Introduce CryptAuthClient, a class capable of performing all CryptAuth APIs.

components/proximity_auth/cryptauth/cryptauth_client.h

Index: components/proximity_auth/cryptauth/cryptauth_client.h
diff --git a/components/proximity_auth/cryptauth/cryptauth_client.h b/components/proximity_auth/cryptauth/cryptauth_client.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2b346695de44be0d4ce7e76afef245a03e6d33d
--- /dev/null
+++ b/components/proximity_auth/cryptauth/cryptauth_client.h
@@ -0,0 +1,158 @@
+// 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.
+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();
+
+  // The GetMyDevices API request returns a list of devices that the user has
+  // registered with CryptAuth.
+  typedef base::Callback<void(const cryptauth::GetMyDevicesResponse&)>
+      GetMyDevicesCallback;
+  void GetMyDevices(const cryptauth::GetMyDevicesRequest& request,
+                    const GetMyDevicesCallback& callback,
+                    const ErrorCallback& error_callback);
+
+  // The FindEligibleUnlockDevices API request returns a list of devices
+  // eligible to be an "unlock key", that is a device capable of unlocking other
+  // devices.
+  // The |bluetooth_address| field should contain the Bluetooth address of the

[Ilya Sherman, 2014/12/03 03:16:37]

I think it's really weird to refer to |bluetooth_address| here, when it isn't
directly declared or referenced in this file.  I really think it would be better
to just have one copy of the documentation, and for that to live in the .proto
file.  It seems implausible to me that clients of this file would have trouble
finding that documentation, but would still be able to use this code, since the
methods require instantiated protobuf objects.

Maybe we can compromise by having high-level docs duplicated both here and in
the .proto file, but have the low-level details be documented only in the .proto
file?  I saw your concern about keeping the .proto file in sync with the server
copy; but we have to do that anyway in order to use it.

[Tim Song, 2014/12/05 00:00:36]

I get what you're saying. I removed all the documentation here, and added a
comment to look at the proto file.

+  // local device, which is sent to the eligible devices so they can connect to
+  // the local device.
+  typedef base::Callback<void(
+      const cryptauth::FindEligibleUnlockDevicesResponse&)>
+      FindEligibleUnlockDevicesCallback;
+  void FindEligibleUnlockDevices(
+      const cryptauth::FindEligibleUnlockDevicesRequest& request,
+      const FindEligibleUnlockDevicesCallback& callback,
+      const ErrorCallback& error_callback);
+
+  // The SendDeviceSyncTickle API request tells the server to "tickle" all
+  // the user's registered devices, so they can sync the latest device state.
+  typedef base::Callback<void(const cryptauth::SendDeviceSyncTickleResponse&)>
+      SendDeviceSyncTickleCallback;
+  void SendDeviceSyncTickle(
+      const cryptauth::SendDeviceSyncTickleRequest& request,
+      const SendDeviceSyncTickleCallback& callback,
+      const ErrorCallback& error_callback);
+
+  // The ToggleEasyUnlock API request tells the server to designate devices as
+  // an "unlock key" that can unlock other devices. The |turn_on| argument is
+  // used to enable or disable the device given by its |public_key|.  If
+  // |apply_to_all| is true, then |public_key| will be ignored, and |turn_on|
+  // will be applied to all eligible unlock keys.
+  typedef base::Callback<void(const cryptauth::ToggleEasyUnlockResponse&)>
+      ToggleEasyUnlockCallback;
+  void ToggleEasyUnlock(const cryptauth::ToggleEasyUnlockRequest& request,
+                        const ToggleEasyUnlockCallback& callback,
+                        const ErrorCallback& error_callback);
+
+  // The SetupEnrollment API request is the first of a two step process to
+  // enroll the device with CryptAuth. See FinishEnrollment for the last step of
+  // enrollment.
+  // You most likely will not use this API directly. Look instead at
+  // CryptAuthEnroller, which handles the entire enrollment operation.
+  typedef base::Callback<void(const cryptauth::SetupEnrollmentResponse&)>
+      SetupEnrollmentCallback;
+  void SetupEnrollment(const cryptauth::SetupEnrollmentRequest& request,
+                       const SetupEnrollmentCallback& callback,
+                       const ErrorCallback& error_callback);
+
+  // The FinishEnrollment API request is the last of a two step process to
+  // enroll the device with CryptAuth. See for the SetupEnrollment for the

[Ilya Sherman, 2014/12/03 03:16:37]

nit: "See for the" -> "See"

[Tim Song, 2014/12/05 00:00:36]

Done.

+  // first step of enrollment.
+  // You most likely will not use this API directly. Look instead at
+  // CryptAuthEnroller, which handles the entire enrollment operation.
+  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 and takes ownership of it.

[Ilya Sherman, 2014/12/03 03:16:37]

nit: I'm not sure what "and takes ownership of it" means here -- really we are
transferring ownership to the caller, right?

[Tim Song, 2014/12/05 00:00:36]

Because the function is protected, the caller will always be the object itself.
I made this much clearer by making the return value a scoped_ptr like you
suggested.

+  // Exposed for testing.
+  virtual CryptAuthApiCallFlow* CreateFlow(const GURL& request_url);

[Ilya Sherman, 2014/12/03 03:16:37]

Please return a scoped_ptr here.

[Tim Song, 2014/12/05 00:00:36]

Done.

+
+ 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_;
+
+  // Fetchs the access token authorizing the API calls.

[Ilya Sherman, 2014/12/03 03:16:37]

nit: "Fetchs" -> "Fetches"

[Tim Song, 2014/12/05 00:00:36]

Done.

+  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