components/signin/core/browser/signin_manager_base.h

   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
  39 class PrefService;
  40
  41 class SigninClient;
  42
  43 class 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& username,
  52                                        const std::string& password) {}
  53
  54     // Called when the currently signed-in user for a user has been signed out.
  55     virtual void GoogleSignedOut(const std::string& username) {}
  56
  57    protected:
  58     virtual ~Observer() {}
  59   };
  60
  61   SigninManagerBase(SigninClient* client);
  62   virtual ~SigninManagerBase();
  63
  64   // If user was signed in, load tokens from DB if available.
  65   virtual void Initialize(PrefService* local_state);
  66   bool IsInitialized() const;
  67
  68   // Returns true if a signin to Chrome is allowed (by policy or pref).
  69   // TODO(tim): kSigninAllowed is defined for all platforms in pref_names.h.
  70   // If kSigninAllowed pref was non-Chrome OS-only, this method wouldn't be
  71   // needed, but as is we provide this method to let all interested code
  72   // code query the value in one way, versus half using PrefService directly
  73   // and the other half using SigninManager.
  74   virtual bool IsSigninAllowed() const;
  75
  76   // If a user has previously signed in (and has not signed out), this returns
  77   // the normalized email address of the account. Otherwise, it returns an empty
  78   // string.
  79   const std::string& GetAuthenticatedUsername() const;
  80
  81   // If a user has previously signed in (and has not signed out), this returns
  82   // the account id. Otherwise, it returns an empty string.  This id can be used
  83   // to uniquely identify an account, so for example can be used as a key to
  84   // map accounts to data.
  85   //
  86   // TODO(rogerta): eventually the account id should be an obfuscated gaia id.
  87   // For now though, this function returns the same value as
  88   // GetAuthenticatedUsername() since lots of code assumes the unique id for an
  89   // account is the username.  For code that needs a unique id to represent the
  90   // connected account, call this method. Example: the AccountInfoMap type
  91   // in MutableProfileOAuth2TokenService.  For code that needs to know the
  92   // normalized email address of the connected account, use
  93   // GetAuthenticatedUsername().  Example: to show the string "Signed in as XXX"
  94   // in the hotdog menu.
  95   const std::string& GetAuthenticatedAccountId() const;
  96
  97   // Sets the user name.  Note: |username| should be already authenticated as
  98   // this is a sticky operation (in contrast to StartSignIn).
  99   // TODO(tim): Remove this in favor of passing username on construction by
 100   // (by platform / depending on StartBehavior). Bug 88109.
 101   void SetAuthenticatedUsername(const std::string& username);
 102
 103   // Returns true if there is an authenticated user.
 104   bool IsAuthenticated() const;
 105
 106   // Returns true if there's a signin in progress.
 107   virtual bool AuthInProgress() const;
 108
 109   // KeyedService implementation.
 110   virtual void Shutdown() OVERRIDE;
 111
 112   // Methods to register or remove observers of signin.
 113   void AddObserver(Observer* observer);
 114   void RemoveObserver(Observer* observer);
 115
 116   // Methods to register or remove SigninDiagnosticObservers.
 117   void AddSigninDiagnosticsObserver(
 118       signin_internals_util::SigninDiagnosticsObserver* observer);
 119   void RemoveSigninDiagnosticsObserver(
 120       signin_internals_util::SigninDiagnosticsObserver* observer);
 121
 122  protected:
 123   // Used by subclass to clear authenticated_username_ instead of using
 124   // SetAuthenticatedUsername, which enforces special preconditions due
 125   // to the fact that it is part of the public API and called by clients.
 126   void clear_authenticated_username();
 127
 128   // List of observers to notify on signin events.
 129   // Makes sure list is empty on destruction.
 130   ObserverList<Observer, true> observer_list_;
 131
 132   // Helper methods to notify all registered diagnostics observers with.
 133   void NotifyDiagnosticsObservers(
 134       const signin_internals_util::UntimedSigninStatusField& field,
 135       const std::string& value);
 136   void NotifyDiagnosticsObservers(
 137       const signin_internals_util::TimedSigninStatusField& field,
 138       const std::string& value);
 139
 140  private:
 141   friend class FakeSigninManagerBase;
 142   friend class FakeSigninManager;
 143
 144   SigninClient* client_;
 145   bool initialized_;
 146
 147   // Actual username after successful authentication.
 148   std::string authenticated_username_;
 149
 150   // The list of SigninDiagnosticObservers.
 151   ObserverList<signin_internals_util::SigninDiagnosticsObserver, true>
 152       signin_diagnostics_observers_;
 153
 154   base::WeakPtrFactory<SigninManagerBase> weak_pointer_factory_;
 155
 156   DISALLOW_COPY_AND_ASSIGN(SigninManagerBase);
 157 };
 158
 159 #endif  // COMPONENTS_SIGNIN_CORE_BROWSER_SIGNIN_MANAGER_BASE_H_