Abstract most Profile knowledge from SigninManager.

chrome/browser/signin/signin_manager.cc

 // Copyright (c) 2012 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/signin_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/profiles/profile_io_data.h"
-#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_account_id_helper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/profile_management_switches.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_internals_util.h"
 #include "components/signin/core/browser/signin_manager_cookie_helper.h"
+#include "components/signin/core/common/signin_pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/escape.h"
 #include "third_party/icu/source/i18n/unicode/regex.h"
 
 using namespace signin_internals_util;
 
 namespace {
 
@@ skipping 19 matching lines @@
     return false;
 
   // Any login UI URLs with signin=chromiumsync should be considered a web
   // URL (relies on GAIA keeping the "service=chromiumsync" query string
   // fragment present even when embedding inside a "continue" parameter).
   return net::UnescapeURLComponent(
       url.query(), net::UnescapeRule::URL_SPECIAL_CHARS)
           .find(kChromiumSyncService) != std::string::npos;
 }
 
-SigninManager::SigninManager(SigninClient* client)
+SigninManager::SigninManager(SigninClient* client,
+                             ProfileOAuth2TokenService* token_service)
     : SigninManagerBase(client),
       profile_(NULL),
       prohibit_signout_(false),
       type_(SIGNIN_TYPE_NONE),
       weak_pointer_factory_(this),
-      client_(client) {}
+      client_(client),
+      token_service_(token_service) {}
 
 void SigninManager::AddMergeSessionObserver(
     MergeSessionHelper::Observer* observer) {
   if (merge_session_helper_)
     merge_session_helper_->AddObserver(observer);
 }
 
 void SigninManager::RemoveMergeSessionObserver(
     MergeSessionHelper::Observer* observer) {
   if (merge_session_helper_)
     merge_session_helper_->RemoveObserver(observer);
 }
 
 SigninManager::~SigninManager() {
 }
 
 void SigninManager::InitTokenService() {
-  ProfileOAuth2TokenService* token_service =
-      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   const std::string& account_id = GetAuthenticatedUsername();
-  if (token_service && !account_id.empty())
-    token_service->LoadCredentials(account_id);
+  if (token_service_ && !account_id.empty())
+    token_service_->LoadCredentials(account_id);
 }
 
 std::string SigninManager::SigninTypeToString(
     SigninManager::SigninType type) {
   switch (type) {
     case SIGNIN_TYPE_NONE:
       return "No Signin";
     case SIGNIN_TYPE_WITH_REFRESH_TOKEN:
       return "Signin with refresh token";
   }
@@ skipping 104 matching lines @@
 
   if (prohibit_signout_) {
     DVLOG(1) << "Ignoring attempt to sign out while signout is prohibited";
     return;
   }
 
   ClearTransientSigninData();
 
   const std::string& username = GetAuthenticatedUsername();
   clear_authenticated_username();
-  profile_->GetPrefs()->ClearPref(prefs::kGoogleServicesUsername);
+  client_->GetPrefs()->ClearPref(prefs::kGoogleServicesUsername);
 
   // Erase (now) stale information from AboutSigninInternals.
   NotifyDiagnosticsObservers(USERNAME, "");
 
   // Revoke all tokens before sending signed_out notification, because there
   // may be components that don't listen for token service events when the
   // profile is not connected to an account.
-  ProfileOAuth2TokenService* token_service =
-      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
   LOG(WARNING) << "Revoking refresh token on server. Reason: sign out, "
                << "IsSigninAllowed: " << IsSigninAllowed();
-  token_service->RevokeAllCredentials();
+  token_service_->RevokeAllCredentials();
 
   // TODO(blundell): Eliminate this notification send once crbug.com/333997 is
   // fixed.
   GoogleServiceSignoutDetails details(username);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_GOOGLE_SIGNED_OUT,
       content::Source<Profile>(profile_),
       content::Details<const GoogleServiceSignoutDetails>(&details));
 
   FOR_EACH_OBSERVER(Observer, observer_list_, GoogleSignedOut(username));
 }
 
 void SigninManager::Initialize(Profile* profile, PrefService* local_state) {
   profile_ = profile;
   SigninManagerBase::Initialize(profile, local_state);
 
   // local_state can be null during unit tests.
   if (local_state) {
     local_state_pref_registrar_.Init(local_state);
     local_state_pref_registrar_.Add(
         prefs::kGoogleServicesUsernamePattern,
         base::Bind(&SigninManager::OnGoogleServicesUsernamePatternChanged,
                    weak_pointer_factory_.GetWeakPtr()));
   }
-  signin_allowed_.Init(prefs::kSigninAllowed, profile_->GetPrefs(),
-      base::Bind(&SigninManager::OnSigninAllowedPrefChanged,
-                 base::Unretained(this)));
+  signin_allowed_.Init(prefs::kSigninAllowed,
+                       client_->GetPrefs(),
+                       base::Bind(&SigninManager::OnSigninAllowedPrefChanged,
+                                  base::Unretained(this)));
 
-  std::string user = profile_->GetPrefs()->GetString(
-      prefs::kGoogleServicesUsername);
+  std::string user =
+      client_->GetPrefs()->GetString(prefs::kGoogleServicesUsername);
   if ((!user.empty() && !IsAllowedUsername(user)) || !IsSigninAllowed()) {
     // User is signed in, but the username is invalid - the administrator must
     // have changed the policy since the last signin, so sign out the user.
     SignOut();
   }
 
   InitTokenService();
-  account_id_helper_.reset(new SigninAccountIdHelper(
-      client_,
-      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
-      this));
+  account_id_helper_.reset(
+      new SigninAccountIdHelper(client_, token_service_, this));
 }
 
 void SigninManager::Shutdown() {
   if (merge_session_helper_)
     merge_session_helper_->CancelAll();
 
   local_state_pref_registrar_.RemoveAll();
   account_id_helper_.reset();
   SigninManagerBase::Shutdown();
 }
@@ skipping 60 matching lines @@
 }
 
 bool SigninManager::AuthInProgress() const {
   return !possibly_invalid_username_.empty();
 }
 
 const std::string& SigninManager::GetUsernameForAuthInProgress() const {
   return possibly_invalid_username_;
 }
 
-void SigninManager::DisableOneClickSignIn(Profile* profile) {
-  PrefService* pref_service = profile->GetPrefs();
-  pref_service->SetBoolean(prefs::kReverseAutologinEnabled, false);
+void SigninManager::DisableOneClickSignIn(PrefService* prefs) {
+  prefs->SetBoolean(prefs::kReverseAutologinEnabled, false);
 }
 
 void SigninManager::CompletePendingSignin() {
   DCHECK(!possibly_invalid_username_.empty());
   OnSignedIn(possibly_invalid_username_);
 
-  ProfileOAuth2TokenService* token_service =
-      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
-
   // If inline sign in is enabled, but new profile management is not, perform a
   // merge session now to push the user's credentials into the cookie jar.
   bool do_merge_session_in_signin_manager =
       !switches::IsEnableWebBasedSignin() &&
       !switches::IsNewProfileManagement();
 
   if (do_merge_session_in_signin_manager) {
     merge_session_helper_.reset(new MergeSessionHelper(
-        token_service, profile_->GetRequestContext(), NULL));
+        token_service_, client_->GetURLRequestContext(), NULL));
   }
 
   DCHECK(!temp_refresh_token_.empty());
   DCHECK(!GetAuthenticatedUsername().empty());
-  token_service->UpdateCredentials(GetAuthenticatedUsername(),
-                                   temp_refresh_token_);
+  token_service_->UpdateCredentials(GetAuthenticatedUsername(),
+                                    temp_refresh_token_);
   temp_refresh_token_.clear();
 
   if (do_merge_session_in_signin_manager)
     merge_session_helper_->LogIn(GetAuthenticatedUsername());
 }
 
 void SigninManager::OnExternalSigninCompleted(const std::string& username) {
   OnSignedIn(username);
 }
 
@@ skipping 10 matching lines @@
       content::Source<Profile>(profile_),
       content::Details<const GoogleServiceSigninSuccessDetails>(&details));
 
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     GoogleSigninSucceeded(GetAuthenticatedUsername(),
                                           password_));
 
   client_->GoogleSigninSucceeded(GetAuthenticatedUsername(), password_);
 
   password_.clear();  // Don't need it anymore.
-  DisableOneClickSignIn(profile_);  // Don't ever offer again.
+  DisableOneClickSignIn(client_->GetPrefs());  // Don't ever offer again.
 }
 
 void SigninManager::ProhibitSignout(bool prohibit_signout) {
   prohibit_signout_ = prohibit_signout;
 }
 
 bool SigninManager::IsSignoutProhibited() const {
   return prohibit_signout_;
 }