Migrate weave-related classes from proximity_auth/ble to cryptauth/ble.

components/proximity_auth/device_to_device_authenticator.h

 // Copyright 2015 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_DEVICE_TO_DEVICE_AUTHENTICATOR_H
 #define COMPONENTS_PROXIMITY_DEVICE_TO_DEVICE_AUTHENTICATOR_H
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "components/cryptauth/connection.h"
+#include "components/cryptauth/connection_observer.h"
 #include "components/proximity_auth/authenticator.h"
-#include "components/proximity_auth/connection_observer.h"
 
 namespace base {
 class Timer;
 };
 
 namespace cryptauth {
 class SecureMessageDelegate;
 }
 
 namespace proximity_auth {
 
-class Connection;
-
 // Authenticator implementation using the "device to device" protocol, which is
 // in turn built on top of the SecureMessage library.
 // This protocol contains the following steps (local device is the initiator):
 //   1. Both initiator and responder devices generate a temporary key pair for
 //      the session.
 //   2. Initiator sends [Hello] message to responder device, which contains the
 //      initiator's session public key.
 //   3. Responder responds with a [Responder Auth] message, containing its
 //      session public key and data that allows the initiator to assert the
 //      identity of the responder.
 //   4. Initiator sends [Initiator Auth] message, containing data allowing the
 //      responder to assert the identity of the initiator.
 //   5. Both devices derive a symmetric key by running a key agreement protocol
 //      session public keys they obtain from from the messages above. This
 //      symmetric key is used in the subsequent SecureContext.
 // The authentication protocol fails if any of the steps above fail.
 // This protocol requires exclusive use of the connection. No other message
 // should be sent or received while authentication is in progress.
 class DeviceToDeviceAuthenticator : public Authenticator,
-                                    public ConnectionObserver {
+                                    public cryptauth::ConnectionObserver {
  public:
   // Creates the instance:
   // |connection|: The connection to the remote device, which must be in a
   //     connected state. Not owned.
   // |account_id|: The canonical account id of the user who is the owner of both
   //     the local and remote devices.
   // |secure_message_delegate|: Handles the SecureMessage crypto operations.
-  DeviceToDeviceAuthenticator(Connection* connection,
+  DeviceToDeviceAuthenticator(cryptauth::Connection* connection,
                               const std::string& account_id,
                               std::unique_ptr<cryptauth::SecureMessageDelegate>
                                   secure_message_delegate);
 
   ~DeviceToDeviceAuthenticator() override;
 
   // Authenticator:
   void Authenticate(const AuthenticationCallback& callback) override;
 
  protected:
@@ skipping 37 matching lines @@
   // Called when the authentication flow fails, and logs |error_message|. The
   // overloaded version specifies the Result to be reported;
   // otherwise, a FAILURE result will be reported.
   void Fail(const std::string& error_message);
   void Fail(const std::string& error_message, Result result);
 
   // Called when the authentication flow succeeds.
   void Succeed();
 
   // ConnectionObserver:
-  void OnConnectionStatusChanged(Connection* connection,
-                                 Connection::Status old_status,
-                                 Connection::Status new_status) override;
-  void OnMessageReceived(const Connection& connection,
-                         const WireMessage& message) override;
-  void OnSendCompleted(const Connection& connection,
-                       const WireMessage& message,
+  void OnConnectionStatusChanged(
+      cryptauth::Connection* connection,
+      cryptauth::Connection::Status old_status,
+      cryptauth::Connection::Status new_status) override;
+  void OnMessageReceived(const cryptauth::Connection& connection,
+                         const cryptauth::WireMessage& message) override;
+  void OnSendCompleted(const cryptauth::Connection& connection,
+                       const cryptauth::WireMessage& message,
                        bool success) override;
 
   // The connection to the remote device. It is expected to be in the CONNECTED
   // state at all times during authentication.
   // Not owned, and must outlive this instance.
-  Connection* const connection_;
+  cryptauth::Connection* const connection_;
 
   // The account id of the user who owns the local and remote devices. This is
   // normally an email address, and should be canonicalized.
   const std::string account_id_;
 
   // Handles SecureMessage crypto operations.
   std::unique_ptr<cryptauth::SecureMessageDelegate> secure_message_delegate_;
 
   // The current state in the authentication flow.
   State state_;
@@ skipping 17 matching lines @@
   std::string session_symmetric_key_;
 
   base::WeakPtrFactory<DeviceToDeviceAuthenticator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceToDeviceAuthenticator);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_DEVICE_TO_DEVICE_AUTHENTICATOR_H