Use a TestBrowserThreadBundle in the DeviceSettingsTestBase.

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos_unittest.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/policy/device_cloud_policy_manager_chromeos.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 51 matching lines @@
                     EnterpriseInstallAttributes::LockResult result) {
   *out = result;
   loop->Quit();
 }
 
 class DeviceCloudPolicyManagerChromeOSTest
     : public chromeos::DeviceSettingsTestBase {
  protected:
   DeviceCloudPolicyManagerChromeOSTest()
       : state_keys_broker_(&fake_session_manager_client_,
-                           loop_.message_loop_proxy()),
+                           base::MessageLoopProxy::current()),
         store_(NULL) {
     EXPECT_CALL(mock_statistics_provider_,
                 GetMachineStatistic(_, _))
         .WillRepeatedly(Return(false));
     EXPECT_CALL(mock_statistics_provider_,
                 GetMachineStatistic("serial_number", _))
         .WillRepeatedly(DoAll(SetArgumentPointee<1>(std::string("test_sn")),
                               Return(true)));
     chromeos::system::StatisticsProvider::SetTestProvider(
         &mock_statistics_provider_);
     std::vector<std::string> state_keys;
     state_keys.push_back("1");
     state_keys.push_back("2");
     state_keys.push_back("3");
     fake_session_manager_client_.set_server_backed_state_keys(state_keys);
   }
 
   virtual ~DeviceCloudPolicyManagerChromeOSTest() {
     chromeos::system::StatisticsProvider::SetTestProvider(NULL);
   }
 
   virtual void SetUp() OVERRIDE {
     DeviceSettingsTestBase::SetUp();
 
     // DBusThreadManager is set up in DeviceSettingsTestBase::SetUp().
     install_attributes_.reset(new EnterpriseInstallAttributes(
         chromeos::DBusThreadManager::Get()->GetCryptohomeClient()));
-    store_ = new DeviceCloudPolicyStoreChromeOS(&device_settings_service_,
-                                                install_attributes_.get(),
-                                                loop_.message_loop_proxy());
+    store_ =
+        new DeviceCloudPolicyStoreChromeOS(&device_settings_service_,
+                                           install_attributes_.get(),
+                                           base::MessageLoopProxy::current());
     manager_.reset(new DeviceCloudPolicyManagerChromeOS(
         make_scoped_ptr(store_),
-        loop_.message_loop_proxy(),
-        loop_.message_loop_proxy(),
+        base::MessageLoopProxy::current(),
+        base::MessageLoopProxy::current(),
         install_attributes_.get(),
         &state_keys_broker_));
 
     chrome::RegisterLocalState(local_state_.registry());
     manager_->Init(&schema_registry_);
 
     // DeviceOAuth2TokenService uses the system request context to fetch
     // OAuth tokens, then writes the token to local state, encrypting it
     // first with methods in CryptohomeTokenEncryptor.
     request_context_getter_ = new net::TestURLRequestContextGetter(
-        loop_.message_loop_proxy());
+        base::MessageLoopProxy::current());
     TestingBrowserProcess::GetGlobal()->SetSystemRequestContext(
         request_context_getter_.get());
     TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
     // SystemSaltGetter is used in DeviceOAuth2TokenService.
     chromeos::SystemSaltGetter::Initialize();
     chromeos::DeviceOAuth2TokenServiceFactory::Initialize();
     url_fetcher_response_code_ = 200;
     url_fetcher_response_string_ = "{\"access_token\":\"accessToken4Test\","
                                    "\"expires_in\":1234,"
                                    "\"refresh_token\":\"refreshToken4Test\"}";
@@ skipping 461 matching lines @@
 
 TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest,
        RobotRefreshSaveFailed) {
   // Without the system salt, the robot token can't be stored.
   RunTest();
   ExpectFailedEnrollment(EnrollmentStatus::STATUS_ROBOT_REFRESH_STORE_FAILED);
 }
 
 }  // namespace
 }  // namespace policy