Reduce usage of MessageLoopProxy in base/

chrome/browser/profiles/profile_io_data.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/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 418 matching lines @@
   ChromeNetworkDelegate::InitializePrefsOnUIThread(
       &enable_referrers_,
       &enable_do_not_track_,
       &force_safesearch_,
       pref_service);
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
 #if defined(ENABLE_PRINTING)
   printing_enabled_.Init(prefs::kPrintingEnabled, pref_service);
-  printing_enabled_.MoveToThread(io_message_loop_proxy);
+  printing_enabled_.UseAlternateTaskRunner(io_message_loop_proxy);
 #endif
 
   chrome_http_user_agent_settings_.reset(
       new ChromeHttpUserAgentSettings(pref_service));
 
   // These members are used only for one click sign in, which is not enabled
   // in incognito mode.  So no need to initialize them.
   if (!IsOffTheRecord()) {
     signin_names_.reset(new SigninNamesOnIOThread());
 
     google_services_user_account_id_.Init(
         prefs::kGoogleServicesUserAccountId, pref_service);
-    google_services_user_account_id_.MoveToThread(io_message_loop_proxy);
+    google_services_user_account_id_.UseAlternateTaskRunner(
+        io_message_loop_proxy);
 
     google_services_username_.Init(
         prefs::kGoogleServicesUsername, pref_service);
-    google_services_username_.MoveToThread(io_message_loop_proxy);
+    google_services_username_.UseAlternateTaskRunner(io_message_loop_proxy);
 
     google_services_username_pattern_.Init(
         prefs::kGoogleServicesUsernamePattern, local_state_pref_service);
-    google_services_username_pattern_.MoveToThread(io_message_loop_proxy);
+    google_services_username_pattern_.UseAlternateTaskRunner(
+        io_message_loop_proxy);
 
     reverse_autologin_enabled_.Init(
         prefs::kReverseAutologinEnabled, pref_service);
-    reverse_autologin_enabled_.MoveToThread(io_message_loop_proxy);
+    reverse_autologin_enabled_.UseAlternateTaskRunner(io_message_loop_proxy);
 
     one_click_signin_rejected_email_list_.Init(
         prefs::kReverseAutologinRejectedEmailList, pref_service);
-    one_click_signin_rejected_email_list_.MoveToThread(io_message_loop_proxy);
+    one_click_signin_rejected_email_list_.UseAlternateTaskRunner(
+        io_message_loop_proxy);
 
     sync_disabled_.Init(sync_driver::prefs::kSyncManaged, pref_service);
-    sync_disabled_.MoveToThread(io_message_loop_proxy);
+    sync_disabled_.UseAlternateTaskRunner(io_message_loop_proxy);
 
     signin_allowed_.Init(prefs::kSigninAllowed, pref_service);
-    signin_allowed_.MoveToThread(io_message_loop_proxy);
+    signin_allowed_.UseAlternateTaskRunner(io_message_loop_proxy);
   }
 
   quick_check_enabled_.Init(prefs::kQuickCheckEnabled,
                             local_state_pref_service);
-  quick_check_enabled_.MoveToThread(io_message_loop_proxy);
+  quick_check_enabled_.UseAlternateTaskRunner(io_message_loop_proxy);
 
   media_device_id_salt_ = new MediaDeviceIDSalt(pref_service, IsOffTheRecord());
 
   network_prediction_options_.Init(prefs::kNetworkPredictionOptions,
                                    pref_service);
 
-  network_prediction_options_.MoveToThread(io_message_loop_proxy);
+  network_prediction_options_.UseAlternateTaskRunner(io_message_loop_proxy);
 
 #if defined(OS_CHROMEOS)
   scoped_ptr<policy::PolicyCertVerifier> verifier =
       policy::PolicyCertServiceFactory::CreateForProfile(profile);
   policy_cert_verifier_ = verifier.get();
   cert_verifier_ = verifier.Pass();
 #endif
   // The URLBlacklistManager has to be created on the UI thread to register
   // observers of |pref_service|, and it also has to clean up on
   // ShutdownOnUIThread to release these observers on the right thread.
@@ skipping 20 matching lines @@
         policy::PolicyHeaderServiceFactory::GetForBrowserContext(profile);
     if (policy_header_service) {
       policy_header_helper_ = policy_header_service->CreatePolicyHeaderIOHelper(
           io_message_loop_proxy);
     }
   }
 #endif
 
   incognito_availibility_pref_.Init(
       prefs::kIncognitoModeAvailability, pref_service);
-  incognito_availibility_pref_.MoveToThread(io_message_loop_proxy);
+  incognito_availibility_pref_.UseAlternateTaskRunner(io_message_loop_proxy);
 
   initialized_on_UI_thread_ = true;
 
   // We need to make sure that content initializes its own data structures that
   // are associated with each ResourceContext because we might post this
   // object to the IO thread after this function.
   BrowserContext::EnsureResourceContextInitialized(profile);
 }
 
 ProfileIOData::MediaRequestContext::MediaRequestContext() {
@@ skipping 297 matching lines @@
   // We will want to do something similar to the PrefMember method below in the
   // future to more accurately capture this state.
   chromeos::CrosSettings::Get()->GetBoolean(chromeos::kStatsReportingPref,
                                             &enable_metrics_);
 #elif defined(OS_ANDROID)
   // TODO(dwkang): rename or unify the pref for UMA once we have conclusion
   // in crbugs.com/246495.
   // Android has it's own preferences for metrics / crash uploading.
   enable_metrics_.Init(prefs::kCrashReportingEnabled,
                        g_browser_process->local_state());
-  enable_metrics_.MoveToThread(
+  enable_metrics_.UseAlternateTaskRunner(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 #else
   // Prep the PrefMember and send it to the IO thread, since this value will be
   // read from there.
   enable_metrics_.Init(prefs::kMetricsReportingEnabled,
                        g_browser_process->local_state());
-  enable_metrics_.MoveToThread(
+  enable_metrics_.UseAlternateTaskRunner(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 #endif  // defined(OS_CHROMEOS)
 }
 
 bool ProfileIOData::GetMetricsEnabledStateOnIOThread() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 #if defined(OS_CHROMEOS)
   return enable_metrics_;
 #else
   return enable_metrics_.GetValue();
@@ skipping 415 matching lines @@
 void ProfileIOData::SetCookieSettingsForTesting(
     CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }
 
 void ProfileIOData::set_signin_names_for_testing(
     SigninNamesOnIOThread* signin_names) {
   signin_names_.reset(signin_names);
 }