Revert 282925 "Make the policy fetch for first time login blocking"

trunk/src/chrome/browser/chromeos/login/login_utils_browsertest.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 "chrome/browser/chromeos/login/login_utils.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 510 matching lines @@
 
  private:
   base::ScopedTempDir scoped_temp_dir_;
 
   std::string device_policy_;
   std::string user_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsTest);
 };
 
-struct LoginUtilsBlockingLoginTestParam {
-  const int steps;
-  const char* username;
-  const bool enroll_device;
-};
-
 class LoginUtilsBlockingLoginTest
     : public LoginUtilsTest,
-      public testing::WithParamInterface<LoginUtilsBlockingLoginTestParam> {};
+      public testing::WithParamInterface<int> {};
+
+TEST_F(LoginUtilsTest, NormalLoginDoesntBlock) {
+  UserManager* user_manager = UserManager::Get();
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
+  EXPECT_FALSE(connector_->IsEnterpriseManaged());
+  EXPECT_FALSE(prepared_profile_);
+  EXPECT_EQ(policy::USER_AFFILIATION_NONE,
+            connector_->GetUserAffiliation(kUsername));
+
+  // The profile will be created without waiting for a policy response.
+  PrepareProfile(kUsername);
+
+  EXPECT_TRUE(prepared_profile_);
+  ASSERT_TRUE(user_manager->IsUserLoggedIn());
+  EXPECT_EQ(kUsername, user_manager->GetLoggedInUser()->email());
+}
+
+TEST_F(LoginUtilsTest, EnterpriseLoginDoesntBlockForNormalUser) {
+  UserManager* user_manager = UserManager::Get();
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
+  EXPECT_FALSE(connector_->IsEnterpriseManaged());
+  EXPECT_FALSE(prepared_profile_);
+
+  // Enroll the device.
+  EnrollDevice(kUsername);
+
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
+  EXPECT_TRUE(connector_->IsEnterpriseManaged());
+  EXPECT_EQ(kDomain, connector_->GetEnterpriseDomain());
+  EXPECT_FALSE(prepared_profile_);
+  EXPECT_EQ(policy::USER_AFFILIATION_NONE,
+            connector_->GetUserAffiliation(kUsernameOtherDomain));
+
+  // Login with a non-enterprise user shouldn't block.
+  PrepareProfile(kUsernameOtherDomain);
+
+  EXPECT_TRUE(prepared_profile_);
+  ASSERT_TRUE(user_manager->IsUserLoggedIn());
+  EXPECT_EQ(kUsernameOtherDomain, user_manager->GetLoggedInUser()->email());
+}
 
 #if defined(ENABLE_RLZ)
 TEST_F(LoginUtilsTest, RlzInitialized) {
   // No RLZ brand code set initially.
   EXPECT_FALSE(local_state_.Get()->HasPrefPath(prefs::kRLZBrand));
 
   base::RunLoop wait_for_rlz_init;
   rlz_initialized_cb_ = wait_for_rlz_init.QuitClosure();
 
   PrepareProfile(kUsername);
 
   wait_for_rlz_init.Run();
   // Wait for blocking RLZ tasks to complete.
   RunUntilIdle();
 
   // RLZ brand code has been set to empty string.
   EXPECT_TRUE(local_state_.Get()->HasPrefPath(prefs::kRLZBrand));
   EXPECT_EQ(std::string(), local_state_.Get()->GetString(prefs::kRLZBrand));
 
   // RLZ value for homepage access point should have been initialized.
   base::string16 rlz_string;
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(
       RLZTracker::ChromeHomePage(), &rlz_string));
   EXPECT_EQ(base::string16(), rlz_string);
 }
 #endif
 
-TEST_P(LoginUtilsBlockingLoginTest, LoginBlocksForUser) {
+TEST_P(LoginUtilsBlockingLoginTest, EnterpriseLoginBlocksForEnterpriseUser) {
   UserManager* user_manager = UserManager::Get();
   EXPECT_FALSE(user_manager->IsUserLoggedIn());
   EXPECT_FALSE(connector_->IsEnterpriseManaged());
   EXPECT_FALSE(prepared_profile_);
 
-  if (GetParam().enroll_device) {
-    // Enroll the device.
-    EnrollDevice(kUsername);
+  // Enroll the device.
+  EnrollDevice(kUsername);
 
-    EXPECT_FALSE(user_manager->IsUserLoggedIn());
-    EXPECT_TRUE(connector_->IsEnterpriseManaged());
-    EXPECT_EQ(kDomain, connector_->GetEnterpriseDomain());
-    EXPECT_FALSE(prepared_profile_);
-    EXPECT_EQ(policy::USER_AFFILIATION_MANAGED,
-              connector_->GetUserAffiliation(kUsername));
-    EXPECT_FALSE(user_manager->IsKnownUser(kUsername));
-  }
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
+  EXPECT_TRUE(connector_->IsEnterpriseManaged());
+  EXPECT_EQ(kDomain, connector_->GetEnterpriseDomain());
+  EXPECT_FALSE(prepared_profile_);
+  EXPECT_EQ(policy::USER_AFFILIATION_MANAGED,
+            connector_->GetUserAffiliation(kUsername));
+  EXPECT_FALSE(user_manager->IsKnownUser(kUsername));
 
-  PrepareProfile(GetParam().username);
+  // Login with a user of the enterprise domain waits for policy.
+  PrepareProfile(kUsername);
 
   EXPECT_FALSE(prepared_profile_);
   ASSERT_TRUE(user_manager->IsUserLoggedIn());
   EXPECT_TRUE(user_manager->IsCurrentUserNew());
 
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
   net::TestURLFetcher* fetcher;
 
   // |steps| is the test parameter, and is the number of successful fetches.
   // The first incomplete fetch will fail. In any case, the profile creation
   // should resume.
-  int steps = GetParam().steps;
+  int steps = GetParam();
 
   // The next expected fetcher ID. This is used to make it fail.
   int next_expected_fetcher_id = 0;
 
   do {
     if (steps < 1) break;
 
     // Fake refresh token retrieval:
     fetcher = PrepareOAuthFetcher(gaia_urls->client_login_to_oauth2_url());
     ASSERT_TRUE(fetcher);
@@ skipping 54 matching lines @@
     // fetchers then it will make them fail too.
     fetcher->SetResponseString(kGaiaAccountDisabledResponse);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunUntilIdle();
   }
 
   // The profile is finally ready:
   EXPECT_TRUE(prepared_profile_);
 }
 
-const LoginUtilsBlockingLoginTestParam 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}};
-
-INSTANTIATE_TEST_CASE_P(LoginUtilsBlockingLoginTestInstance,
-                        LoginUtilsBlockingLoginTest,
-                        testing::ValuesIn(kBlockinLoginTestCases));
+INSTANTIATE_TEST_CASE_P(
+    LoginUtilsBlockingLoginTestInstance,
+    LoginUtilsBlockingLoginTest,
+    testing::Values(0, 1, 2, 3, 4, 5));
 
 }  // namespace
 
 }  // namespace chromeos