Have content/ create and destroy its own threads.

chrome/browser/chromeos/login/login_utils_browsertest.cc

 // Copyright (c) 2011 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"
@@ skipping 12 matching lines @@
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/net/gaia/gaia_auth_consumer.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/common/url_fetcher_delegate.h"
 #include "content/test/test_browser_thread.h"
 #include "content/test/test_url_fetcher_factory.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 
 namespace {
 
 namespace em = enterprise_management;
 
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 using ::testing::_;
+using content::BrowserThread;
 
 const char kTrue[] = "true";
 const char kDomain[] = "domain.com";
 const char kUsername[] = "user@domain.com";
 const char kUsernameOtherDomain[] = "user@other.com";
 const char kAttributeOwned[] = "enterprise.owned";
 const char kAttributeOwner[] = "enterprise.user";
 
 const char kOAuthTokenCookie[] = "oauth_token=1234";
 const char kOAuthGetAccessTokenData[] =
     "oauth_token=1234&oauth_token_secret=1234";
 const char kOAuthServiceTokenData[] =
     "wrap_access_token=1234&wrap_access_token_expires_in=123456789";
 
 const char kDMServer[] = "http://server/device_management";
 const char kDMRegisterRequest[] =
     "http://server/device_management?request=register";
 const char kDMPolicyRequest[] =
     "http://server/device_management?request=policy";
 
 const char kDMToken[] = "1234";
 
 ACTION_P(MockSessionManagerClientPolicyCallback, policy) {
   arg0.Run(policy);
 }
 
-// Subclass IOThread to expose set_message_loop.
-class TestIOThread : public IOThread {
- public:
-  explicit TestIOThread(PrefService* local_state)
-      : IOThread(local_state, NULL, NULL) {}
-
-  using IOThread::set_message_loop;
-};
-
 template<typename TESTBASE>
 class LoginUtilsTestBase : public TESTBASE,
                            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()
       : 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_(local_state_.Get()),
+        io_thread_(content::BrowserThread::IO),
+        io_thread_state_(local_state_.Get(), NULL, NULL),
         prepared_profile_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     // BrowserPolicyConnector makes the UserPolicyCache read relative to this
     // path. Make sure it's in a clean state.
     PathService::Override(chrome::DIR_USER_DATA, scoped_temp_dir_.path());
 
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kEnableDevicePolicy);
     command_line->AppendSwitchASCII(switches::kDeviceManagementUrl, kDMServer);
     command_line->AppendSwitchASCII(switches::kLoginProfile, "user");
 
     local_state_.Get()->RegisterStringPref(prefs::kApplicationLocale, "");
 
-    browser_process_->SetIOThread(&io_thread_);
+    browser_process_->SetIOThread(&io_thread_state_);
 
     DBusThreadManager::InitializeForTesting(&dbus_thread_manager_);
 
     MockSessionManagerClient* session_managed_client =
         dbus_thread_manager_.mock_session_manager_client();
     EXPECT_CALL(*session_managed_client, RetrievePolicy(_))
         .WillRepeatedly(MockSessionManagerClientPolicyCallback(""));
 
     CrosLibrary::TestApi* test_api = CrosLibrary::Get()->GetTestApi();
     ASSERT_TRUE(test_api);
@@ skipping 37 matching lines @@
   }
 
   virtual void TearDown() OVERRIDE {
     loop_.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.
-      io_thread_.set_message_loop(&loop_);
+      //
+      // It is important to not have a fake message loop on the IO
+      // thread for the whole test, see comment on LoginUtilsTestBase
+      // constructor for details.
+      io_thread_.DeprecatedSetMessageLoop(&loop_);
       loop_.PostTask(FROM_HERE,
                      base::Bind(&LoginUtilsTestBase::TearDownOnIO,
                                 base::Unretained(this)));
       loop_.RunAllPending();
-      io_thread_.set_message_loop(NULL);
+      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();
   }
 
@@ skipping 110 matching lines @@
 
  protected:
   ScopedStubCrosEnabler stub_cros_enabler_;
 
   MessageLoop loop_;
   TestingBrowserProcess* browser_process_;
   ScopedTestingLocalState local_state_;
 
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
-  TestIOThread io_thread_;
+  content::TestBrowserThread io_thread_;
+  IOThread io_thread_state_;
 
   MockDBusThreadManager dbus_thread_manager_;
   TestURLFetcherFactory test_url_fetcher_factory_;
 
   policy::BrowserPolicyConnector* connector_;
   MockCryptohomeLibrary* cryptohome_;
   Profile* prepared_profile_;
 
  private:
   ScopedTempDir scoped_temp_dir_;
@@ skipping 130 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(
     LoginUtilsBlockingLoginTestInstance,
     LoginUtilsBlockingLoginTest,
     testing::Values(0, 1, 2, 3, 4, 5));
 
 }  // namespace
 
 }