Abstract most Profile knowledge from SigninManager.

chrome/browser/signin/signin_manager.h

 // 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.
 //
 // The signin manager encapsulates some functionality tracking
 // which user is signed in. See SigninManagerBase for full description of
 // responsibilities. The class defined in this file provides functionality
 // required by all platforms except Chrome OS.
 //
 // When a user is signed in, a ClientLogin request is run on their behalf.
@@ skipping 13 matching lines @@
 #include <set>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_member.h"
-#include "chrome/browser/profiles/profile.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/signin/core/browser/signin_internals_util.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/merge_session_helper.h"
 #include "net/cookies/canonical_cookie.h"
 
 class PrefService;
+class ProfileOAuth2TokenService;
 class SigninAccountIdHelper;
 class SigninClient;
 
 class SigninManager : public SigninManagerBase {
  public:
   // The callback invoked once the OAuth token has been fetched during signin,
   // but before the profile transitions to the "signed-in" state. This allows
   // callers to load policy and prompt the user appropriately before completing
   // signin. The callback is passed the just-fetched OAuth login refresh token.
   typedef base::Callback<void(const std::string&)> OAuthTokenFetchedCallback;
 
   // Returns true if |url| is a web signin URL and should be hosted in an
   // isolated, privileged signin process.
   static bool IsWebBasedSigninFlowURL(const GURL& url);
 
   // This is used to distinguish URLs belonging to the special web signin flow
   // running in the special signin process from other URLs on the same domain.
   // We do not grant WebUI privilieges / bindings to this process or to URLs of
   // this scheme; enforcement of privileges is handled separately by
   // OneClickSigninHelper.
   static const char kChromeSigninEffectiveSite[];
 
-  explicit SigninManager(SigninClient* client);
+  SigninManager(SigninClient* client, ProfileOAuth2TokenService* token_service);
   virtual ~SigninManager();
 
   // Returns true if the username is allowed based on the policy string.
   static bool IsUsernameAllowedByPolicy(const std::string& username,
                                         const std::string& policy);
 
   // Attempt to sign in this user with a refresh token.
   // If non-null, the passed |oauth_fetched_callback| callback is invoked once
   // signin has been completed.
   // The callback should invoke SignOut() or CompletePendingSignin() to either
@@ skipping 32 matching lines @@
   virtual bool IsSigninAllowed() const OVERRIDE;
 
   // Returns true if the passed username is allowed by policy. Virtual for
   // mocking in tests.
   virtual bool IsAllowedUsername(const std::string& username) const;
 
   // If an authentication is in progress, return the username being
   // authenticated. Returns an empty string if no auth is in progress.
   const std::string& GetUsernameForAuthInProgress() const;
 
-  // Set the profile preference to turn off one-click sign-in so that it won't
-  // ever show it again in this profile (even if the user tries a new account).
-  static void DisableOneClickSignIn(Profile* profile);
+  // Set the preference to turn off one-click sign-in so that it won't ever
+  // show it again for the user associated with |prefs| (even if the user tries
+  // a new account).
+  static void DisableOneClickSignIn(PrefService* prefs);
 
   // Tells the SigninManager whether to prohibit signout for this profile.
   // If |prohibit_signout| is true, then signout will be prohibited.
   void ProhibitSignout(bool prohibit_signout);
 
   // If true, signout is prohibited for this profile (calls to SignOut() are
   // ignored).
   bool IsSignoutProhibited() const;
 
   // Add or remove observers for the merge session notification.
@@ skipping 64 matching lines @@
   // Temporarily saves the oauth2 refresh token.  It will be passed to the
   // token service so that it does not need to mint new ones.
   std::string temp_refresh_token_;
 
   base::WeakPtrFactory<SigninManager> weak_pointer_factory_;
 
   // The SigninClient object associated with this object. Must outlive this
   // object.
   SigninClient* client_;
 
+  // The ProfileOAuth2TokenService instance associated with this object. Must
+  // outlive this object.
+  ProfileOAuth2TokenService* token_service_;
+
   // Helper object to listen for changes to signin preferences stored in non-
   // profile-specific local prefs (like kGoogleServicesUsernamePattern).
   PrefChangeRegistrar local_state_pref_registrar_;
 
   // Helper object to listen for changes to the signin allowed preference.
   BooleanPrefMember signin_allowed_;
 
   // Helper to merge signed in account into the content area.
   scoped_ptr<MergeSessionHelper> merge_session_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(SigninManager);
 };
 
 #endif  // !defined(OS_CHROMEOS)
 
 #endif  // CHROME_BROWSER_SIGNIN_SIGNIN_MANAGER_H_