Move screenlock_bridge to components/proximity_auth

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
-#include "chrome/browser/signin/screenlock_bridge.h"
+#include "chrome/browser/signin/proximity_auth_facade.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/api/easy_unlock_private.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/login/user_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/proximity_auth/cryptauth/cryptauth_access_token_fetcher.h"
 #include "components/proximity_auth/cryptauth/cryptauth_client_impl.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 "content/public/browser/browser_thread.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/constants.h"
 
 #if defined(OS_CHROMEOS)
 #include "apps/app_lifetime_monitor_factory.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 48 matching lines @@
 }
 
 EasyUnlockServiceRegular::~EasyUnlockServiceRegular() {
 }
 
 EasyUnlockService::Type EasyUnlockServiceRegular::GetType() const {
   return EasyUnlockService::TYPE_REGULAR;
 }
 
 std::string EasyUnlockServiceRegular::GetUserEmail() const {
-  return ScreenlockBridge::GetAuthenticatedUserEmail(profile());
+  const SigninManagerBase* signin_manager =
+      SigninManagerFactory::GetForProfileIfExists(profile());
+  // |profile| has to be a signed-in profile with SigninManager already
+  // created. Otherwise, just crash to collect stack.
+  DCHECK(signin_manager);
+  return signin_manager->GetAuthenticatedUsername();
 }
 
 void EasyUnlockServiceRegular::LaunchSetup() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 #if defined(OS_CHROMEOS)
   // Force the user to reauthenticate by showing a modal overlay (similar to the
   // lock screen). The password obtained from the reauth is cached for a short
   // period of time and used to create the cryptohome keys for sign-in.
   if (short_lived_user_context_ && short_lived_user_context_->user_context()) {
     OpenSetupApp();
@@ skipping 185 matching lines @@
 void EasyUnlockServiceRegular::SetAutoPairingResult(
     bool success,
     const std::string& error) {
   DCHECK(!auto_pairing_callback_.is_null());
 
   auto_pairing_callback_.Run(success, error);
   auto_pairing_callback_.Reset();
 }
 
 void EasyUnlockServiceRegular::InitializeInternal() {
-  ScreenlockBridge::Get()->AddObserver(this);
+  GetScreenlockBridgeInstance()->AddObserver(this);
   registrar_.Init(profile()->GetPrefs());
   registrar_.Add(
       prefs::kEasyUnlockAllowed,
       base::Bind(&EasyUnlockServiceRegular::OnPrefsChanged,
                  base::Unretained(this)));
   registrar_.Add(prefs::kEasyUnlockProximityRequired,
                  base::Bind(&EasyUnlockServiceRegular::OnPrefsChanged,
                             base::Unretained(this)));
   OnPrefsChanged();
 }
 
 void EasyUnlockServiceRegular::ShutdownInternal() {
 #if defined(OS_CHROMEOS)
   short_lived_user_context_.reset();
 #endif
 
   turn_off_flow_status_ = EasyUnlockService::IDLE;
   registrar_.RemoveAll();
-  ScreenlockBridge::Get()->RemoveObserver(this);
+  GetScreenlockBridgeInstance()->RemoveObserver(this);
 }
 
 bool EasyUnlockServiceRegular::IsAllowedInternal() const {
 #if defined(OS_CHROMEOS)
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (!user_manager->IsLoggedInAsUserWithGaiaAccount())
     return false;
 
   // TODO(tengs): Ephemeral accounts generate a new enrollment every time they
   // are added, so disable Smart Lock to reduce enrollments on server. However,
@@ skipping 16 matching lines @@
 
 void EasyUnlockServiceRegular::OnWillFinalizeUnlock(bool success) {
   will_unlock_using_easy_unlock_ = success;
 }
 
 void EasyUnlockServiceRegular::OnSuspendDone() {
   lock_screen_last_shown_timestamp_ = base::TimeTicks::Now();
 }
 
 void EasyUnlockServiceRegular::OnScreenDidLock(
-    ScreenlockBridge::LockHandler::ScreenType screen_type) {
+    proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type) {
   will_unlock_using_easy_unlock_ = false;
   lock_screen_last_shown_timestamp_ = base::TimeTicks::Now();
 }
 
 void EasyUnlockServiceRegular::OnScreenDidUnlock(
-    ScreenlockBridge::LockHandler::ScreenType screen_type) {
+    proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type) {
   // Notifications of signin screen unlock events can also reach this code path;
   // disregard them.
-  if (screen_type != ScreenlockBridge::LockHandler::LOCK_SCREEN)
+  if (screen_type != proximity_auth::ScreenlockBridge::LockHandler::LOCK_SCREEN)
     return;
 
   // Only record metrics for users who have enabled the feature.
   if (IsEnabled()) {
     EasyUnlockAuthEvent event =
         will_unlock_using_easy_unlock_
             ? EASY_UNLOCK_SUCCESS
             : GetPasswordAuthEvent();
     RecordEasyUnlockScreenUnlockEvent(event);
 
@@ skipping 49 matching lines @@
       new base::DictionaryValue());
   user_prefs_dict->SetBooleanWithoutPathExpansion(
       prefs::kEasyUnlockProximityRequired,
       profile_prefs->GetBoolean(prefs::kEasyUnlockProximityRequired));
 
   DictionaryPrefUpdate update(local_state,
                               prefs::kEasyUnlockLocalStateUserPrefs);
   std::string user_email = GetUserEmail();
   update->SetWithoutPathExpansion(user_email, user_prefs_dict.Pass());
 }