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

chrome/browser/signin/easy_unlock_service_regular.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 "chrome/browser/signin/easy_unlock_service_regular.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
 #include "chrome/browser/signin/chrome_proximity_auth_client.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/extensions/api/easy_unlock_private.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
+#include "components/cryptauth/cryptauth_access_token_fetcher.h"
+#include "components/cryptauth/cryptauth_client_impl.h"
+#include "components/cryptauth/cryptauth_enrollment_manager.h"
+#include "components/cryptauth/cryptauth_enrollment_utils.h"
+#include "components/cryptauth/cryptauth_gcm_manager_impl.h"
+#include "components/cryptauth/secure_message_delegate.h"
 #include "components/gcm_driver/gcm_profile_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
-#include "components/proximity_auth/cryptauth/cryptauth_access_token_fetcher.h"
-#include "components/proximity_auth/cryptauth/cryptauth_client_impl.h"
-#include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
-#include "components/proximity_auth/cryptauth/cryptauth_enrollment_utils.h"
-#include "components/proximity_auth/cryptauth/cryptauth_gcm_manager_impl.h"
-#include "components/proximity_auth/cryptauth/secure_message_delegate.h"
 #include "components/proximity_auth/cryptauth_enroller_factory_impl.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/proximity_auth_pref_manager.h"
 #include "components/proximity_auth/proximity_auth_system.h"
 #include "components/proximity_auth/remote_device_loader.h"
 #include "components/proximity_auth/screenlock_bridge.h"
 #include "components/proximity_auth/switches.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/translate/core/browser/translate_download_manager.h"
@@ skipping 31 matching lines @@
     : EasyUnlockService(profile),
       turn_off_flow_status_(EasyUnlockService::IDLE),
       will_unlock_using_easy_unlock_(false),
       lock_screen_last_shown_timestamp_(base::TimeTicks::Now()),
       deferring_device_load_(false),
       weak_ptr_factory_(this) {}
 
 EasyUnlockServiceRegular::~EasyUnlockServiceRegular() {
 }
 
-proximity_auth::CryptAuthEnrollmentManager*
+cryptauth::CryptAuthEnrollmentManager*
 EasyUnlockServiceRegular::GetCryptAuthEnrollmentManager() {
   return enrollment_manager_.get();
 }
 
-proximity_auth::CryptAuthDeviceManager*
+cryptauth::CryptAuthDeviceManager*
 EasyUnlockServiceRegular::GetCryptAuthDeviceManager() {
   return device_manager_.get();
 }
 
 proximity_auth::ProximityAuthPrefManager*
 EasyUnlockServiceRegular::GetProximityAuthPrefManager() {
   return pref_manager_.get();
 }
 
 void EasyUnlockServiceRegular::LoadRemoteDevices() {
@@ skipping 231 matching lines @@
   }
 }
 
 void EasyUnlockServiceRegular::RunTurnOffFlow() {
   if (turn_off_flow_status_ == PENDING)
     return;
   DCHECK(!cryptauth_client_);
 
   SetTurnOffFlowStatus(PENDING);
 
-  std::unique_ptr<proximity_auth::CryptAuthClientFactory> factory =
+  std::unique_ptr<cryptauth::CryptAuthClientFactory> factory =
       proximity_auth_client()->CreateCryptAuthClientFactory();
   cryptauth_client_ = factory->CreateInstance();
 
   cryptauth::ToggleEasyUnlockRequest request;
   request.set_enable(false);
   request.set_apply_to_all(true);
   cryptauth_client_->ToggleEasyUnlock(
       request,
       base::Bind(&EasyUnlockServiceRegular::OnToggleEasyUnlockApiComplete,
                  weak_ptr_factory_.GetWeakPtr()),
@@ skipping 133 matching lines @@
         ProfileOAuth2TokenServiceFactory::GetForProfile(profile());
     token_service->RemoveObserver(this);
 #if defined(OS_CHROMEOS)
     enrollment_manager_->Start();
     device_manager_->Start();
 #endif
   }
 }
 
 void EasyUnlockServiceRegular::OnSyncFinished(
-    proximity_auth::CryptAuthDeviceManager::SyncResult sync_result,
-    proximity_auth::CryptAuthDeviceManager::DeviceChangeResult
+    cryptauth::CryptAuthDeviceManager::SyncResult sync_result,
+    cryptauth::CryptAuthDeviceManager::DeviceChangeResult
         device_change_result) {
   if (device_change_result !=
-      proximity_auth::CryptAuthDeviceManager::DeviceChangeResult::CHANGED)
+      cryptauth::CryptAuthDeviceManager::DeviceChangeResult::CHANGED)
     return;
 
   if (proximity_auth::ScreenlockBridge::Get()->IsLocked()) {
     PA_LOG(INFO) << "Deferring device load until screen is unlocked.";
     deferring_device_load_ = true;
   } else {
     LoadRemoteDevices();
   }
 }
 
@@ skipping 85 matching lines @@
   update->SetWithoutPathExpansion(GetAccountId().GetUserEmail(),
                                   std::move(user_prefs_dict));
 }
 
 cryptauth::GcmDeviceInfo EasyUnlockServiceRegular::GetGcmDeviceInfo() {
   cryptauth::GcmDeviceInfo device_info;
   device_info.set_long_device_id(EasyUnlockService::GetDeviceId());
   device_info.set_device_type(cryptauth::CHROME);
   device_info.set_device_software_version(version_info::GetVersionNumber());
   google::protobuf::int64 software_version_code =
-      proximity_auth::HashStringToInt64(version_info::GetLastChange());
+      cryptauth::HashStringToInt64(version_info::GetLastChange());
   device_info.set_device_software_version_code(software_version_code);
   device_info.set_locale(
       translate::TranslateDownloadManager::GetInstance()->application_locale());
 
 #if defined(OS_CHROMEOS)
   device_info.set_device_model(base::SysInfo::GetLsbReleaseBoard());
   device_info.set_device_os_version(base::GetLinuxDistro());
   // The Chrome OS version tracks the Chrome version, so fill in the same value
   // as |device_software_version_code|.
   device_info.set_device_os_version_code(software_version_code);
@@ skipping 23 matching lines @@
 #else
 // TODO(tengs): Fill in device information for other platforms.
 #endif
   return device_info;
 }
 
 #if defined(OS_CHROMEOS)
 void EasyUnlockServiceRegular::InitializeCryptAuth() {
   PA_LOG(INFO) << "Initializing CryptAuth managers.";
   // Initialize GCM manager.
-  gcm_manager_.reset(new proximity_auth::CryptAuthGCMManagerImpl(
+  gcm_manager_.reset(new cryptauth::CryptAuthGCMManagerImpl(
       gcm::GCMProfileServiceFactory::GetForProfile(profile())->driver(),
       proximity_auth_client()->GetPrefService()));
   gcm_manager_->StartListening();
 
   // Initialize enrollment manager.
   cryptauth::GcmDeviceInfo device_info;
-  enrollment_manager_.reset(new proximity_auth::CryptAuthEnrollmentManager(
+  enrollment_manager_.reset(new cryptauth::CryptAuthEnrollmentManager(
       base::MakeUnique<base::DefaultClock>(),
       base::MakeUnique<proximity_auth::CryptAuthEnrollerFactoryImpl>(
           proximity_auth_client()),
       proximity_auth_client()->CreateSecureMessageDelegate(),
       GetGcmDeviceInfo(), gcm_manager_.get(),
       proximity_auth_client()->GetPrefService()));
 
   // Initialize device manager.
-  device_manager_.reset(new proximity_auth::CryptAuthDeviceManager(
+  device_manager_.reset(new cryptauth::CryptAuthDeviceManager(
       base::MakeUnique<base::DefaultClock>(),
       proximity_auth_client()->CreateCryptAuthClientFactory(),
       gcm_manager_.get(), proximity_auth_client()->GetPrefService()));
 
   OAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile());
   if (!token_service->RefreshTokenIsAvailable(
           proximity_auth_client()->GetAccountId())) {
     PA_LOG(INFO) << "Refresh token not yet available, "
                  << "waiting before starting CryptAuth managers";
     token_service->AddObserver(this);
   }
 
   device_manager_->AddObserver(this);
   enrollment_manager_->Start();
   device_manager_->Start();
 }
 #endif