signin_manager_base.h revision 1320f92c476a1ad9d19dba2a48c72b75566198e9
1// Copyright 2014 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4// 5// The signin manager encapsulates some functionality tracking 6// which user is signed in. 7// 8// **NOTE** on semantics of SigninManager: 9// 10// Once a signin is successful, the username becomes "established" and will not 11// be cleared until a SignOut operation is performed (persists across 12// restarts). Until that happens, the signin manager can still be used to 13// refresh credentials, but changing the username is not permitted. 14// 15// On Chrome OS, because of the existence of other components that handle login 16// and signin at a higher level, all that is needed from a SigninManager is 17// caching / handling of the "authenticated username" field, and TokenService 18// initialization, so that components that depend on these two things 19// (i.e on desktop) can continue using it / don't need to change. For this 20// reason, SigninManagerBase is all that exists on Chrome OS. For desktop, 21// see signin/signin_manager.h. 22 23#ifndef COMPONENTS_SIGNIN_CORE_BROWSER_SIGNIN_MANAGER_BASE_H_ 24#define COMPONENTS_SIGNIN_CORE_BROWSER_SIGNIN_MANAGER_BASE_H_ 25 26#include <string> 27 28#include "base/compiler_specific.h" 29#include "base/gtest_prod_util.h" 30#include "base/logging.h" 31#include "base/memory/scoped_ptr.h" 32#include "base/observer_list.h" 33#include "base/prefs/pref_change_registrar.h" 34#include "base/prefs/pref_member.h" 35#include "components/keyed_service/core/keyed_service.h" 36#include "components/signin/core/browser/signin_internals_util.h" 37#include "google_apis/gaia/google_service_auth_error.h" 38 39class PrefService; 40 41class SigninClient; 42 43class SigninManagerBase : public KeyedService { 44 public: 45 class Observer { 46 public: 47 // Called when a user fails to sign into Google services such as sync. 48 virtual void GoogleSigninFailed(const GoogleServiceAuthError& error) {} 49 50 // Called when a user signs into Google services such as sync. 51 virtual void GoogleSigninSucceeded(const std::string& account_id, 52 const std::string& username, 53 const std::string& password) {} 54 55 // Called when the currently signed-in user for a user has been signed out. 56 virtual void GoogleSignedOut(const std::string& account_id, 57 const std::string& username) {} 58 59 protected: 60 virtual ~Observer() {} 61 }; 62 63 SigninManagerBase(SigninClient* client); 64 virtual ~SigninManagerBase(); 65 66 // If user was signed in, load tokens from DB if available. 67 virtual void Initialize(PrefService* local_state); 68 bool IsInitialized() const; 69 70 // Returns true if a signin to Chrome is allowed (by policy or pref). 71 // TODO(tim): kSigninAllowed is defined for all platforms in pref_names.h. 72 // If kSigninAllowed pref was non-Chrome OS-only, this method wouldn't be 73 // needed, but as is we provide this method to let all interested code 74 // code query the value in one way, versus half using PrefService directly 75 // and the other half using SigninManager. 76 virtual bool IsSigninAllowed() const; 77 78 // If a user has previously signed in (and has not signed out), this returns 79 // the normalized email address of the account. Otherwise, it returns an empty 80 // string. 81 const std::string& GetAuthenticatedUsername() const; 82 83 // If a user has previously signed in (and has not signed out), this returns 84 // the account id. Otherwise, it returns an empty string. This id can be used 85 // to uniquely identify an account, so for example can be used as a key to 86 // map accounts to data. 87 // 88 // TODO(rogerta): eventually the account id should be an obfuscated gaia id. 89 // For now though, this function returns the same value as 90 // GetAuthenticatedUsername() since lots of code assumes the unique id for an 91 // account is the username. For code that needs a unique id to represent the 92 // connected account, call this method. Example: the AccountInfoMap type 93 // in MutableProfileOAuth2TokenService. For code that needs to know the 94 // normalized email address of the connected account, use 95 // GetAuthenticatedUsername(). Example: to show the string "Signed in as XXX" 96 // in the hotdog menu. 97 const std::string& GetAuthenticatedAccountId() const; 98 99 // Sets the user name. Note: |username| should be already authenticated as 100 // this is a sticky operation (in contrast to StartSignIn). 101 // TODO(tim): Remove this in favor of passing username on construction by 102 // (by platform / depending on StartBehavior). Bug 88109. 103 void SetAuthenticatedUsername(const std::string& username); 104 105 // Returns true if there is an authenticated user. 106 bool IsAuthenticated() const; 107 108 // Returns true if there's a signin in progress. 109 virtual bool AuthInProgress() const; 110 111 // KeyedService implementation. 112 virtual void Shutdown() OVERRIDE; 113 114 // Methods to register or remove observers of signin. 115 void AddObserver(Observer* observer); 116 void RemoveObserver(Observer* observer); 117 118 // Methods to register or remove SigninDiagnosticObservers. 119 void AddSigninDiagnosticsObserver( 120 signin_internals_util::SigninDiagnosticsObserver* observer); 121 void RemoveSigninDiagnosticsObserver( 122 signin_internals_util::SigninDiagnosticsObserver* observer); 123 124 protected: 125 // Used by subclass to clear authenticated_username_ instead of using 126 // SetAuthenticatedUsername, which enforces special preconditions due 127 // to the fact that it is part of the public API and called by clients. 128 void clear_authenticated_username(); 129 130 // List of observers to notify on signin events. 131 // Makes sure list is empty on destruction. 132 ObserverList<Observer, true> observer_list_; 133 134 // Helper methods to notify all registered diagnostics observers with. 135 void NotifyDiagnosticsObservers( 136 const signin_internals_util::UntimedSigninStatusField& field, 137 const std::string& value); 138 void NotifyDiagnosticsObservers( 139 const signin_internals_util::TimedSigninStatusField& field, 140 const std::string& value); 141 142 private: 143 friend class FakeSigninManagerBase; 144 friend class FakeSigninManager; 145 146 SigninClient* client_; 147 bool initialized_; 148 149 // Actual username after successful authentication. 150 std::string authenticated_username_; 151 152 // The list of SigninDiagnosticObservers. 153 ObserverList<signin_internals_util::SigninDiagnosticsObserver, true> 154 signin_diagnostics_observers_; 155 156 base::WeakPtrFactory<SigninManagerBase> weak_pointer_factory_; 157 158 DISALLOW_COPY_AND_ASSIGN(SigninManagerBase); 159}; 160 161#endif // COMPONENTS_SIGNIN_CORE_BROWSER_SIGNIN_MANAGER_BASE_H_ 162