Fix flakiness in login_utils_browsertest.cc.

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/command_line.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/mock_cryptohome_library.h"
 #include "chrome/browser/chromeos/cros/mock_library_loader.h"
 #include "chrome/browser/chromeos/cryptohome/mock_async_method_caller.h"
 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/login_status_consumer.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/predictor.h"
@@ skipping 59 matching lines @@
 const char kDMToken[] = "1234";
 
 ACTION_P(MockSessionManagerClientRetrievePolicyCallback, policy) {
   arg0.Run(*policy);
 }
 
 ACTION_P(MockSessionManagerClientStorePolicyCallback, success) {
   arg1.Run(success);
 }
 
-template<typename TESTBASE>
-class LoginUtilsTestBase : public TESTBASE,
-                           public LoginUtils::Delegate,
-                           public LoginStatusConsumer {
+class LoginUtilsTest : public testing::Test,
+                       public LoginUtils::Delegate,
+                       public LoginStatusConsumer {
  public:
   // Initialization here is important. The UI thread gets the test's
   // message loop, as does the file thread (which never actually gets
   // started - so this is a way to fake multiple threads on a single
   // test thread).  The IO thread does not get the message loop set,
   // and is never started.  This is necessary so that we skip various
   // bits of initialization that get posted to the IO thread.  We do
   // however, at one point in the test, temporarily set the message
   // loop for the IO thread.
-  LoginUtilsTestBase()
+  LoginUtilsTest()
       : loop_(MessageLoop::TYPE_IO),
         browser_process_(
             static_cast<TestingBrowserProcess*>(g_browser_process)),
         local_state_(browser_process_),
         ui_thread_(content::BrowserThread::UI, &loop_),
         file_thread_(content::BrowserThread::FILE, &loop_),
         io_thread_(content::BrowserThread::IO),
         mock_async_method_caller_(NULL),
         connector_(NULL),
         cryptohome_(NULL),
@@ skipping 88 matching lines @@
     EXPECT_CALL(*cryptohome_, InstallAttributesGet(kAttrEnterpriseDeviceId, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(kDeviceId),
                               Return(true)));
     test_api->SetCryptohomeLibrary(cryptohome_, true);
 
     browser_process_->SetProfileManager(
         new ProfileManagerWithoutInit(scoped_temp_dir_.path()));
     connector_ = browser_process_->browser_policy_connector();
     connector_->Init();
 
-    loop_.RunAllPending();
+    RunAllPending();
   }
 
   virtual void TearDown() OVERRIDE {
     cryptohome::AsyncMethodCaller::Shutdown();
     mock_async_method_caller_ = NULL;
 
-    loop_.RunAllPending();
+    RunAllPending();
     {
       // chrome_browser_net::Predictor usually skips its shutdown routines on
       // unit_tests, but does the full thing when
       // g_browser_process->profile_manager() is valid during initialization.
       // Run a task on a temporary BrowserThread::IO that allows skipping
       // these routines.
       //
       // It is important to not have a fake message loop on the IO
-      // thread for the whole test, see comment on LoginUtilsTestBase
+      // thread for the whole test, see comment on LoginUtilsTest
       // constructor for details.
       io_thread_.DeprecatedSetMessageLoop(&loop_);
       loop_.PostTask(FROM_HERE,
-                     base::Bind(&LoginUtilsTestBase::TearDownOnIO,
+                     base::Bind(&LoginUtilsTest::TearDownOnIO,
                                 base::Unretained(this)));
-      loop_.RunAllPending();
+      RunAllPending();
       io_thread_.DeprecatedSetMessageLoop(NULL);
     }
 
     // These trigger some tasks that have to run while BrowserThread::UI
     // exists.
     connector_ = NULL;
     browser_process_->SetBrowserPolicyConnector(NULL);
     browser_process_->SetProfileManager(NULL);
-    loop_.RunAllPending();
+    RunAllPending();
   }
 
   void TearDownOnIO() {
     std::vector<Profile*> profiles =
         browser_process_->profile_manager()->GetLoadedProfiles();
     for (size_t i = 0; i < profiles.size(); ++i) {
       chrome_browser_net::Predictor* predictor =
           profiles[i]->GetNetworkPredictor();
       if (predictor) {
         predictor->EnablePredictorOnIOThread(false);
         predictor->Shutdown();
       }
     }
   }
 
+  void RunAllPending() {
+    loop_.RunAllPending();
+    BrowserThread::GetBlockingPool()->FlushForTesting();
+    loop_.RunAllPending();
+  }
+
   virtual void OnProfilePrepared(Profile* profile) OVERRIDE {
     EXPECT_FALSE(prepared_profile_);
     prepared_profile_ = profile;
   }
 
   virtual void OnLoginFailure(const LoginFailure& error) OVERRIDE {
     FAIL() << "OnLoginFailure not expected";
   }
 
   virtual void OnLoginSuccess(const std::string& username,
                               const std::string& password,
                               bool pending_requests,
                               bool using_oauth) OVERRIDE {
     FAIL() << "OnLoginSuccess not expected";
   }
 
   void LockDevice(const std::string& username) {
     EXPECT_CALL(*cryptohome_, InstallAttributesIsFirstInstall())
         .WillOnce(Return(true))
         .WillRepeatedly(Return(false));
     policy::CloudPolicyDataStore* device_data_store =
         connector_->GetDeviceCloudPolicyDataStore();
     device_data_store->set_device_mode(policy::DEVICE_MODE_ENTERPRISE);
     device_data_store->set_device_id(kDeviceId);
     EXPECT_EQ(policy::EnterpriseInstallAttributes::LOCK_SUCCESS,
               connector_->LockDevice(username));
-    loop_.RunAllPending();
+    RunAllPending();
   }
 
   void PrepareProfile(const std::string& username) {
     MockSessionManagerClient* session_managed_client =
         mock_dbus_thread_manager_.mock_session_manager_client();
     EXPECT_CALL(*session_managed_client, StartSession(_));
     EXPECT_CALL(*cryptohome_, GetSystemSalt())
         .WillRepeatedly(Return(std::string("stub_system_salt")));
     EXPECT_CALL(*mock_async_method_caller_, AsyncMount(_, _, _, _))
         .WillRepeatedly(Return());
 
     scoped_refptr<Authenticator> authenticator =
         LoginUtils::Get()->CreateAuthenticator(this);
     authenticator->CompleteLogin(ProfileManager::GetDefaultProfile(),
                                  username,
                                  "password");
 
     LoginUtils::Get()->PrepareProfile(username, std::string(), "password",
                                       false, true, false, this);
-    loop_.RunAllPending();
+    RunAllPending();
   }
 
   TestURLFetcher* PrepareOAuthFetcher(const std::string& expected_url) {
     TestURLFetcher* fetcher = test_url_fetcher_factory_.GetFetcherByID(0);
     EXPECT_TRUE(fetcher);
     EXPECT_TRUE(fetcher->delegate());
     EXPECT_TRUE(StartsWithASCII(fetcher->GetOriginalURL().spec(),
                                 expected_url,
                                 true));
     fetcher->set_url(fetcher->GetOriginalURL());
@@ skipping 57 matching lines @@
   policy::BrowserPolicyConnector* connector_;
   MockCryptohomeLibrary* cryptohome_;
   Profile* prepared_profile_;
 
  private:
   ScopedTempDir scoped_temp_dir_;
 
   std::string device_policy_;
   std::string user_policy_;
 
-  DISALLOW_COPY_AND_ASSIGN(LoginUtilsTestBase);
-};
-
-class LoginUtilsTest : public LoginUtilsTestBase<testing::Test> {
+  DISALLOW_COPY_AND_ASSIGN(LoginUtilsTest);
 };
 
 class LoginUtilsBlockingLoginTest
-    : public LoginUtilsTestBase<testing::TestWithParam<int> > {
-};
+    : public LoginUtilsTest,
+      public testing::WithParamInterface<int> {};
 
 TEST_F(LoginUtilsTest, NormalLoginDoesntBlock) {
   UserManager* user_manager = UserManager::Get();
   ASSERT_TRUE(!user_manager->IsUserLoggedIn() ||
               user_manager->IsLoggedInAsStub());
   EXPECT_FALSE(connector_->IsEnterpriseManaged());
   EXPECT_FALSE(prepared_profile_);
 
   // The profile will be created without waiting for a policy response.
   PrepareProfile(kUsername);
@@ skipping 77 matching lines @@
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     if (steps < 3) break;
 
     // Fake OAuth service token retrieval:
     fetcher = PrepareOAuthFetcher(gaia_urls->oauth_wrap_bridge_url());
     fetcher->SetResponseString(kOAuthServiceTokenData);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     // The cloud policy subsystem is now ready to fetch the dmtoken and the user
     // policy.
-    loop_.RunAllPending();
+    RunAllPending();
     if (steps < 4) break;
 
     fetcher = PrepareDMRegisterFetcher();
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     // The policy fetch job has now been scheduled, run it:
-    loop_.RunAllPending();
+    RunAllPending();
     if (steps < 5) break;
 
     // Verify that there is no profile prepared just before the policy fetch.
     EXPECT_FALSE(prepared_profile_);
 
     fetcher = PrepareDMPolicyFetcher();
     fetcher->delegate()->OnURLFetchComplete(fetcher);
   } while (0);
 
   if (steps < 5) {
@@ skipping 14 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(
     LoginUtilsBlockingLoginTestInstance,
     LoginUtilsBlockingLoginTest,
     testing::Values(0, 1, 2, 3, 4, 5));
 
 }  // namespace
 
 }