Moved //components/proximity_auth/cryptauth to //components/cryptauth.

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 <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "base/time/default_tick_clock.h"
 #include "base/values.h"
+#include "components/cryptauth/cryptauth_enrollment_manager.h"
+#include "components/cryptauth/secure_message_delegate.h"
 #include "components/prefs/pref_service.h"
 #include "components/proximity_auth/ble/pref_names.h"
 #include "components/proximity_auth/bluetooth_connection_finder.h"
-#include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
-#include "components/proximity_auth/cryptauth/secure_message_delegate.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger.h"
 #include "components/proximity_auth/remote_device_life_cycle_impl.h"
 #include "components/proximity_auth/remote_device_loader.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.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"
@@ skipping 155 matching lines @@
       "LocalStateInterface.onEnrollmentStateChanged", *enrollment_state);
 }
 
 void ProximityAuthWebUIHandler::OnSyncStarted() {
   web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onDeviceSyncStateChanged",
       *GetDeviceSyncStateDictionary());
 }
 
 void ProximityAuthWebUIHandler::OnSyncFinished(
-    CryptAuthDeviceManager::SyncResult sync_result,
-    CryptAuthDeviceManager::DeviceChangeResult device_change_result) {
+    cryptauth::CryptAuthDeviceManager::SyncResult sync_result,
+    cryptauth::CryptAuthDeviceManager::DeviceChangeResult
+        device_change_result) {
   std::unique_ptr<base::DictionaryValue> device_sync_state =
       GetDeviceSyncStateDictionary();
   PA_LOG(INFO) << "Device sync completed with result="
                << static_cast<int>(sync_result) << ":\n" << *device_sync_state;
   web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onDeviceSyncStateChanged", *device_sync_state);
 
   if (device_change_result ==
-      CryptAuthDeviceManager::DeviceChangeResult::CHANGED) {
+      cryptauth::CryptAuthDeviceManager::DeviceChangeResult::CHANGED) {
     std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
     PA_LOG(INFO) << "New unlock keys obtained after device sync:\n"
                  << *unlock_keys;
     web_ui()->CallJavascriptFunctionUnsafe(
         "LocalStateInterface.onUnlockKeysChanged", *unlock_keys);
   }
 }
 
 void ProximityAuthWebUIHandler::OnWebContentsInitialized(
     const base::ListValue* args) {
   if (!web_contents_initialized_) {
-    CryptAuthEnrollmentManager* enrollment_manager =
+    cryptauth::CryptAuthEnrollmentManager* enrollment_manager =
         proximity_auth_client_->GetCryptAuthEnrollmentManager();
     if (enrollment_manager)
       enrollment_manager->AddObserver(this);
 
-    CryptAuthDeviceManager* device_manager =
+    cryptauth::CryptAuthDeviceManager* device_manager =
         proximity_auth_client_->GetCryptAuthDeviceManager();
     if (device_manager)
       device_manager->AddObserver(this);
 
     LogBuffer::GetInstance()->AddObserver(this);
 
     web_contents_initialized_ = true;
   }
 }
 
@@ skipping 64 matching lines @@
   }
 
   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) {
-  CryptAuthEnrollmentManager* enrollment_manager =
+  cryptauth::CryptAuthEnrollmentManager* enrollment_manager =
       proximity_auth_client_->GetCryptAuthEnrollmentManager();
   if (enrollment_manager) {
     enrollment_manager->ForceEnrollmentNow(cryptauth::INVOCATION_REASON_MANUAL);
   }
 }
 
 void ProximityAuthWebUIHandler::ForceDeviceSync(const base::ListValue* args) {
-  CryptAuthDeviceManager* device_manager =
+  cryptauth::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 =
+  cryptauth::CryptAuthEnrollmentManager* enrollment_manager =
       proximity_auth_client_->GetCryptAuthEnrollmentManager();
-  CryptAuthDeviceManager* device_manager =
+  cryptauth::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() ||
       !args->GetString(0, &b64_public_key) ||
       !base::Base64UrlDecode(b64_public_key,
                              base::Base64UrlDecodePolicy::REQUIRE_PADDING,
@@ skipping 82 matching lines @@
                << "Enrollment State: \n" << *enrollment_state
                << "Device Sync State: \n" << *device_sync_state
                << "Unlock Keys: \n" << *unlock_keys;
   web_ui()->CallJavascriptFunctionUnsafe("LocalStateInterface.onGotLocalState",
                                          *enrollment_state, *device_sync_state,
                                          *unlock_keys);
 }
 
 std::unique_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::GetEnrollmentStateDictionary() {
-  CryptAuthEnrollmentManager* enrollment_manager =
+  cryptauth::CryptAuthEnrollmentManager* enrollment_manager =
       proximity_auth_client_->GetCryptAuthEnrollmentManager();
   if (!enrollment_manager)
     return base::MakeUnique<base::DictionaryValue>();
 
   return CreateSyncStateDictionary(
       enrollment_manager->GetLastEnrollmentTime().ToJsTime(),
       enrollment_manager->GetTimeToNextAttempt().InMillisecondsF(),
       enrollment_manager->IsRecoveringFromFailure(),
       enrollment_manager->IsEnrollmentInProgress());
 }
 
 std::unique_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::GetDeviceSyncStateDictionary() {
-  CryptAuthDeviceManager* device_manager =
+  cryptauth::CryptAuthDeviceManager* device_manager =
       proximity_auth_client_->GetCryptAuthDeviceManager();
   if (!device_manager)
     return base::MakeUnique<base::DictionaryValue>();
 
   return CreateSyncStateDictionary(
       device_manager->GetLastSyncTime().ToJsTime(),
       device_manager->GetTimeToNextAttempt().InMillisecondsF(),
       device_manager->IsRecoveringFromFailure(),
       device_manager->IsSyncInProgress());
 }
 
 std::unique_ptr<base::ListValue>
 ProximityAuthWebUIHandler::GetUnlockKeysList() {
   std::unique_ptr<base::ListValue> unlock_keys(new base::ListValue());
-  CryptAuthDeviceManager* device_manager =
+  cryptauth::CryptAuthDeviceManager* device_manager =
       proximity_auth_client_->GetCryptAuthDeviceManager();
   if (!device_manager)
     return unlock_keys;
 
   for (const auto& unlock_key : device_manager->unlock_keys()) {
     unlock_keys->Append(ExternalDeviceInfoToDictionary(unlock_key));
   }
 
   return unlock_keys;
 }
@@ skipping 25 matching lines @@
       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);
 
-  CryptAuthDeviceManager* device_manager =
+  cryptauth::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(),
@@ skipping 92 matching lines @@
                << "\n  trust_agent_state: "
                << static_cast<int>(status_update.trust_agent_state);
 
   last_remote_status_update_.reset(new RemoteStatusUpdate(status_update));
   std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
   web_ui()->CallJavascriptFunctionUnsafe(
       "LocalStateInterface.onUnlockKeysChanged", *unlock_keys);
 }
 
 }  // namespace proximity_auth