1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_PROXIMITY_AUTH_CRYPT_AUTH_CLIENT_H
#define COMPONENTS_PROXIMITY_AUTH_CRYPT_AUTH_CLIENT_H
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
#include "net/url_request/url_request_context_getter.h"
#include "url/gurl.h"
class OAuth2TokenService;
namespace proximity_auth {
class CryptAuthAccessTokenFetcher;
class CryptAuthApiCallFlow;
// Use CryptAuthClient to make API requests to the CryptAuth service, which
// manages cryptographic credentials (ie. public keys) for a user's devices.
// CryptAuthClient only processes one request, so create a new instance for each
// request you make. DO NOT REUSE.
// For documentation on each API call, see
// components/proximity_auth/cryptauth/proto/cryptauth_api.proto
class CryptAuthClient {
public:
typedef base::Callback<void(const std::string&)> ErrorCallback;
// Creates the client using |url_request_context| to make the HTTP request.
// CryptAuthClient takes ownership of |access_token_fetcher|, which provides
// the access token authorizing CryptAuth requests.
CryptAuthClient(
scoped_ptr<CryptAuthAccessTokenFetcher> access_token_fetcher,
scoped_refptr<net::URLRequestContextGetter> url_request_context);
virtual ~CryptAuthClient();
// GetMyDevices
typedef base::Callback<void(const cryptauth::GetMyDevicesResponse&)>
GetMyDevicesCallback;
void GetMyDevices(const cryptauth::GetMyDevicesRequest& request,
const GetMyDevicesCallback& callback,
const ErrorCallback& error_callback);
// FindEligibleUnlockDevices
typedef base::Callback<void(
const cryptauth::FindEligibleUnlockDevicesResponse&)>
FindEligibleUnlockDevicesCallback;
void FindEligibleUnlockDevices(
const cryptauth::FindEligibleUnlockDevicesRequest& request,
const FindEligibleUnlockDevicesCallback& callback,
const ErrorCallback& error_callback);
// SendDeviceSyncTickle
typedef base::Callback<void(const cryptauth::SendDeviceSyncTickleResponse&)>
SendDeviceSyncTickleCallback;
void SendDeviceSyncTickle(
const cryptauth::SendDeviceSyncTickleRequest& request,
const SendDeviceSyncTickleCallback& callback,
const ErrorCallback& error_callback);
// ToggleEasyUnlock
typedef base::Callback<void(const cryptauth::ToggleEasyUnlockResponse&)>
ToggleEasyUnlockCallback;
void ToggleEasyUnlock(const cryptauth::ToggleEasyUnlockRequest& request,
const ToggleEasyUnlockCallback& callback,
const ErrorCallback& error_callback);
// SetupEnrollment
typedef base::Callback<void(const cryptauth::SetupEnrollmentResponse&)>
SetupEnrollmentCallback;
void SetupEnrollment(const cryptauth::SetupEnrollmentRequest& request,
const SetupEnrollmentCallback& callback,
const ErrorCallback& error_callback);
// FinishEnrollment
typedef base::Callback<void(const cryptauth::FinishEnrollmentResponse&)>
FinishEnrollmentCallback;
void FinishEnrollment(const cryptauth::FinishEnrollmentRequest& request,
const FinishEnrollmentCallback& callback,
const ErrorCallback& error_callback);
protected:
// Creates a CryptAuthApiCallFlow object. Exposed for testing.
virtual scoped_ptr<CryptAuthApiCallFlow> CreateFlow(const GURL& request_url);
private:
// Starts a call to the API given by |request_path|, with the templated
// request and response types. The client first fetches the access token and
// then makes the HTTP request.
template <class RequestProto, class ResponseProto>
void MakeApiCall(
const std::string& request_path,
const RequestProto& request_proto,
const base::Callback<void(const ResponseProto&)>& response_callback,
const ErrorCallback& error_callback);
// Called when the access token is obtained so the API request can be made.
template <class ResponseProto>
void OnAccessTokenFetched(
const std::string& serialized_request,
const base::Callback<void(const ResponseProto&)>& response_callback,
const std::string& access_token);
// Called with CryptAuthApiCallFlow completes successfully to deserialize and
// return the result.
template <class ResponseProto>
void OnFlowSuccess(
const base::Callback<void(const ResponseProto&)>& result_callback,
const std::string& serialized_response);
// Called when the current API call fails at any step.
void OnApiCallFailed(const std::string& error_message);
// The context for network requests.
scoped_refptr<net::URLRequestContextGetter> url_request_context_;
// Fetches the access token authorizing the API calls.
scoped_ptr<CryptAuthAccessTokenFetcher> access_token_fetcher_;
// Handles the current API call.
scoped_ptr<CryptAuthApiCallFlow> flow_;
// URL path of the current request.
std::string request_path_;
// Called when the current request fails.
ErrorCallback error_callback_;
base::WeakPtrFactory<CryptAuthClient> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(CryptAuthClient);
};
} // namespace proximity_auth
#endif // COMPONENTS_PROXIMITY_AUTH_CRYPT_AUTH_CLIENT_H
|
