Identity API: switch WebAuthFlow dialog to component app

chrome/browser/extensions/api/identity/identity_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 "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/identity/identity_api.h"
+#include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/identity/oauth2_manifest_handler.h"
 #include "chrome/test/base/in_process_browser_test.h"
@@ skipping 163 matching lines @@
  private:
   ResultType result_;
   OAuth2MintTokenFlow::Delegate* delegate_;
 };
 
 BrowserContextKeyedService* IdentityAPITestFactory(
     content::BrowserContext* profile) {
   return new IdentityAPI(static_cast<Profile*>(profile));
 }
 
+// Waits for a specific GURL to generate a NOTIFICATION_LOAD_STOP
+// event, and closes the window embedding the webcontents.
+class WaitForGURLAndCloseWindow : public content::WindowedNotificationObserver {
+ public:
+  explicit WaitForGURLAndCloseWindow(GURL url)
+      : WindowedNotificationObserver(
+            content::NOTIFICATION_LOAD_STOP,
+            content::NotificationService::AllSources()),
+        url_(url) {}
+
+  // NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE {
+    content::NavigationController* web_auth_flow_controller =
+        content::Source<content::NavigationController>(source).ptr();
+    content::WebContents* web_contents =
+        web_auth_flow_controller->GetWebContents();
+
+    if (web_contents->GetURL() == url_) {
+      web_contents->GetEmbedderWebContents()->Close();
+      content::WindowedNotificationObserver::Observe(type, source, details);

[miket_OOO, 2013/05/24 16:37:56]

Did you mean to call the inherited behavior only conditionally on == url_?

[Michael Courage, 2013/05/30 22:27:03]

Yes, added a comment to that effect.

+    }
+  }
+
+ private:
+  GURL url_;
+};
+
 }  // namespace
 
 class MockGetAuthTokenFunction : public IdentityGetAuthTokenFunction {
  public:
   MockGetAuthTokenFunction() : login_ui_result_(true),
                                scope_ui_result_(true),
                                login_ui_shown_(false),
                                scope_ui_shown_(false) {
   }
 
@@ skipping 336 matching lines @@
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
   func->set_scope_ui_failure(GaiaWebAuthFlow::WINDOW_CLOSED);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"interactive\": true}]", browser());
   EXPECT_EQ(std::string(errors::kUserRejected), error);
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_TRUE(func->scope_ui_shown());
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       InteractiveApprovalLoadFailed) {
+  scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
+  func->set_extension(CreateExtension(CLIENT_ID | SCOPES));
+  EXPECT_CALL(*func.get(), HasLoginToken())
+      .WillOnce(Return(true));
+  TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
+      TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
+  EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
+  func->set_scope_ui_failure(GaiaWebAuthFlow::LOAD_FAILED);
+  std::string error = utils::RunFunctionAndReturnError(
+      func.get(), "[{\"interactive\": true}]", browser());
+  EXPECT_EQ(std::string(errors::kPageLoadFailure), error);
+  EXPECT_FALSE(func->login_ui_shown());
+  EXPECT_TRUE(func->scope_ui_shown());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
                        InteractiveApprovalInvalidRedirect) {
   scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
   func->set_extension(CreateExtension(CLIENT_ID | SCOPES));
   EXPECT_CALL(*func.get(), HasLoginToken())
       .WillOnce(Return(true));
   TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
       TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
   func->set_scope_ui_failure(GaiaWebAuthFlow::INVALID_REDIRECT);
   std::string error = utils::RunFunctionAndReturnError(
@@ skipping 375 matching lines @@
   IdentityTokenCacheValue token(kAccessToken,
                                 base::TimeDelta::FromSeconds(3600));
   SetCachedToken(token);
   EXPECT_TRUE(InvalidateDefaultToken());
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_NOTFOUND,
             GetCachedToken().status());
 }
 
 class LaunchWebAuthFlowFunctionTest : public AsyncExtensionBrowserTest {
  public:
+  void LoadComponent() {
+    // Normally the ComponentLoader won't load the component in tests.
+    ExtensionService* service = extensions::ExtensionSystem::Get(
+        profile())->extension_service();
+
+    service->component_loader()->Add(
+        IDR_IDENTITY_API_SCOPE_APPROVAL_MANIFEST,
+        base::FilePath(FILE_PATH_LITERAL("identity_scope_approval_dialog")));
+  }
+
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Reduce performance test variance by disabling background networking.
     command_line->AppendSwitch(switches::kDisableBackgroundNetworking);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, UserCloseWindow) {
+  LoadComponent();
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS,
       net::SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL(
           "chrome/test/data/extensions/api_test/identity")));
   ASSERT_TRUE(https_server.Start());
   GURL auth_url(https_server.GetURL("files/interaction_required.html"));
 
   scoped_refptr<IdentityLaunchWebAuthFlowFunction> function(
       new IdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(
       utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
-  content::WindowedNotificationObserver popup_observer(
-      chrome::NOTIFICATION_BROWSER_WINDOW_READY,
-      content::NotificationService::AllSources());
+  WaitForGURLAndCloseWindow popup_observer(auth_url);
 
   std::string args = "[{\"interactive\": true, \"url\": \"" +
       auth_url.spec() + "\"}]";
   RunFunctionAsync(function, args);
 
   popup_observer.Wait();
-  content::Source<Browser>(popup_observer.source())->window()->Close();
 
   EXPECT_EQ(std::string(errors::kUserRejected), WaitForError(function));
 }
 
 IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, InteractionRequired) {
+  LoadComponent();
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS,
       net::SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL(
           "chrome/test/data/extensions/api_test/identity")));
   ASSERT_TRUE(https_server.Start());
   GURL auth_url(https_server.GetURL("files/interaction_required.html"));
 
   scoped_refptr<IdentityLaunchWebAuthFlowFunction> function(
       new IdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(
       utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   std::string args = "[{\"interactive\": false, \"url\": \"" +
       auth_url.spec() + "\"}]";
   std::string error = utils::RunFunctionAndReturnError(function, args,
                                                        browser());
 
   EXPECT_EQ(std::string(errors::kInteractionRequired), error);
 }
 
-IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, NonInteractiveSuccess) {
+IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, LoadFailed) {
+  LoadComponent();
+  net::SpawnedTestServer https_server(
+      net::SpawnedTestServer::TYPE_HTTPS,
+      net::SpawnedTestServer::kLocalhost,
+      base::FilePath(FILE_PATH_LITERAL(
+          "chrome/test/data/extensions/api_test/identity")));
+  ASSERT_TRUE(https_server.Start());
+  GURL auth_url(https_server.GetURL("files/five_hundred.html"));
+
   scoped_refptr<IdentityLaunchWebAuthFlowFunction> function(
       new IdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(
+      utils::CreateEmptyExtension());
+  function->set_extension(empty_extension.get());
+
+  std::string args = "[{\"interactive\": true, \"url\": \"" +
+      auth_url.spec() + "\"}]";
+  std::string error = utils::RunFunctionAndReturnError(function, args,
+                                                       browser());
+
+  EXPECT_EQ(std::string(errors::kPageLoadFailure), error);
+}
+
+IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, NonInteractiveSuccess) {
+  LoadComponent();
+  scoped_refptr<IdentityLaunchWebAuthFlowFunction> function(
+      new IdentityLaunchWebAuthFlowFunction());
+  scoped_refptr<Extension> empty_extension(
       utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   function->InitFinalRedirectURLPrefixForTest("abcdefghij");
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
       function,
       "[{\"interactive\": false,"
       "\"url\": \"https://abcdefghij.chromiumapp.org/callback#test\"}]",
       browser()));
 
   std::string url;
   EXPECT_TRUE(value->GetAsString(&url));
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 IN_PROC_BROWSER_TEST_F(
     LaunchWebAuthFlowFunctionTest, InteractiveFirstNavigationSuccess) {
+  LoadComponent();
   scoped_refptr<IdentityLaunchWebAuthFlowFunction> function(
       new IdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(
       utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   function->InitFinalRedirectURLPrefixForTest("abcdefghij");
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
       function,
       "[{\"interactive\": true,"
       "\"url\": \"https://abcdefghij.chromiumapp.org/callback#test\"}]",
       browser()));
 
   std::string url;
   EXPECT_TRUE(value->GetAsString(&url));
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 IN_PROC_BROWSER_TEST_F(
     LaunchWebAuthFlowFunctionTest, InteractiveSecondNavigationSuccess) {
+  LoadComponent();
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS,
       net::SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL(
           "chrome/test/data/extensions/api_test/identity")));
   ASSERT_TRUE(https_server.Start());
   GURL auth_url(https_server.GetURL("files/redirect_to_chromiumapp.html"));
 
   scoped_refptr<IdentityLaunchWebAuthFlowFunction> function(
       new IdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(
       utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   function->InitFinalRedirectURLPrefixForTest("abcdefghij");
   std::string args = "[{\"interactive\": true, \"url\": \"" +
       auth_url.spec() + "\"}]";
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
       function, args, browser()));
 
   std::string url;
   EXPECT_TRUE(value->GetAsString(&url));
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 }  // namespace extensions