Test BlockingLoginTestInstance with enabled webview

chrome/browser/chromeos/policy/blocking_login_browsertest.cc

 // Copyright 2014 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
@@ skipping 60 matching lines @@
   *out = result;
   loop->Quit();
 }
 
 }  // namespace
 
 struct BlockingLoginTestParam {
   const int steps;
   const char* username;
   const bool enroll_device;
+  const bool use_webview;
 };
 
 class BlockingLoginTest
     : public OobeBaseTest,
       public content::NotificationObserver,
       public testing::WithParamInterface<BlockingLoginTestParam> {
  public:
   BlockingLoginTest() : profile_added_(NULL) {
     // TODO(nkostylev): Fix this test for webview. http://crbug.com/477402
-    set_use_webview(false);
+    set_use_webview(GetParam().use_webview);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     OobeBaseTest::SetUpCommandLine(command_line);
 
-    command_line->AppendSwitchASCII(::switches::kAuthExtensionPath,
-                                    "gaia_auth");
     command_line->AppendSwitchASCII(
         policy::switches::kDeviceManagementUrl,
         embedded_test_server()->GetURL("/device_management").spec());
   }
 
   void SetUpOnMainThread() override {
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROFILE_ADDED,
                    content::NotificationService::AllSources());
 
@@ skipping 17 matching lines @@
 
   void RunUntilIdle() {
     base::RunLoop().RunUntilIdle();
   }
 
   policy::BrowserPolicyConnectorChromeOS* browser_policy_connector() {
     return g_browser_process->platform_part()
         ->browser_policy_connector_chromeos();
   }
 
-  void SkipToSigninScreen() {
-    WizardController::SkipPostLoginScreensForTesting();
-    WizardController* wizard_controller =
-        WizardController::default_controller();
-    ASSERT_TRUE(wizard_controller);
-    wizard_controller->SkipToLoginForTesting(LoginScreenContext());
-
-    content::WindowedNotificationObserver(
-        chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
-        content::NotificationService::AllSources()).Wait();
-    RunUntilIdle();
-  }
-
   void EnrollDevice(const std::string& username) {
     base::RunLoop loop;
     policy::EnterpriseInstallAttributes::LockResult result;
     browser_policy_connector()->GetInstallAttributes()->LockDevice(
         username, policy::DEVICE_MODE_ENTERPRISE, "100200300",
         base::Bind(&CopyLockResult, &loop, &result));
     loop.Run();
     EXPECT_EQ(policy::EnterpriseInstallAttributes::LOCK_SUCCESS, result);
     RunUntilIdle();
   }
@@ skipping 103 matching lines @@
     EXPECT_EQ(kDomain, browser_policy_connector()->GetEnterpriseDomain());
     EXPECT_FALSE(profile_added_);
     EXPECT_EQ(policy::USER_AFFILIATION_MANAGED,
               browser_policy_connector()->GetUserAffiliation(kUsername));
     RunUntilIdle();
     EXPECT_FALSE(user_manager->IsKnownUser(kUsername));
   }
 
   // Skip the OOBE, go to the sign-in screen, and wait for the login screen to
   // become visible.
-  SkipToSigninScreen();
+  WaitForSigninScreen();
   EXPECT_FALSE(profile_added_);
 
   // Prepare the fake HTTP responses.
   if (GetParam().steps < 5) {
     // If this instance is not going to complete the entire flow successfully
     // then the last step will fail.
 
     // This response body is important to make the gaia fetcher skip its delayed
     // retry behavior, which makes testing harder. If this is sent to the policy
     // fetchers then it will make them fail too.
     PushResponse(net::HTTP_UNAUTHORIZED).set_content("Error=AccountDeleted");
   }
 
   // Push a response for each step that is going to succeed, in reverse order.
   switch (GetParam().steps) {
     default:
       ADD_FAILURE() << "Invalid step number: " << GetParam().steps;
       return;
 
     case 5:
       PushResponse(net::HTTP_OK).set_content(GetPolicyResponse());
 
     case 4:
       PushResponse(net::HTTP_OK).set_content(GetRegisterResponse());
 
     case 3:
-      PushResponse(net::HTTP_OK).set_content(kOAuth2AccessTokenData);
+      if (!GetParam().use_webview)
+        PushResponse(net::HTTP_OK).set_content(kOAuth2AccessTokenData);
 
     case 2:
-      PushResponse(net::HTTP_OK).set_content(kOAuth2TokenPairData);
+      if (!GetParam().use_webview)
+        PushResponse(net::HTTP_OK).set_content(kOAuth2TokenPairData);
 
     case 1:
       PushResponse(net::HTTP_OK)
           .AddCustomHeader("Set-Cookie", kOAuthCodeCookie);
       break;
 
     case 0:
       break;
   }
 
   // Login now. This verifies that logging in with the canned responses (which
   // may include failures) won't be blocked due to the potential failures.
   EXPECT_FALSE(profile_added_);
   Login(GetParam().username);
   EXPECT_TRUE(profile_added_);
   ASSERT_TRUE(user_manager->IsUserLoggedIn());
   EXPECT_TRUE(user_manager->IsCurrentUserNew());
 }
 
 const BlockingLoginTestParam kBlockinLoginTestCases[] = {
-    { 0, kUsername, true },
-    { 1, kUsername, true },
-    { 2, kUsername, true },
-    { 3, kUsername, true },
-    { 4, kUsername, true },
-    { 5, kUsername, true },
-    { 0, kUsername, false },
-    { 1, kUsername, false },
-    { 2, kUsername, false },
-    { 3, kUsername, false },
-    { 4, kUsername, false },
-    { 5, kUsername, false },
-    { 0, kUsernameOtherDomain, true },
-    { 1, kUsernameOtherDomain, true },
-    { 2, kUsernameOtherDomain, true },
-    { 3, kUsernameOtherDomain, true },
-    { 4, kUsernameOtherDomain, true },
-    { 5, kUsernameOtherDomain, true },
+    {0, kUsername, true, false},
+    {1, kUsername, true, false},
+    {2, kUsername, true, false},
+    {3, kUsername, true, false},
+    {4, kUsername, true, false},
+    {5, kUsername, true, false},
+    {0, kUsername, false, false},
+    {1, kUsername, false, false},
+    {2, kUsername, false, false},
+    {3, kUsername, false, false},
+    {4, kUsername, false, false},
+    {5, kUsername, false, false},
+    {0, kUsernameOtherDomain, true, false},
+    {1, kUsernameOtherDomain, true, false},
+    {2, kUsernameOtherDomain, true, false},
+    {3, kUsernameOtherDomain, true, false},
+    {4, kUsernameOtherDomain, true, false},
+    {5, kUsernameOtherDomain, true, false},
+
+    {0, kUsername, true, true},
+    {1, kUsername, true, true},
+    {2, kUsername, true, true},
+    {3, kUsername, true, true},
+    {4, kUsername, true, true},
+    {5, kUsername, true, true},
+    {0, kUsername, false, true},
+    {1, kUsername, false, true},
+    {2, kUsername, false, true},
+    {3, kUsername, false, true},
+    {4, kUsername, false, true},
+    {5, kUsername, false, true},
+    {0, kUsernameOtherDomain, true, true},
+    {1, kUsernameOtherDomain, true, true},
+    {2, kUsernameOtherDomain, true, true},
+    {3, kUsernameOtherDomain, true, true},
+    {4, kUsernameOtherDomain, true, true},
+    {5, kUsernameOtherDomain, true, true},
 };
 
 INSTANTIATE_TEST_CASE_P(BlockingLoginTestInstance,
                         BlockingLoginTest,
                         testing::ValuesIn(kBlockinLoginTestCases));
 
 }  // namespace chromeos