implement sign in dialog

chrome/browser/extensions/api/identity/identity_api.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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/extensions/api/identity/web_auth_flow.h"
 #include "chrome/browser/extensions/app_notify_channel_setup.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_function.h"
+#include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/common/net/gaia/oauth2_mint_token_flow.h"
 
+class GetAuthTokenFunctionTest;
+class MockGetAuthTokenFunction;
 class GoogleServiceAuthError;
 
 namespace extensions {
 
 class GetAuthTokenFunction : public AsyncExtensionFunction,
                              public OAuth2MintTokenFlow::Delegate,
-                             public ExtensionInstallPrompt::Delegate {
+                             public ExtensionInstallPrompt::Delegate,
+                             public LoginUIService::Observer {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("experimental.identity.getAuthToken");
 
   GetAuthTokenFunction();
 
+  static const char kInvalidClientId[];

[Mihai Parparita -not on Chrome, 2012/07/17 01:01:00]

I don't think it's worth exposing these constants in the header file just for
the sake of tests. You can leave them in an anonymous namespace in the .cc file,
and hardcode the strings in the test.

[Munjal (Google), 2012/07/19 22:35:42]

That is what I did first. But then I thought that it is silly to have to change
tests every time someone makes a tiny change to the error messages. So given
that error messages are const char* const, I thought it makes sense to make them
public.

If you feel strongly, let me know.

[Mihai Parparita -not on Chrome, 2012/07/20 18:02:32]

In that case, to be consistent with other exported constants, they should be in
an identity_constants namespace. See for example:

http://code.google.com/searchframe#OAMlx_jo-ck/src/chrome/browser/extensions/...
or
http://code.google.com/searchframe#OAMlx_jo-ck/src/chrome/browser/extensions/...

[Munjal (Google), 2012/07/20 18:54:14]

Done.

+  static const char kInvalidScopes[];
+  static const char kAuthFailure[];
+  static const char kNoGrant[];
+  static const char kUserRejected[];
+  static const char kUserNotSignedIn[];
+
+ protected:
+  virtual ~GetAuthTokenFunction();
+
  private:
-  virtual ~GetAuthTokenFunction();
+  friend class ::GetAuthTokenFunctionTest;
+  friend class ::MockGetAuthTokenFunction;
 
   // ExtensionFunction:
   virtual bool RunImpl() OVERRIDE;
 
   // OAuth2MintTokenFlow::Delegate implementation:
   virtual void OnMintTokenSuccess(const std::string& access_token) OVERRIDE;
-  virtual void OnMintTokenFailure(const GoogleServiceAuthError& error) OVERRIDE;
+  virtual void OnMintTokenFailure(
+      const GoogleServiceAuthError& error) OVERRIDE;
   virtual void OnIssueAdviceSuccess(
       const IssueAdviceInfo& issue_advice) OVERRIDE;
 
+  // LoginUIService::Observer implementation.
+  virtual void OnLoginUIShown(LoginUIService::LoginUI* ui) OVERRIDE {
+    // Do nothing when login ui is shown.
+  }
+  virtual void OnLoginUIClosed(LoginUIService::LoginUI* ui) OVERRIDE;
+
   // ExtensionInstallPrompt::Delegate implementation:
   virtual void InstallUIProceed() OVERRIDE;
   virtual void InstallUIAbort(bool user_initiated) OVERRIDE;
 
+  // Shows the login UI in a browser popup.
+  bool StartLogin();
   // Starts a MintTokenFlow with the given mode; Returns success.
   bool StartFlow(OAuth2MintTokenFlow::Mode mode);
 
+  virtual void StartObservingLoginService();
+  virtual void StopObservingLoginService();
+  virtual void ShowLoginPopup();
+  virtual void ShowOAuthApprovalDialog(const IssueAdviceInfo& issue_advice);
+  virtual const std::string& GetExtensionId() const;
+  virtual const Extension::OAuth2Info& GetOAuth2Info() const;
+  // Caller owns the returned instance.
+  virtual OAuth2MintTokenFlow* CreateMintTokenFlow(
+      OAuth2MintTokenFlow::Mode mode);
+
+  // Checks if there is a master login token to mint tokens for the extension.
+  virtual bool HasLoginToken() const;
+
+  // Gets the token mint flow mode based on a command-line flag.
+  OAuth2MintTokenFlow::Mode GetTokenFlowMode() const;
+
   bool interactive_;
   scoped_ptr<OAuth2MintTokenFlow> flow_;
 
   // When launched in interactive mode, and if there is no existing grant,
   // a permissions prompt will be popped up to the user.
   scoped_ptr<ExtensionInstallPrompt> install_ui_;
 };
 
 class LaunchWebAuthFlowFunction : public AsyncExtensionFunction,
                                   public WebAuthFlow::Delegate {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("experimental.identity.launchWebAuthFlow");
 
+  static const char kInvalidRedirect[];
+
   LaunchWebAuthFlowFunction();
 
  private:
   virtual ~LaunchWebAuthFlowFunction();
   virtual bool RunImpl() OVERRIDE;
 
   // WebAuthFlow::Delegate implementation.
   virtual void OnAuthFlowSuccess(const std::string& redirect_url) OVERRIDE;
   virtual void OnAuthFlowFailure() OVERRIDE;
 
   scoped_ptr<WebAuthFlow> auth_flow_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_API_H_