Replace ProximityAuthUIDelegate with ProximityAuthClient.

components/proximity_auth/webui/proximity_auth_webui_handler.cc

 // 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.
 
 #include "components/proximity_auth/webui/proximity_auth_webui_handler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/prefs/pref_service.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "base/time/default_tick_clock.h"
 #include "base/values.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_device_whitelist.h"
 #include "components/proximity_auth/ble/pref_names.h"
 #include "components/proximity_auth/bluetooth_connection_finder.h"
 #include "components/proximity_auth/bluetooth_throttler_impl.h"
 #include "components/proximity_auth/bluetooth_util.h"
 #include "components/proximity_auth/client_impl.h"
 #include "components/proximity_auth/cryptauth/base64url.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
-#include "components/proximity_auth/cryptauth/cryptauth_gcm_manager_impl.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/cryptauth/secure_message_delegate.h"
 #include "components/proximity_auth/device_to_device_authenticator.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.h"
-#include "components/proximity_auth/webui/cryptauth_enroller_factory_impl.h"
-#include "components/proximity_auth/webui/proximity_auth_ui_delegate.h"
 #include "components/proximity_auth/webui/reachable_phone_flow.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace proximity_auth {
 
 namespace {
 
 // The UUID of the Smart Lock classic Bluetooth service.
@@ skipping 68 matching lines @@
   sync_state->SetBoolean(kSyncStateRecoveringFromFailure,
                          is_recovering_from_failure);
   sync_state->SetBoolean(kSyncStateOperationInProgress,
                          is_enrollment_in_progress);
   return sync_state;
 }
 
 }  // namespace
 
 ProximityAuthWebUIHandler::ProximityAuthWebUIHandler(
-    ProximityAuthUIDelegate* delegate)
-    : delegate_(delegate),
+    ProximityAuthClient* proximity_auth_client)
+    : proximity_auth_client_(proximity_auth_client),
+      web_contents_initialized_(false),
       weak_ptr_factory_(this) {
-  cryptauth_client_factory_ = delegate_->CreateCryptAuthClientFactory();
+  cryptauth_client_factory_ =
+      proximity_auth_client_->CreateCryptAuthClientFactory();
 }
 
 ProximityAuthWebUIHandler::~ProximityAuthWebUIHandler() {
   LogBuffer::GetInstance()->RemoveObserver(this);
 }
 
 void ProximityAuthWebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "onWebContentsInitialized",
       base::Bind(&ProximityAuthWebUIHandler::OnWebContentsInitialized,
@@ skipping 87 matching lines @@
     scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
     PA_LOG(INFO) << "New unlock keys obtained after device sync:\n"
                  << *unlock_keys;
     web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                      *unlock_keys);
   }
 }
 
 void ProximityAuthWebUIHandler::OnWebContentsInitialized(
     const base::ListValue* args) {
-  if (!gcm_manager_ || !enrollment_manager_ || !device_manager_) {
-    InitGCMManager();
-    InitEnrollmentManager();
-    InitDeviceManager();
+  if (!web_contents_initialized_) {
+    CryptAuthEnrollmentManager* enrollment_manager =
+        proximity_auth_client_->GetCryptAuthEnrollmentManager();
+    if (enrollment_manager)
+      enrollment_manager->AddObserver(this);
+
+    CryptAuthDeviceManager* device_manager =
+        proximity_auth_client_->GetCryptAuthDeviceManager();
+    if (device_manager)
+      device_manager->AddObserver(this);
+
     LogBuffer::GetInstance()->AddObserver(this);
+
+    web_contents_initialized_ = true;
   }
 }
 
 void ProximityAuthWebUIHandler::GetLogMessages(const base::ListValue* args) {
   base::ListValue json_logs;
   for (const auto& log : *LogBuffer::GetInstance()->logs()) {
     json_logs.Append(LogMessageToDictionary(log).release());
   }
   web_ui()->CallJavascriptFunction("LogBufferInterface.onGotLogMessages",
                                    json_logs);
@@ skipping 11 matching lines @@
   if (args->GetSize() != 2 || !args->GetString(0, &public_key_b64) ||
       !args->GetBoolean(1, &make_unlock_key) ||
       !Base64UrlDecode(public_key_b64, &public_key)) {
     PA_LOG(ERROR) << "Invalid arguments to toggleUnlockKey";
     return;
   }
 
   cryptauth::ToggleEasyUnlockRequest request;
   request.set_enable(make_unlock_key);
   request.set_public_key(public_key);
-  *(request.mutable_device_classifier()) = delegate_->GetDeviceClassifier();
+  *(request.mutable_device_classifier()) =
+      proximity_auth_client_->GetDeviceClassifier();
 
   PA_LOG(INFO) << "Toggling unlock key:\n"
                << "    public_key: " << public_key_b64 << "\n"
                << "    make_unlock_key: " << make_unlock_key;
   cryptauth_client_ = cryptauth_client_factory_->CreateInstance();
   cryptauth_client_->ToggleEasyUnlock(
       request, base::Bind(&ProximityAuthWebUIHandler::OnEasyUnlockToggled,
                           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProximityAuthWebUIHandler::OnCryptAuthClientError,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ProximityAuthWebUIHandler::FindEligibleUnlockDevices(
     const base::ListValue* args) {
   cryptauth_client_ = cryptauth_client_factory_->CreateInstance();
 
   cryptauth::FindEligibleUnlockDevicesRequest request;
-  *(request.mutable_device_classifier()) = delegate_->GetDeviceClassifier();
+  *(request.mutable_device_classifier()) =
+      proximity_auth_client_->GetDeviceClassifier();
   cryptauth_client_->FindEligibleUnlockDevices(
       request,
       base::Bind(&ProximityAuthWebUIHandler::OnFoundEligibleUnlockDevices,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProximityAuthWebUIHandler::OnCryptAuthClientError,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ProximityAuthWebUIHandler::FindReachableDevices(
     const base::ListValue* args) {
   if (reachable_phone_flow_) {
     PA_LOG(INFO) << "Waiting for existing ReachablePhoneFlow to finish.";
     return;
   }
 
   reachable_phone_flow_.reset(
       new ReachablePhoneFlow(cryptauth_client_factory_.get()));
   reachable_phone_flow_->Run(
       base::Bind(&ProximityAuthWebUIHandler::OnReachablePhonesFound,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ProximityAuthWebUIHandler::ForceEnrollment(const base::ListValue* args) {
-  if (enrollment_manager_) {
-    enrollment_manager_->ForceEnrollmentNow(
-        cryptauth::INVOCATION_REASON_MANUAL);
+  CryptAuthEnrollmentManager* enrollment_manager =
+      proximity_auth_client_->GetCryptAuthEnrollmentManager();
+  if (enrollment_manager) {
+    enrollment_manager->ForceEnrollmentNow(cryptauth::INVOCATION_REASON_MANUAL);
   }
 }
 
 void ProximityAuthWebUIHandler::ForceDeviceSync(const base::ListValue* args) {
-  if (device_manager_)
-    device_manager_->ForceSyncNow(cryptauth::INVOCATION_REASON_MANUAL);
+  CryptAuthDeviceManager* device_manager =
+      proximity_auth_client_->GetCryptAuthDeviceManager();
+  if (device_manager)
+    device_manager->ForceSyncNow(cryptauth::INVOCATION_REASON_MANUAL);
 }
 
 void ProximityAuthWebUIHandler::ToggleConnection(const base::ListValue* args) {
+  CryptAuthEnrollmentManager* enrollment_manager =
+      proximity_auth_client_->GetCryptAuthEnrollmentManager();
+  CryptAuthDeviceManager* device_manager =
+      proximity_auth_client_->GetCryptAuthDeviceManager();
+  if (!enrollment_manager || !device_manager)
+    return;
+
   std::string b64_public_key;
   std::string public_key;
-  if (!enrollment_manager_ || !device_manager_ || !args->GetSize() ||
+  if (!enrollment_manager || !device_manager || !args->GetSize() ||
       !args->GetString(0, &b64_public_key) ||
       !Base64UrlDecode(b64_public_key, &public_key)) {
     return;
   }
 
   Connection* connection = GetConnection();
-  for (const auto& unlock_key : device_manager_->unlock_keys()) {
+  for (const auto& unlock_key : device_manager->unlock_keys()) {
     if (unlock_key.public_key() == public_key) {
       // Check if there is an existing connection to disconnect from first.
       if (connection && connection->IsConnected() &&
           selected_remote_device_.public_key == public_key) {
         PA_LOG(INFO) << "Disconnecting from "
                      << unlock_key.friendly_device_name() << "["
                      << unlock_key.bluetooth_address() << "]";
         connection->Disconnect();
         return;
       }
 
       // Derive the PSK before connecting to the device.
       PA_LOG(INFO) << "Deriving PSK before connecting to "
                    << unlock_key.friendly_device_name();
-      secure_message_delegate_ = delegate_->CreateSecureMessageDelegate();
+      secure_message_delegate_ =
+          proximity_auth_client_->CreateSecureMessageDelegate();
       secure_message_delegate_->DeriveKey(
-          enrollment_manager_->GetUserPrivateKey(), unlock_key.public_key(),
+          enrollment_manager->GetUserPrivateKey(), unlock_key.public_key(),
           base::Bind(&ProximityAuthWebUIHandler::OnPSKDerived,
                      weak_ptr_factory_.GetWeakPtr(), unlock_key));
 
       return;
     }
   }
 
   PA_LOG(ERROR) << "Unlock key (" << b64_public_key << ") not found";
 }
 
-void ProximityAuthWebUIHandler::InitGCMManager() {
-  gcm_manager_.reset(new CryptAuthGCMManagerImpl(delegate_->GetGCMDriver(),
-                                                 delegate_->GetPrefService()));
-  gcm_manager_->StartListening();
-}
-
-void ProximityAuthWebUIHandler::InitEnrollmentManager() {
-#if defined(OS_CHROMEOS)
-  // TODO(tengs): We initialize a CryptAuthEnrollmentManager here for
-  // development and testing purposes until it is ready to be moved into Chrome.
-  // The public/private key pair has been generated and serialized in a previous
-  // session.
-  // This serialized DeviceInfo proto was previously captured from a real
-  // CryptAuth enrollment, and is replayed here for testing purposes.
-  std::string serialized_device_info;
-  Base64UrlDecode(
-      "IkoIARJGCiEAX_ZjLSq73EVcrarX-7l7No7nSP86GEC322ocSZKqUKwSIQDbEDu9KN7AgLM"
-      "v_lzZZNui9zSOgXCeDpLhS2tgrYVXijoEbGlua0IFZW4tVVNKSggBEkYKIQBf9mMtKrvcRV"
-      "ytqtf7uXs2judI_zoYQLfbahxJkqpQrBIhANsQO70o3sCAsy_-XNlk26L3NI6BcJ4OkuFLa"
-      "2CthVeKam9Nb3ppbGxhLzUuMCAoWDExOyBDck9TIHg4Nl82NCA3MTM0LjAuMCkgQXBwbGVX"
-      "ZWJLaXQvNTM3LjM2IChLSFRNTCwgbGlrZSBHZWNrbykgQ2hyb21lLzQ1LjAuMjQyMi4wIFN"
-      "hZmFyaS81MzcuMzZwLYoBAzEuMJABAZoBIG1rYWVtaWdob2xlYmNnY2hsa2JhbmttaWhrbm"
-      "9qZWFrsAHDPuoBHEJLZEluZWxFZk05VG1adGV3eTRGb19RV1Vicz2AAgKyBqIBQVBBOTFiS"
-      "FZDdlJJNGJFSXppMmFXOTBlZ044eHFBYkhWYnJwSVFuMTk3bWltd3RWWTZYN0JEcEI4Szg3"
-      "RjRubkJnejdLX1BQV2xkcUtDRVhiZkFiMGwyN1VaQXgtVjBWbEE4WlFwdkhETmpHVlh4RlV"
-      "WRDFNY1AzNTgtYTZ3eHRpVG5LQnpMTEVIT1F6Ujdpb0lUMzRtWWY1VmNhbmhPZDh3ugYgs9"
-      "7-c7qNUzzLeEqVCDXb_EaJ8wC3iie_Lpid44iuAh3CPo0CCugBCiMIARACGgi5wHHa82avM"
-      "ioQ7y8xhiUBs7Um73ZC1vQlzzIBABLAAeCqGnWF7RwtnmdfIQJoEqXoXrH1qLw4yqUAA1TW"
-      "M1qxTepJOdDHrh54eiejobW0SKpHqTlZIyiK3ObHAPdfzFum1l640RFdFGZTTTksZFqfD9O"
-      "dftoi0pMrApob4gXj8Pv2g22ArX55BiH56TkTIcDcEE3KKnA_2G0INT1y_clZvZfDw1n0WP"
-      "0Xdg1PLLCOb46WfDWUhHvUk3GzUce8xyxsjOkiZUNh8yvhFXaP2wJgVKVWInf0inuofo9Za"
-      "7p44hIgHgKJIr_4fuVs9Ojf0KcMzxoJTbFUGg58jglUAKFfJBLKPpMBeWEyOS5pQUdTNFZ1"
-      "bF9JVWY4YTJDSmJNbXFqaWpYUFYzaVV5dmJXSVRrR3d1bFRaVUs3RGVZczJtT0h5ZkQ1NWR"
-      "HRXEtdnJTdVc4VEZ2Z1haa2xhVEZTN0dqM2xCVUktSHd5Z0h6bHZHX2NGLWtzQmw0dXdveG"
-      "VPWE1hRlJ3WGJHVUU1Tm9sLS1mdkRIcGVZVnJR",
-      &serialized_device_info);
-  cryptauth::GcmDeviceInfo device_info;
-  device_info.ParseFromString(serialized_device_info);
-
-  enrollment_manager_.reset(new CryptAuthEnrollmentManager(
-      make_scoped_ptr(new base::DefaultClock()),
-      make_scoped_ptr(new CryptAuthEnrollerFactoryImpl(delegate_)),
-      delegate_->CreateSecureMessageDelegate(), device_info, gcm_manager_.get(),
-      delegate_->GetPrefService()));
-  enrollment_manager_->AddObserver(this);
-  enrollment_manager_->Start();
-#endif
-}
-
-void ProximityAuthWebUIHandler::InitDeviceManager() {
-  // TODO(tengs): We initialize a CryptAuthDeviceManager here for
-  // development and testing purposes until it is ready to be moved into Chrome.
-  device_manager_.reset(new CryptAuthDeviceManager(
-      make_scoped_ptr(new base::DefaultClock()),
-      delegate_->CreateCryptAuthClientFactory(), gcm_manager_.get(),
-      delegate_->GetPrefService()));
-  device_manager_->AddObserver(this);
-  device_manager_->Start();
-}
-
 void ProximityAuthWebUIHandler::OnCryptAuthClientError(
     const std::string& error_message) {
   PA_LOG(WARNING) << "CryptAuth request failed: " << error_message;
   base::StringValue error_string(error_message);
   web_ui()->CallJavascriptFunction("CryptAuthInterface.onError", error_string);
 }
 
 void ProximityAuthWebUIHandler::OnEasyUnlockToggled(
     const cryptauth::ToggleEasyUnlockResponse& response) {
   web_ui()->CallJavascriptFunction("CryptAuthInterface.onUnlockKeyToggled");
@@ skipping 41 matching lines @@
                << "Enrollment State: \n" << *enrollment_state
                << "Device Sync State: \n" << *device_sync_state
                << "Unlock Keys: \n" << *unlock_keys;
   web_ui()->CallJavascriptFunction("LocalStateInterface.onGotLocalState",
                                    *enrollment_state, *device_sync_state,
                                    *unlock_keys);
 }
 
 scoped_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::GetEnrollmentStateDictionary() {
-  if (!enrollment_manager_)
+  CryptAuthEnrollmentManager* enrollment_manager =
+      proximity_auth_client_->GetCryptAuthEnrollmentManager();
+  if (!enrollment_manager)
     return make_scoped_ptr(new base::DictionaryValue());
 
   return CreateSyncStateDictionary(
-      enrollment_manager_->GetLastEnrollmentTime().ToJsTime(),
-      enrollment_manager_->GetTimeToNextAttempt().InMillisecondsF(),
-      enrollment_manager_->IsRecoveringFromFailure(),
-      enrollment_manager_->IsEnrollmentInProgress());
+      enrollment_manager->GetLastEnrollmentTime().ToJsTime(),
+      enrollment_manager->GetTimeToNextAttempt().InMillisecondsF(),
+      enrollment_manager->IsRecoveringFromFailure(),
+      enrollment_manager->IsEnrollmentInProgress());
 }
 
 scoped_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::GetDeviceSyncStateDictionary() {
-  if (!device_manager_)
+  CryptAuthDeviceManager* device_manager =
+      proximity_auth_client_->GetCryptAuthDeviceManager();
+  if (!device_manager)
     return make_scoped_ptr(new base::DictionaryValue());
 
   return CreateSyncStateDictionary(
-      device_manager_->GetLastSyncTime().ToJsTime(),
-      device_manager_->GetTimeToNextAttempt().InMillisecondsF(),
-      device_manager_->IsRecoveringFromFailure(),
-      device_manager_->IsSyncInProgress());
+      device_manager->GetLastSyncTime().ToJsTime(),
+      device_manager->GetTimeToNextAttempt().InMillisecondsF(),
+      device_manager->IsRecoveringFromFailure(),
+      device_manager->IsSyncInProgress());
 }
 
 scoped_ptr<base::ListValue> ProximityAuthWebUIHandler::GetUnlockKeysList() {
   scoped_ptr<base::ListValue> unlock_keys(new base::ListValue());
-  if (!device_manager_)
+  CryptAuthDeviceManager* device_manager =
+      proximity_auth_client_->GetCryptAuthDeviceManager();
+  if (!device_manager)
     return unlock_keys;
 
-  for (const auto& unlock_key : device_manager_->unlock_keys()) {
+  for (const auto& unlock_key : device_manager->unlock_keys()) {
     unlock_keys->Append(ExternalDeviceInfoToDictionary(unlock_key));
   }
 
   return unlock_keys;
 }
 
 Connection* ProximityAuthWebUIHandler::GetConnection() {
   Connection* connection = connection_.get();
   if (client_) {
     DCHECK(!connection);
@@ skipping 35 matching lines @@
   connection_finder_->Find(
       base::Bind(&ProximityAuthWebUIHandler::OnConnectionFound,
                  weak_ptr_factory_.GetWeakPtr()));
 
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                    *GetUnlockKeysList());
 }
 
 void ProximityAuthWebUIHandler::FindBluetoothLowEnergyConnection(
     const RemoteDevice& remote_device) {
-  PrefService* pref_service = delegate_->GetPrefService();
+  PrefService* pref_service = proximity_auth_client_->GetPrefService();
   if (!pref_service->FindPreference(
           prefs::kBluetoothLowEnergyDeviceWhitelist)) {
     PA_LOG(ERROR) << "Please enable the BLE experiment in chrome://flags.";
     return;
   }
 
   PA_LOG(INFO) << "Finding Bluetooth Low Energy device " << remote_device.name;
   if (!bluetooth_throttler_) {
     bluetooth_throttler_.reset(new BluetoothThrottlerImpl(
         make_scoped_ptr(new base::DefaultTickClock())));
   }
 
-  ble_device_whitelist_.reset(
-      new BluetoothLowEnergyDeviceWhitelist(delegate_->GetPrefService()));
+  ble_device_whitelist_.reset(new BluetoothLowEnergyDeviceWhitelist(
+      proximity_auth_client_->GetPrefService()));
 
   // TODO(tengs): Set a timeout to stop the connection finder eventually.
   connection_finder_.reset(new BluetoothLowEnergyConnectionFinder(
       kBLESmartLockServiceUUID, kBLEToPeripheralCharUUID,
       kBLEFromPeripheralCharUUID, ble_device_whitelist_.get(),
       bluetooth_throttler_.get(), 3));
   connection_finder_->Find(
       base::Bind(&ProximityAuthWebUIHandler::OnConnectionFound,
                  weak_ptr_factory_.GetWeakPtr()));
 
@@ skipping 22 matching lines @@
   connection_->AddObserver(this);
 
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                    *GetUnlockKeysList());
 
   // TODO(tengs): Create an authenticator for BLE connections.
   if (selected_remote_device_.bluetooth_address.empty())
     return;
 
   authenticator_.reset(new DeviceToDeviceAuthenticator(
-      connection_.get(), delegate_->GetAccountId(),
-      delegate_->CreateSecureMessageDelegate()));
+      connection_.get(), proximity_auth_client_->GetAccountId(),
+      proximity_auth_client_->CreateSecureMessageDelegate()));
   authenticator_->Authenticate(
       base::Bind(&ProximityAuthWebUIHandler::OnAuthenticationResult,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ProximityAuthWebUIHandler::CreateStatusUpdateClient() {
   client_.reset(new ClientImpl(connection_.Pass(), secure_context_.Pass()));
   client_->AddObserver(this);
 }
 
 scoped_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::ExternalDeviceInfoToDictionary(
     const cryptauth::ExternalDeviceInfo& device_info) {
   std::string base64_public_key;
   Base64UrlEncode(device_info.public_key(), &base64_public_key);
 
   // Set the fields in the ExternalDeviceInfo proto.
   scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
   dictionary->SetString(kExternalDevicePublicKey, base64_public_key);
   dictionary->SetString(kExternalDeviceFriendlyName,
                         device_info.friendly_device_name());
   dictionary->SetString(kExternalDeviceBluetoothAddress,
                         device_info.bluetooth_address());
   dictionary->SetBoolean(kExternalDeviceUnlockKey, device_info.unlock_key());
   dictionary->SetString(kExternalDeviceConnectionStatus,
                         kExternalDeviceDisconnected);
 
-  if (!device_manager_)
+  CryptAuthDeviceManager* device_manager =
+      proximity_auth_client_->GetCryptAuthDeviceManager();
+  if (!device_manager)
     return dictionary;
 
   // If |device_info| is a known unlock key, then combine the proto data with
   // the corresponding local device data (e.g. connection status and remote
   // status updates).
   std::string public_key = device_info.public_key();
   auto iterator = std::find_if(
-      device_manager_->unlock_keys().begin(),
-      device_manager_->unlock_keys().end(),
+      device_manager->unlock_keys().begin(),
+      device_manager->unlock_keys().end(),
       [&public_key](const cryptauth::ExternalDeviceInfo& unlock_key) {
         return unlock_key.public_key() == public_key;
       });
 
-  if (iterator == device_manager_->unlock_keys().end() ||
+  if (iterator == device_manager->unlock_keys().end() ||
       selected_remote_device_.public_key != device_info.public_key())
     return dictionary;
 
   // Fill in the current Bluetooth connection status.
   std::string connection_status = kExternalDeviceDisconnected;
   Connection* connection = GetConnection();
   if (connection && connection->IsConnected()) {
     connection_status = kExternalDeviceConnected;
   } else if (connection_finder_) {
     connection_status = kExternalDeviceConnecting;
@@ skipping 66 matching lines @@
                << "\n  trust_agent_state: "
                << static_cast<int>(status_update.trust_agent_state);
 
   last_remote_status_update_.reset(new RemoteStatusUpdate(status_update));
   scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                    *unlock_keys);
 }
 
 }  // namespace proximity_auth