Multiple account support in chrome.identity.getAuthToken

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 <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.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/guest_view/guest_view_base.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_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/identity.h"
 #include "chrome/common/extensions/api/identity/oauth2_manifest_handler.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_switches.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/common/profile_management_switches.h"
@@ skipping 308 matching lines @@
   ~MockGetAuthTokenFunction() {}
   bool login_access_token_result_;
   bool login_ui_result_;
   bool scope_ui_result_;
   GaiaWebAuthFlow::Failure scope_ui_failure_;
   std::string scope_ui_oauth_error_;
   bool login_ui_shown_;
   bool scope_ui_shown_;
 };
 
+// TODO(courage): Replace MockGetAuthTokenFunction with
+// FakeGetAuthTokenFunction in all tests.
+
+class FakeGetAuthTokenFunction : public IdentityGetAuthTokenFunction {
+ public:
+  FakeGetAuthTokenFunction()
+      : login_access_token_result_(true),
+        login_ui_result_(true),
+        scope_ui_result_(true),
+        login_ui_shown_(false),
+        scope_ui_shown_(false) {}
+
+  void set_login_access_token_result(bool result) {
+    login_access_token_result_ = result;
+  }
+
+  void set_login_ui_result(bool result) { login_ui_result_ = result; }
+
+  void set_mint_token_flow(scoped_ptr<OAuth2MintTokenFlow> flow) {
+    flow_ = flow.Pass();
+  }
+
+  void set_scope_ui_failure(GaiaWebAuthFlow::Failure failure) {
+    scope_ui_result_ = false;
+    scope_ui_failure_ = failure;
+  }
+
+  void set_scope_ui_oauth_error(const std::string& oauth_error) {
+    scope_ui_result_ = false;
+    scope_ui_failure_ = GaiaWebAuthFlow::OAUTH_ERROR;
+    scope_ui_oauth_error_ = oauth_error;
+  }
+
+  bool login_ui_shown() const { return login_ui_shown_; }
+
+  bool scope_ui_shown() const { return scope_ui_shown_; }
+
+  std::string login_access_token() const { return login_access_token_; }
+
+  virtual void ShowLoginPopup() OVERRIDE {
+    EXPECT_FALSE(login_ui_shown_);
+    login_ui_shown_ = true;
+    if (login_ui_result_)
+      SigninSuccess();
+    else
+      SigninFailed();
+  }
+
+  virtual void ShowOAuthApprovalDialog(
+      const IssueAdviceInfo& issue_advice) OVERRIDE {
+    scope_ui_shown_ = true;
+
+    if (scope_ui_result_) {
+      OnGaiaFlowCompleted(kAccessToken, "3600");
+    } else if (scope_ui_failure_ == GaiaWebAuthFlow::SERVICE_AUTH_ERROR) {
+      GoogleServiceAuthError error(GoogleServiceAuthError::CONNECTION_FAILED);
+      OnGaiaFlowFailure(scope_ui_failure_, error, "");
+    } else {
+      GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
+      OnGaiaFlowFailure(scope_ui_failure_, error, scope_ui_oauth_error_);
+    }
+  }
+
+  virtual OAuth2MintTokenFlow* CreateMintTokenFlow(
+      const std::string& login_access_token) OVERRIDE {
+    EXPECT_TRUE(login_access_token_.empty());
+    login_access_token_ = login_access_token;
+    return flow_.release();
+  }
+
+ private:
+  virtual ~FakeGetAuthTokenFunction() {}
+  bool login_access_token_result_;
+  bool login_ui_result_;
+  bool scope_ui_result_;
+  GaiaWebAuthFlow::Failure scope_ui_failure_;
+  std::string scope_ui_oauth_error_;
+  bool login_ui_shown_;
+  bool scope_ui_shown_;
+
+  scoped_ptr<OAuth2MintTokenFlow> flow_;
+
+  std::string login_access_token_;
+};
+
 class MockQueuedMintRequest : public IdentityMintRequestQueue::Request {
  public:
   MOCK_METHOD1(StartMintToken, void(IdentityMintRequestQueue::MintType));
 };
 
+AccountIds CreateIds(std::string email, std::string obfid) {
+  AccountIds ids;
+  ids.account_key = email;
+  ids.email = email;
+  ids.gaia = obfid;
+  return ids;
+}
+
 class IdentityGetAccountsFunctionTest : public ExtensionBrowserTest {
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    ExtensionBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kExtensionsMultiAccount);
   }
 
  protected:
   void SetAccountState(AccountIds ids, bool is_signed_in) {
     IdentityAPI::GetFactoryInstance()->Get(profile())->SetAccountStateForTest(
         ids, is_signed_in);
   }
 
-  AccountIds CreateIds(std::string email, std::string obfid) {
-    AccountIds ids;
-    ids.account_key = email;
-    ids.email = email;
-    ids.gaia = obfid;
-    return ids;
-  }
-
   testing::AssertionResult ExpectGetAccounts(
       const std::vector<std::string>& accounts) {
     scoped_refptr<IdentityGetAccountsFunction> func(
         new IdentityGetAccountsFunction);
     func->set_extension(utils::CreateEmptyExtension(kExtensionId).get());
     if (!utils::RunFunction(
             func.get(), std::string("[]"), browser(), utils::NONE)) {
       return GenerateFailureResult(accounts, NULL)
              << "getAccounts did not return a result.";
     }
@@ skipping 101 matching lines @@
 IN_PROC_BROWSER_TEST_F(IdentityOldProfilesGetAccountsFunctionTest,
                        TwoAccountsSignedIn) {
   SetAccountState(CreateIds("primary@example.com", "1"), true);
   SetAccountState(CreateIds("secondary@example.com", "2"), true);
   std::vector<std::string> only_primary;
   only_primary.push_back("1");
   EXPECT_TRUE(ExpectGetAccounts(only_primary));
 }
 
 class GetAuthTokenFunctionTest : public AsyncExtensionBrowserTest {
+ public:
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    AsyncExtensionBrowserTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitch(switches::kExtensionsMultiAccount);
+  }
+
+  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+    AsyncExtensionBrowserTest::SetUpInProcessBrowserTestFixture();
+
+    will_create_browser_context_services_subscription_ =
+        BrowserContextDependencyManager::GetInstance()
+            ->RegisterWillCreateBrowserContextServicesCallbackForTesting(
+                  base::Bind(&GetAuthTokenFunctionTest::
+                                 OnWillCreateBrowserContextServices,
+                             base::Unretained(this)))
+            .Pass();
+  }
+
+  void OnWillCreateBrowserContextServices(content::BrowserContext* context) {
+    // Replace the signin manager and token service with fakes. Do this ahead of
+    // creating the browser so that a bunch of classes don't register as
+    // observers and end up needing to unregister when the fake is substituted.
+    SigninManagerFactory::GetInstance()->SetTestingFactory(
+        context, &FakeSigninManagerBase::Build);
+    ProfileOAuth2TokenServiceFactory::GetInstance()->SetTestingFactory(
+        context, &BuildFakeProfileOAuth2TokenService);
+  }
+
+  virtual void SetUpOnMainThread() OVERRIDE {
+    AsyncExtensionBrowserTest::SetUpOnMainThread();
+
+    // Grab references to the fake signin manager and token service.
+    signin_manager_ = static_cast<FakeSigninManagerForTesting*>(
+        SigninManagerFactory::GetInstance()->GetForProfile(profile()));
+    ASSERT_TRUE(signin_manager_);
+    token_service_ = static_cast<FakeProfileOAuth2TokenService*>(
+        ProfileOAuth2TokenServiceFactory::GetInstance()->GetForProfile(
+            profile()));
+    ASSERT_TRUE(token_service_);
+  }
+
+  void SignIn(const std::string account_key) {
+#if defined(OS_CHROMEOS)
+    signin_manager_->SetAuthenticatedUsername(account_key);
+#else
+    signin_manager_->SignIn(account_key, "password");
+#endif
+  }
+
+  void SetAccountState(AccountIds ids, bool is_signed_in) {
+    IdentityAPI::GetFactoryInstance()->Get(profile())->SetAccountStateForTest(
+        ids, is_signed_in);
+  }
+
  protected:
   enum OAuth2Fields {
     NONE = 0,
     CLIENT_ID = 1,
     SCOPES = 2,
     AS_COMPONENT = 4
   };
 
+  FakeSigninManagerForTesting* signin_manager_;
+  FakeProfileOAuth2TokenService* token_service_;
+
   virtual ~GetAuthTokenFunctionTest() {}
 
   // Helper to create an extension with specific OAuth2Info fields set.
   // |fields_to_set| should be computed by using fields of Oauth2Fields enum.
   const Extension* CreateExtension(int fields_to_set) {
     const Extension* ext;
     base::FilePath manifest_path =
         test_data_dir_.AppendASCII("platform_apps/oauth2");
     base::FilePath component_manifest_path =
         test_data_dir_.AppendASCII("packaged_app/component_oauth2");
@@ skipping 24 matching lines @@
     SigninManagerBase* signin_manager =
         SigninManagerFactory::GetForProfile(browser()->profile());
     return signin_manager->GetAuthenticatedAccountId();
   }
 
   void SetCachedToken(const IdentityTokenCacheValue& token_data) {
     ExtensionTokenKey key(extension_id_, GetPrimaryAccountId(), oauth_scopes_);
     id_api()->SetCachedToken(key, token_data);
   }
 
-  const IdentityTokenCacheValue& GetCachedToken() {
-    ExtensionTokenKey key(extension_id_, GetPrimaryAccountId(), oauth_scopes_);
+  const IdentityTokenCacheValue& GetCachedToken(std::string account_id) {
+    if (account_id.empty())
+      account_id = GetPrimaryAccountId();
+    ExtensionTokenKey key(extension_id_, account_id, oauth_scopes_);
     return id_api()->GetCachedToken(key);
   }
 
   void QueueRequestStart(IdentityMintRequestQueue::MintType type,
                          IdentityMintRequestQueue::Request* request) {
     ExtensionTokenKey key(extension_id_, GetPrimaryAccountId(), oauth_scopes_);
     id_api()->mint_queue()->RequestStart(type, key, request);
   }
 
   void QueueRequestComplete(IdentityMintRequestQueue::MintType type,
                             IdentityMintRequestQueue::Request* request) {
     ExtensionTokenKey key(extension_id_, GetPrimaryAccountId(), oauth_scopes_);
     id_api()->mint_queue()->RequestComplete(type, key, request);
   }
 
  private:
   std::string extension_id_;
   std::set<std::string> oauth_scopes_;
+
+  scoped_ptr<base::CallbackList<void(content::BrowserContext*)>::Subscription>
+      will_create_browser_context_services_subscription_;
 };
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
                        NoClientId) {
   scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
   func->set_extension(CreateExtension(SCOPES));
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{}]", browser());
   EXPECT_EQ(std::string(errors::kInvalidClientId), error);
   EXPECT_FALSE(func->login_ui_shown());
@@ skipping 60 matching lines @@
   TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
       TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{}]", browser());
   EXPECT_EQ(std::string(errors::kNoGrant), error);
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
 
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_ADVICE,
-            GetCachedToken().status());
+            GetCachedToken(std::string()).status());
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
                        NonInteractiveMintBadCredentials) {
   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::MINT_TOKEN_BAD_CREDENTIALS, func.get());
@@ skipping 42 matching lines @@
       TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
       func.get(), "[{}]", browser()));
   std::string access_token;
   EXPECT_TRUE(value->GetAsString(&access_token));
   EXPECT_EQ(std::string(kAccessToken), access_token);
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
-            GetCachedToken().status());
+            GetCachedToken(std::string()).status());
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
                        InteractiveLoginCanceled) {
   scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
   func->set_extension(CreateExtension(CLIENT_ID | SCOPES));
   EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(false));
   func->set_login_ui_result(false);
   std::string error = utils::RunFunctionAndReturnError(
       func.get(), "[{\"interactive\": true}]", browser());
@@ skipping 235 matching lines @@
 
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
       func.get(), "[{\"interactive\": true}]", browser()));
   std::string access_token;
   EXPECT_TRUE(value->GetAsString(&access_token));
   EXPECT_EQ(std::string(kAccessToken), access_token);
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_TRUE(func->scope_ui_shown());
 
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
-            GetCachedToken().status());
+            GetCachedToken(std::string()).status());
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, NoninteractiveQueue) {
   scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
   scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
   func->set_extension(extension.get());
 
   // Create a fake request to block the queue.
   MockQueuedMintRequest queued_request;
   IdentityMintRequestQueue::MintType type =
@@ skipping 240 matching lines @@
       .WillOnce(Return(flow));
 
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
       func.get(), "[{\"interactive\": true}]", browser()));
   std::string access_token;
   EXPECT_TRUE(value->GetAsString(&access_token));
   EXPECT_EQ(std::string(kAccessToken), access_token);
   EXPECT_TRUE(func->login_ui_shown());
   EXPECT_TRUE(func->scope_ui_shown());
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
-            GetCachedToken().status());
+            GetCachedToken(std::string()).status());
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, ComponentWithChromeClientId) {
   scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
   scoped_refptr<const Extension> extension(
       CreateExtension(SCOPES | AS_COMPONENT));
   func->set_extension(extension.get());
   const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension.get());
   EXPECT_TRUE(oauth2_info.client_id.empty());
   EXPECT_FALSE(func->GetOAuth2ClientId().empty());
   EXPECT_NE("client1", func->GetOAuth2ClientId());
 }
 
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, ComponentWithNormalClientId) {
   scoped_refptr<MockGetAuthTokenFunction> func(new MockGetAuthTokenFunction());
   scoped_refptr<const Extension> extension(
       CreateExtension(CLIENT_ID | SCOPES | AS_COMPONENT));
   func->set_extension(extension.get());
   EXPECT_EQ("client1", func->GetOAuth2ClientId());
 }
 
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, MultiDefaultUser) {
+  SignIn("primary@example.com");
+  token_service_->IssueRefreshTokenForUser("primary@example.com",
+                                           "refresh_token");
+  SetAccountState(CreateIds("primary@example.com", "1"), true);
+  SetAccountState(CreateIds("secondary@example.com", "2"), true);
+
+  scoped_refptr<FakeGetAuthTokenFunction> func(new FakeGetAuthTokenFunction());
+  scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
+  func->set_extension(extension.get());
+  func->set_mint_token_flow(
+      scoped_ptr<OAuth2MintTokenFlow>(new TestOAuth2MintTokenFlow(
+          TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get())));
+
+  RunFunctionAsync(func.get(), "[{}]");
+
+  token_service_->IssueAllTokensForAccount(
+      "primary@example.com",
+      "access_token-primary@example.com",
+      base::Time::Now() + base::TimeDelta::FromSeconds(3600));
+
+  scoped_ptr<base::Value> value(WaitForSingleResult(func.get()));
+  std::string access_token;
+  EXPECT_TRUE(value->GetAsString(&access_token));
+  EXPECT_EQ(std::string(kAccessToken), access_token);
+  EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
+            GetCachedToken(std::string()).status());
+  EXPECT_EQ("access_token-primary@example.com", func->login_access_token());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, MultiPrimaryUser) {
+  SignIn("primary@example.com");
+  token_service_->IssueRefreshTokenForUser("primary@example.com",
+                                           "refresh_token");
+  SetAccountState(CreateIds("primary@example.com", "1"), true);
+  SetAccountState(CreateIds("secondary@example.com", "2"), true);
+
+  scoped_refptr<FakeGetAuthTokenFunction> func(new FakeGetAuthTokenFunction());
+  scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
+  func->set_extension(extension.get());
+  func->set_mint_token_flow(
+      scoped_ptr<OAuth2MintTokenFlow>(new TestOAuth2MintTokenFlow(
+          TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get())));
+
+  RunFunctionAsync(func.get(), "[{\"account\": { \"id\": \"1\" } }]");
+
+  token_service_->IssueAllTokensForAccount(
+      "primary@example.com",
+      "access_token-primary@example.com",
+      base::Time::Now() + base::TimeDelta::FromSeconds(3600));
+
+  scoped_ptr<base::Value> value(WaitForSingleResult(func.get()));
+  std::string access_token;
+  EXPECT_TRUE(value->GetAsString(&access_token));
+  EXPECT_EQ(std::string(kAccessToken), access_token);
+  EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
+            GetCachedToken(std::string()).status());
+  EXPECT_EQ("access_token-primary@example.com", func->login_access_token());
+}
+
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, MultiSecondaryUser) {

[fgorski, 2014/06/03 23:46:41]

are you planning to add negative tests for secondary users?

[Michael Courage, 2014/06/04 23:37:38]

TODO added

+  SignIn("primary@example.com");
+  token_service_->IssueRefreshTokenForUser("secondary@example.com",
+                                           "refresh_token");
+  SetAccountState(CreateIds("primary@example.com", "1"), true);
+  SetAccountState(CreateIds("secondary@example.com", "2"), true);
+
+  scoped_refptr<FakeGetAuthTokenFunction> func(new FakeGetAuthTokenFunction());
+  scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
+  func->set_extension(extension.get());
+  func->set_mint_token_flow(
+      scoped_ptr<OAuth2MintTokenFlow>(new TestOAuth2MintTokenFlow(
+          TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get())));
+
+  RunFunctionAsync(func.get(), "[{\"account\": { \"id\": \"2\" } }]");
+
+  token_service_->IssueAllTokensForAccount(
+      "secondary@example.com",
+      "access_token-secondary@example.com",
+      base::Time::Now() + base::TimeDelta::FromSeconds(3600));
+
+  scoped_ptr<base::Value> value(WaitForSingleResult(func.get()));
+  std::string access_token;
+  EXPECT_TRUE(value->GetAsString(&access_token));
+  EXPECT_EQ(std::string(kAccessToken), access_token);
+  EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
+            GetCachedToken("secondary@example.com").status());
+  EXPECT_EQ("access_token-secondary@example.com", func->login_access_token());
+}
+
 class RemoveCachedAuthTokenFunctionTest : public ExtensionBrowserTest {
  protected:
   bool InvalidateDefaultToken() {
     scoped_refptr<IdentityRemoveCachedAuthTokenFunction> func(
         new IdentityRemoveCachedAuthTokenFunction);
     func->set_extension(utils::CreateEmptyExtension(kExtensionId).get());
     return utils::RunFunction(
         func.get(),
         std::string("[{\"token\": \"") + kAccessToken + "\"}]",
         browser(),
@@ skipping 51 matching lines @@
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_TOKEN,
             GetCachedToken().status());
   EXPECT_TRUE(InvalidateDefaultToken());
   EXPECT_EQ(IdentityTokenCacheValue::CACHE_STATUS_NOTFOUND,
             GetCachedToken().status());
 }
 
 class LaunchWebAuthFlowFunctionTest : public AsyncExtensionBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    AsyncExtensionBrowserTest::SetUpCommandLine(command_line);
     // Reduce performance test variance by disabling background networking.
     command_line->AppendSwitch(switches::kDisableBackgroundNetworking);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(LaunchWebAuthFlowFunctionTest, UserCloseWindow) {
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS,
       net::SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL(
@@ skipping 145 matching lines @@
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 }  // namespace extensions
 
 // Tests the chrome.identity API implemented by custom JS bindings .
 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeIdentityJsBindings) {
   ASSERT_TRUE(RunExtensionTest("identity/js_bindings")) << message_;
 }