identity_api.h revision 5f1c94371a64b3196d4be9466099bb892df9b88e
1// Copyright (c) 2012 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#ifndef CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_
6#define CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_
7
8#include <map>
9#include <set>
10#include <string>
11#include <utility>
12#include <vector>
13
14#include "base/memory/ref_counted.h"
15#include "base/memory/weak_ptr.h"
16#include "base/observer_list.h"
17#include "chrome/browser/extensions/api/identity/extension_token_key.h"
18#include "chrome/browser/extensions/api/identity/gaia_web_auth_flow.h"
19#include "chrome/browser/extensions/api/identity/identity_mint_queue.h"
20#include "chrome/browser/extensions/api/identity/identity_signin_flow.h"
21#include "chrome/browser/extensions/api/identity/web_auth_flow.h"
22#include "chrome/browser/extensions/chrome_extension_function.h"
23#include "chrome/browser/signin/profile_identity_provider.h"
24#include "extensions/browser/browser_context_keyed_api_factory.h"
25#include "google_apis/gaia/account_tracker.h"
26#include "google_apis/gaia/oauth2_mint_token_flow.h"
27#include "google_apis/gaia/oauth2_token_service.h"
28
29class GoogleServiceAuthError;
30class MockGetAuthTokenFunction;
31
32namespace content {
33class BrowserContext;
34}
35
36namespace extensions {
37
38class GetAuthTokenFunctionTest;
39class MockGetAuthTokenFunction;
40
41namespace identity_constants {
42extern const char kInvalidClientId[];
43extern const char kInvalidScopes[];
44extern const char kAuthFailure[];
45extern const char kNoGrant[];
46extern const char kUserRejected[];
47extern const char kUserNotSignedIn[];
48extern const char kInteractionRequired[];
49extern const char kInvalidRedirect[];
50extern const char kOffTheRecord[];
51extern const char kPageLoadFailure[];
52extern const char kCanceled[];
53}  // namespace identity_constants
54
55class IdentityTokenCacheValue {
56 public:
57  IdentityTokenCacheValue();
58  explicit IdentityTokenCacheValue(const IssueAdviceInfo& issue_advice);
59  IdentityTokenCacheValue(const std::string& token,
60                          base::TimeDelta time_to_live);
61  ~IdentityTokenCacheValue();
62
63  // Order of these entries is used to determine whether or not new
64  // entries supercede older ones in SetCachedToken.
65  enum CacheValueStatus {
66    CACHE_STATUS_NOTFOUND,
67    CACHE_STATUS_ADVICE,
68    CACHE_STATUS_TOKEN
69  };
70
71  CacheValueStatus status() const;
72  const IssueAdviceInfo& issue_advice() const;
73  const std::string& token() const;
74  const base::Time& expiration_time() const;
75
76 private:
77  bool is_expired() const;
78
79  CacheValueStatus status_;
80  IssueAdviceInfo issue_advice_;
81  std::string token_;
82  base::Time expiration_time_;
83};
84
85class IdentityAPI : public BrowserContextKeyedAPI,
86                    public gaia::AccountTracker::Observer {
87 public:
88  typedef std::map<ExtensionTokenKey, IdentityTokenCacheValue> CachedTokens;
89
90  class ShutdownObserver {
91   public:
92    virtual void OnShutdown() = 0;
93  };
94
95  explicit IdentityAPI(content::BrowserContext* context);
96  virtual ~IdentityAPI();
97
98  // Request serialization queue for getAuthToken.
99  IdentityMintRequestQueue* mint_queue();
100
101  // Token cache
102  void SetCachedToken(const ExtensionTokenKey& key,
103                      const IdentityTokenCacheValue& token_data);
104  void EraseCachedToken(const std::string& extension_id,
105                        const std::string& token);
106  void EraseAllCachedTokens();
107  const IdentityTokenCacheValue& GetCachedToken(const ExtensionTokenKey& key);
108
109  const CachedTokens& GetAllCachedTokens();
110
111  // Account queries.
112  std::vector<std::string> GetAccounts() const;
113  std::string FindAccountKeyByGaiaId(const std::string& gaia_id);
114
115  // BrowserContextKeyedAPI implementation.
116  virtual void Shutdown() OVERRIDE;
117  static BrowserContextKeyedAPIFactory<IdentityAPI>* GetFactoryInstance();
118
119  // gaia::AccountTracker::Observer implementation:
120  virtual void OnAccountAdded(const gaia::AccountIds& ids) OVERRIDE;
121  virtual void OnAccountRemoved(const gaia::AccountIds& ids) OVERRIDE;
122  virtual void OnAccountSignInChanged(const gaia::AccountIds& ids,
123                                      bool is_signed_in) OVERRIDE;
124
125  void AddShutdownObserver(ShutdownObserver* observer);
126  void RemoveShutdownObserver(ShutdownObserver* observer);
127
128  void SetAccountStateForTest(gaia::AccountIds ids, bool is_signed_in);
129
130 private:
131  friend class BrowserContextKeyedAPIFactory<IdentityAPI>;
132
133  // BrowserContextKeyedAPI implementation.
134  static const char* service_name() { return "IdentityAPI"; }
135  static const bool kServiceIsNULLWhileTesting = true;
136
137  content::BrowserContext* browser_context_;
138  IdentityMintRequestQueue mint_queue_;
139  CachedTokens token_cache_;
140  ProfileIdentityProvider profile_identity_provider_;
141  gaia::AccountTracker account_tracker_;
142  ObserverList<ShutdownObserver> shutdown_observer_list_;
143};
144
145template <>
146void BrowserContextKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies();
147
148class IdentityGetAccountsFunction : public ChromeUIThreadExtensionFunction {
149 public:
150  DECLARE_EXTENSION_FUNCTION("identity.getAccounts",
151                             IDENTITY_GETACCOUNTS);
152
153  IdentityGetAccountsFunction();
154
155 private:
156  virtual ~IdentityGetAccountsFunction();
157
158  // UIThreadExtensionFunction implementation.
159  virtual ExtensionFunction::ResponseAction Run() OVERRIDE;
160};
161
162// identity.getAuthToken fetches an OAuth 2 function for the
163// caller. The request has three sub-flows: non-interactive,
164// interactive, and sign-in.
165//
166// In the non-interactive flow, getAuthToken requests a token from
167// GAIA. GAIA may respond with a token, an error, or "consent
168// required". In the consent required cases, getAuthToken proceeds to
169// the second, interactive phase.
170//
171// The interactive flow presents a scope approval dialog to the
172// user. If the user approves the request, a grant will be recorded on
173// the server, and an access token will be returned to the caller.
174//
175// In some cases we need to display a sign-in dialog. Normally the
176// profile will be signed in already, but if it turns out we need a
177// new login token, there is a sign-in flow. If that flow completes
178// successfully, getAuthToken proceeds to the non-interactive flow.
179class IdentityGetAuthTokenFunction : public ChromeAsyncExtensionFunction,
180                                     public GaiaWebAuthFlow::Delegate,
181                                     public IdentityMintRequestQueue::Request,
182                                     public OAuth2MintTokenFlow::Delegate,
183                                     public IdentitySigninFlow::Delegate,
184                                     public OAuth2TokenService::Consumer,
185                                     public IdentityAPI::ShutdownObserver {
186 public:
187  DECLARE_EXTENSION_FUNCTION("identity.getAuthToken",
188                             EXPERIMENTAL_IDENTITY_GETAUTHTOKEN);
189
190  IdentityGetAuthTokenFunction();
191
192  const ExtensionTokenKey* GetExtensionTokenKeyForTest() {
193    return token_key_.get();
194  }
195
196 protected:
197  virtual ~IdentityGetAuthTokenFunction();
198
199  // IdentitySigninFlow::Delegate implementation:
200  virtual void SigninSuccess() OVERRIDE;
201  virtual void SigninFailed() OVERRIDE;
202
203  // GaiaWebAuthFlow::Delegate implementation:
204  virtual void OnGaiaFlowFailure(GaiaWebAuthFlow::Failure failure,
205                                 GoogleServiceAuthError service_error,
206                                 const std::string& oauth_error) OVERRIDE;
207  virtual void OnGaiaFlowCompleted(const std::string& access_token,
208                                   const std::string& expiration) OVERRIDE;
209
210  // Starts a login access token request.
211  virtual void StartLoginAccessTokenRequest();
212
213  // OAuth2TokenService::Consumer implementation:
214  virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
215                                 const std::string& access_token,
216                                 const base::Time& expiration_time) OVERRIDE;
217  virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
218                                 const GoogleServiceAuthError& error) OVERRIDE;
219
220  scoped_ptr<OAuth2TokenService::Request> login_token_request_;
221
222 private:
223  FRIEND_TEST_ALL_PREFIXES(GetAuthTokenFunctionTest,
224                           ComponentWithChromeClientId);
225  FRIEND_TEST_ALL_PREFIXES(GetAuthTokenFunctionTest,
226                           ComponentWithNormalClientId);
227  FRIEND_TEST_ALL_PREFIXES(GetAuthTokenFunctionTest, InteractiveQueueShutdown);
228  FRIEND_TEST_ALL_PREFIXES(GetAuthTokenFunctionTest, NoninteractiveShutdown);
229
230  // ExtensionFunction:
231  virtual bool RunAsync() OVERRIDE;
232
233  // Helpers to report async function results to the caller.
234  void StartAsyncRun();
235  void CompleteAsyncRun(bool success);
236  void CompleteFunctionWithResult(const std::string& access_token);
237  void CompleteFunctionWithError(const std::string& error);
238
239  // Initiate/complete the sub-flows.
240  void StartSigninFlow();
241  void StartMintTokenFlow(IdentityMintRequestQueue::MintType type);
242  void CompleteMintTokenFlow();
243
244  // IdentityMintRequestQueue::Request implementation:
245  virtual void StartMintToken(IdentityMintRequestQueue::MintType type) OVERRIDE;
246
247  // OAuth2MintTokenFlow::Delegate implementation:
248  virtual void OnMintTokenSuccess(const std::string& access_token,
249                                  int time_to_live) OVERRIDE;
250  virtual void OnMintTokenFailure(
251      const GoogleServiceAuthError& error) OVERRIDE;
252  virtual void OnIssueAdviceSuccess(
253      const IssueAdviceInfo& issue_advice) OVERRIDE;
254
255  // IdentityAPI::ShutdownObserver implementation:
256  virtual void OnShutdown() OVERRIDE;
257
258#if defined(OS_CHROMEOS)
259  // Starts a login access token request for device robot account. This method
260  // will be called only in enterprise kiosk mode in ChromeOS.
261  virtual void StartDeviceLoginAccessTokenRequest();
262#endif
263
264  // Starts a mint token request to GAIA.
265  void StartGaiaRequest(const std::string& login_access_token);
266
267  // Methods for invoking UI. Overridable for testing.
268  virtual void ShowLoginPopup();
269  virtual void ShowOAuthApprovalDialog(const IssueAdviceInfo& issue_advice);
270  // Caller owns the returned instance.
271  virtual OAuth2MintTokenFlow* CreateMintTokenFlow(
272      const std::string& login_access_token);
273
274  // Checks if there is a master login token to mint tokens for the extension.
275  bool HasLoginToken() const;
276
277  // Maps OAuth2 protocol errors to an error message returned to the
278  // developer in chrome.runtime.lastError.
279  std::string MapOAuth2ErrorToDescription(const std::string& error);
280
281  std::string GetOAuth2ClientId() const;
282
283  bool should_prompt_for_scopes_;
284  IdentityMintRequestQueue::MintType mint_token_flow_type_;
285  scoped_ptr<OAuth2MintTokenFlow> mint_token_flow_;
286  OAuth2MintTokenFlow::Mode gaia_mint_token_mode_;
287  bool should_prompt_for_signin_;
288
289  scoped_ptr<ExtensionTokenKey> token_key_;
290  std::string oauth2_client_id_;
291  // When launched in interactive mode, and if there is no existing grant,
292  // a permissions prompt will be popped up to the user.
293  IssueAdviceInfo issue_advice_;
294  scoped_ptr<GaiaWebAuthFlow> gaia_web_auth_flow_;
295  scoped_ptr<IdentitySigninFlow> signin_flow_;
296};
297
298class IdentityGetProfileUserInfoFunction
299    : public ChromeUIThreadExtensionFunction {
300 public:
301  DECLARE_EXTENSION_FUNCTION("identity.getProfileUserInfo",
302                             IDENTITY_GETPROFILEUSERINFO);
303
304  IdentityGetProfileUserInfoFunction();
305
306 private:
307  virtual ~IdentityGetProfileUserInfoFunction();
308
309  // UIThreadExtensionFunction implementation.
310  virtual ExtensionFunction::ResponseAction Run() OVERRIDE;
311};
312
313class IdentityRemoveCachedAuthTokenFunction
314    : public ChromeSyncExtensionFunction {
315 public:
316  DECLARE_EXTENSION_FUNCTION("identity.removeCachedAuthToken",
317                             EXPERIMENTAL_IDENTITY_REMOVECACHEDAUTHTOKEN)
318  IdentityRemoveCachedAuthTokenFunction();
319
320 protected:
321  virtual ~IdentityRemoveCachedAuthTokenFunction();
322
323  // SyncExtensionFunction implementation:
324  virtual bool RunSync() OVERRIDE;
325};
326
327class IdentityLaunchWebAuthFlowFunction : public ChromeAsyncExtensionFunction,
328                                          public WebAuthFlow::Delegate {
329 public:
330  DECLARE_EXTENSION_FUNCTION("identity.launchWebAuthFlow",
331                             EXPERIMENTAL_IDENTITY_LAUNCHWEBAUTHFLOW);
332
333  IdentityLaunchWebAuthFlowFunction();
334
335  // Tests may override extension_id.
336  void InitFinalRedirectURLPrefixForTest(const std::string& extension_id);
337
338 private:
339  virtual ~IdentityLaunchWebAuthFlowFunction();
340  virtual bool RunAsync() OVERRIDE;
341
342  // WebAuthFlow::Delegate implementation.
343  virtual void OnAuthFlowFailure(WebAuthFlow::Failure failure) OVERRIDE;
344  virtual void OnAuthFlowURLChange(const GURL& redirect_url) OVERRIDE;
345  virtual void OnAuthFlowTitleChange(const std::string& title) OVERRIDE {}
346
347  // Helper to initialize final URL prefix.
348  void InitFinalRedirectURLPrefix(const std::string& extension_id);
349
350  scoped_ptr<WebAuthFlow> auth_flow_;
351  GURL final_url_prefix_;
352};
353
354}  // namespace extensions
355
356#endif  // CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_
357