Export a private webstore API to call into the new inline sign-in flow.

chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc

 // 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.
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/extensions/api/identity/identity_api.h"
 #include "chrome/browser/extensions/api/management/management_api.h"
 #include "chrome/browser/extensions/api/webstore_private/webstore_private_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
+#include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
+#include "chrome/browser/signin/fake_signin_manager.h"
+#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
+#include "chrome/browser/signin/signin_manager.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/test/browser_test_utils.h"
 #include "gpu/config/gpu_feature_type.h"
 #include "gpu/config/gpu_info.h"
@@ skipping 48 matching lines @@
   const std::string& id() const { return id_; }
 
  private:
   bool received_failure_;
   bool received_success_;
   bool waiting_;
   std::string id_;
   std::string error_;
 };
 
+// A trivial factory to build a null service.
+KeyedService* BuildNullService(content::BrowserContext* context) {
+  return NULL;
+}
+
 }  // namespace
 
 // A base class for tests below.
 class ExtensionWebstorePrivateApiTest : public ExtensionApiTest {
  public:
+  ExtensionWebstorePrivateApiTest()
+      : signin_manager_(NULL),
+        token_service_(NULL) {}
+  virtual ~ExtensionWebstorePrivateApiTest() {}
+
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     ExtensionApiTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(
         switches::kAppsGalleryURL,
         "http://www.example.com/files/extensions/api_test");
     command_line->AppendSwitchASCII(
         switches::kAppsGalleryInstallAutoConfirmForTests, "accept");
   }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+    ExtensionApiTest::SetUpInProcessBrowserTestFixture();
+
     // Start up the test server and get us ready for calling the install
     // API functions.
     host_resolver()->AddRule("www.example.com", "127.0.0.1");
-    ASSERT_TRUE(test_server()->Start());
+    ASSERT_TRUE(StartSpawnedTestServer());
     ExtensionInstallUI::set_disable_failure_ui_for_tests();
   }
 
+  virtual void SetUpOnMainThread() OVERRIDE {
+    ExtensionApiTest::SetUpOnMainThread();
+
+    // Shutdown the existing identity API service, as it is not designed to
+    // handle a fake signin manager or token service being installed.
+    IdentityAPI::GetFactoryInstance()->SetTestingFactory(
+        profile(), BuildNullService);
+
+    // Install a fake signin manager and token service, and grab references to
+    // them.
+    signin_manager_ =
+        static_cast<FakeSigninManagerForTesting*>(
+            SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
+                profile(), &FakeSigninManagerBase::Build));
+    ASSERT_TRUE(signin_manager_);
+    // TODO(isherman): This fails due to observers that don't unregister when
+    // the service is swapped.
+    /*token_service_ =
+        static_cast<FakeProfileOAuth2TokenService*>(
+            ProfileOAuth2TokenServiceFactory::GetInstance()
+                ->SetTestingFactoryAndUse(
+                    profile(), &BuildFakeProfileOAuth2TokenService));
+    ASSERT_TRUE(token_service_);*/

[Ilya Sherman, 2014/03/26 08:21:39]

I'm having no end of trouble from trying to substitute in these fakes, due to
lots of observers registered with the real versions of these classes not being
prepared for them being swapped out.  Is there a different/better approach that
you'd recommend for implementing the SignIn_AuthInProgress_MergeSessionFails and
SignIn_AuthInProgress_Success test cases? 

+  }
+
  protected:
   // Returns a test server URL, but with host 'www.example.com' so it matches
   // the web store app's extent that we set up via command line flags.
   virtual GURL GetTestServerURL(const std::string& path) {
     GURL url = test_server()->GetURL(
         std::string("files/extensions/api_test/webstore_private/") + path);
 
     // Replace the host with 'www.example.com' so it matches the web store
     // app's extent.
     GURL::Replacements replace_host;
@@ skipping 14 matching lines @@
 #else
     GURL crx_url = GetTestServerURL(crx_file);
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kAppsGalleryUpdateURL, crx_url.spec());
 
     GURL page_url = GetTestServerURL(page);
     return RunPageTest(page_url.spec());
 #endif
   }
 
+  // Navigates to |page| and waits for the API call.
+  void StartSignInTest(const std::string& page) {
+    ui_test_utils::NavigateToURL(browser(), GetTestServerURL(page));
+
+    // Wait for the API to be called.  A simple way to wait for this is to run
+    // some other JavaScript in the page and wait for a round-trip back to the
+    // browser process.
+    bool result = false;
+    ASSERT_TRUE(
+        content::ExecuteScriptAndExtractBool(
+            GetWebContents(), "window.domAutomationController.send(true)",
+            &result));
+    ASSERT_TRUE(result);
+  }
+
+  content::WebContents* GetWebContents() {
+    return browser()->tab_strip_model()->GetActiveWebContents();
+  }
+
   ExtensionService* service() {
     return browser()->profile()->GetExtensionService();
   }
+
+  FakeSigninManagerForTesting* signin_manager_;
+  FakeProfileOAuth2TokenService* token_service_;
 };
 
 // Test cases for webstore origin frame blocking.
 // TODO(mkwst): Disabled until new X-Frame-Options behavior rolls into
 // Chromium, see crbug.com/226018.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
                        DISABLED_FrameWebstorePageBlocked) {
-  content::WebContents* contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
   base::string16 expected_title = base::UTF8ToUTF16("PASS: about:blank");
   base::string16 failure_title = base::UTF8ToUTF16("FAIL");
-  content::TitleWatcher watcher(contents, expected_title);
+  content::TitleWatcher watcher(GetWebContents(), expected_title);
   watcher.AlsoWaitForTitle(failure_title);
   GURL url = test_server()->GetURL(
       "files/extensions/api_test/webstore_private/noframe.html");
   ui_test_utils::NavigateToURL(browser(), url);
   base::string16 final_title = watcher.WaitAndGetTitle();
   EXPECT_EQ(expected_title, final_title);
 }
 
 // TODO(mkwst): Disabled until new X-Frame-Options behavior rolls into
 // Chromium, see crbug.com/226018.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
                        DISABLED_FrameErrorPageBlocked) {
-  content::WebContents* contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
   base::string16 expected_title = base::UTF8ToUTF16("PASS: about:blank");
   base::string16 failure_title = base::UTF8ToUTF16("FAIL");
-  content::TitleWatcher watcher(contents, expected_title);
+  content::TitleWatcher watcher(GetWebContents(), expected_title);
   watcher.AlsoWaitForTitle(failure_title);
   GURL url = test_server()->GetURL(
       "files/extensions/api_test/webstore_private/noframe2.html");
   ui_test_utils::NavigateToURL(browser(), url);
   base::string16 final_title = watcher.WaitAndGetTitle();
   EXPECT_EQ(expected_title, final_title);
 }
 
 // Test cases where the user accepts the install confirmation dialog.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest, InstallAccepted) {
@@ skipping 173 matching lines @@
   gpu::GPUInfo gpu_info;
   content::GpuDataManager::GetInstance()->InitializeForTesting(
       json_blacklist, gpu_info);
   EXPECT_TRUE(content::GpuDataManager::GetInstance()->IsFeatureBlacklisted(
       gpu::GPU_FEATURE_TYPE_WEBGL));
 
   bool webgl_allowed = false;
   RunTest(webgl_allowed);
 }
 
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_MissingContinueUrl) {
+  GURL page_url = GetTestServerURL("sign_in_missing_continue_url.html");
+  ASSERT_TRUE(RunPageTest(page_url.spec()));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_InvalidContinueUrl) {
+  GURL page_url = GetTestServerURL("sign_in_invalid_continue_url.html");
+  ASSERT_TRUE(RunPageTest(page_url.spec()));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_ContinueUrlOnDifferentOrigin) {
+  GURL page_url =
+      GetTestServerURL("sign_in_continue_url_on_different_origin.html");
+  ASSERT_TRUE(RunPageTest(page_url.spec()));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_DisallowedInIncognito) {
+  // Make sure that the test is testing something more than the absence of a
+  // sign-in manager for this profile.
+  ASSERT_TRUE(SigninManagerFactory::GetForProfile(profile()));
+
+  GURL page_url =
+      GetTestServerURL("sign_in_disallowed_in_incognito.html");
+  ASSERT_TRUE(
+      RunPageTest(page_url.spec(), ExtensionApiTest::kFlagUseIncognito));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_DisabledWhenWebBasedSigninIsEnabled) {
+  // Make sure that the test is testing something more than the absence of a
+  // sign-in manager for this profile.
+  ASSERT_TRUE(SigninManagerFactory::GetForProfile(profile()));
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kEnableWebBasedSignin);
+  GURL page_url = GetTestServerURL(
+      "sign_in_disabled_when_web_based_signin_is_enabled.html");
+  ASSERT_TRUE(RunPageTest(page_url.spec()));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_AlreadySignedIn) {
+  signin_manager_->SetAuthenticatedUsername("user@example.com");
+  GURL page_url = GetTestServerURL("sign_in_already_signed_in.html");
+  ASSERT_TRUE(RunPageTest(page_url.spec()));
+}
+
+// The FakeSignInManager class is not implemented for ChromeOS, so there's no
+// straightforward way to test these flows on that platform.
+#if !defined(OS_CHROMEOS)
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_AuthInProgress_Fails) {
+  // Initiate an authentication that will be in progress when the sign-in API is
+  // called.
+  signin_manager_->set_auth_in_progress("user@example.com");
+
+  // Navigate to the page, which will cause the sign-in API to be called.
+  // Then, complete the authentication in a failed state.
+  ResultCatcher catcher;
+  StartSignInTest("sign_in_auth_in_progress_fails.html");
+  signin_manager_->FailSignin(GoogleServiceAuthError::AuthErrorNone());
+  ASSERT_TRUE(catcher.GetNextResult());
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_AuthInProgress_MergeSessionFails) {
+  // TODO(isherman): Implement this test.  How do I interpose an event after
+  // navigating to the test URL but before waiting for a success or failure
+  // result?
+  GURL page_url =
+      GetTestServerURL("sign_in_auth_in_progress_merge_session_fails.html");
+  ASSERT_TRUE(RunPageTest(page_url.spec()));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_AuthInProgress_Succeeds) {
+  // Initiate an authentication that will be in progress when the sign-in API is
+  // called.
+  signin_manager_->set_auth_in_progress("user@example.com");
+
+  // Navigate to the page, which will cause the sign-in API to be called.
+  // Then, complete the authentication in a successful state.
+  ResultCatcher catcher;
+  StartSignInTest("sign_in_auth_in_progress_succeeds.html");
+  // TODO(isherman): Need merge session to happen, not for the sign-in to
+  // succeed.  That requires a token to be successfully merged.  Then, we've got
+  // to somehow trigger a call to MergeSessionCompleted -- which can either be
+  // through the SigninManagerFactory or through the AccountReconcilorFactory.
+  // *sigh*.
+  signin_manager_->CompletePendingSignin();
+  //token_service_->IssueRefreshToken("token");
+  ASSERT_TRUE(catcher.GetNextResult());
+}
+#endif  // !defined (OS_CHROMEOS)
+
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       SignIn_RedirectToSignIn) {
+  GURL signin_url(
+      "chrome://chrome-signin/?source=5&continue_url=http%3A%2F%2F"
+      "www.example.com%3A" +
+      base::IntToString(test_server()->host_port_pair().port()) +
+      "%2Fcontinue");
+  ui_test_utils::UrlLoadObserver observer(
+      signin_url,
+      content::Source<content::NavigationController>(
+          &GetWebContents()->GetController()));
+  StartSignInTest("sign_in_redirect_to_sign_in.html");
+  observer.Wait();
+
+  // TODO(isherman): Also test the redirect back to the continue URL once
+  // sign-in completes?
+}
+
 }  // namespace extensions