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

components/proximity_auth/messenger_impl.cc

 // 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.
 
 #include "components/proximity_auth/messenger_impl.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
-#include "components/proximity_auth/connection.h"
+#include "components/cryptauth/connection.h"
+#include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger_observer.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.h"
-#include "components/proximity_auth/wire_message.h"
 
 namespace proximity_auth {
 namespace {
 
 // The key names of JSON fields for messages sent between the devices.
 const char kTypeKey[] = "type";
 const char kNameKey[] = "name";
 const char kDataKey[] = "data";
 const char kEncryptedDataKey[] = "encrypted_data";
 
@@ skipping 28 matching lines @@
 // wrapper that should only be called when the |message| is known to specify its
 // message type, i.e. this should not be called for untrusted input.
 std::string GetMessageType(const base::DictionaryValue& message) {
   std::string type;
   message.GetString(kTypeKey, &type);
   return type;
 }
 
 }  // namespace
 
-MessengerImpl::MessengerImpl(std::unique_ptr<Connection> connection,
+MessengerImpl::MessengerImpl(std::unique_ptr<cryptauth::Connection> connection,
                              std::unique_ptr<SecureContext> secure_context)
     : connection_(std::move(connection)),
       secure_context_(std::move(secure_context)),
       weak_ptr_factory_(this) {
   DCHECK(connection_->IsConnected());
   connection_->AddObserver(this);
 
   // TODO(tengs): We need CryptAuth to report if the phone runs iOS or Android,
   // rather than relying on this heuristic.
   if (connection_->remote_device().bluetooth_type ==
@@ skipping 90 matching lines @@
 
   pending_message_.reset(new PendingMessage(queued_messages_.front()));
   queued_messages_.pop_front();
 
   secure_context_->Encode(pending_message_->json_message,
                           base::Bind(&MessengerImpl::OnMessageEncoded,
                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MessengerImpl::OnMessageEncoded(const std::string& encoded_message) {
-  connection_->SendMessage(base::MakeUnique<WireMessage>(encoded_message));
+  connection_->SendMessage(
+      base::MakeUnique<cryptauth::WireMessage>(encoded_message));
 }
 
 void MessengerImpl::OnMessageDecoded(const std::string& decoded_message) {
   // TODO(tengs): Unify the iOS status update protocol with the existing Android
   // protocol, so we don't have this special case.
   if (decoded_message == kScreenUnlocked || decoded_message == kScreenLocked) {
     RemoteStatusUpdate update;
     update.user_presence =
         (decoded_message == kScreenUnlocked ? USER_PRESENT : USER_ABSENT);
     update.secure_screen_lock_state = SECURE_SCREEN_LOCK_ENABLED;
@@ skipping 106 matching lines @@
   queued_messages_.push_back(PendingMessage(std::string(kPollScreenState)));
   ProcessMessageQueue();
 
   // Schedules the next message in |kPollingIntervalSeconds|.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&MessengerImpl::PollScreenStateForIOS,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kIOSPollingIntervalSeconds));
 }
 
-void MessengerImpl::OnConnectionStatusChanged(Connection* connection,
-                                              Connection::Status old_status,
-                                              Connection::Status new_status) {
+void MessengerImpl::OnConnectionStatusChanged(
+    cryptauth::Connection* connection,
+    cryptauth::Connection::Status old_status,
+    cryptauth::Connection::Status new_status) {
   DCHECK_EQ(connection, connection_.get());
-  if (new_status == Connection::DISCONNECTED) {
+  if (new_status == cryptauth::Connection::DISCONNECTED) {
     PA_LOG(INFO) << "Secure channel disconnected...";
     connection_->RemoveObserver(this);
     for (auto& observer : observers_)
       observer.OnDisconnected();
     // TODO(isherman): Determine whether it's also necessary/appropriate to fire
     // this notification from the destructor.
   }
 }
 
-void MessengerImpl::OnMessageReceived(const Connection& connection,
-                                      const WireMessage& wire_message) {
+void MessengerImpl::OnMessageReceived(
+    const cryptauth::Connection& connection,
+    const cryptauth::WireMessage& wire_message) {
   secure_context_->Decode(wire_message.payload(),
                           base::Bind(&MessengerImpl::OnMessageDecoded,
                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
-void MessengerImpl::OnSendCompleted(const Connection& connection,
-                                    const WireMessage& wire_message,
+void MessengerImpl::OnSendCompleted(const cryptauth::Connection& connection,
+                                    const cryptauth::WireMessage& wire_message,
                                     bool success) {
   if (!pending_message_) {
     PA_LOG(ERROR) << "Unexpected message sent.";
     return;
   }
 
   // In the common case, wait for a response from the remote device.
   // Don't wait if the message could not be sent, as there won't ever be a
   // response in that case. Likewise, don't wait for a response to local
   // event messages, as there is no response for such messages.
@@ skipping 15 matching lines @@
   } else {
     PA_LOG(ERROR) << "Message of unknown type '" << pending_message_->type
                   << "' sent.";
   }
 
   pending_message_.reset();
   ProcessMessageQueue();
 }
 
 }  // namespace proximity_auth