chrome: Use base::MessageLoop. (Part 3)

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 362 matching lines @@
 };
 
 // Handles asynchronous fetching of memory details.
 // Will run the provided task after finished.
 class MetricsMemoryDetails : public MemoryDetails {
  public:
   explicit MetricsMemoryDetails(const base::Closure& callback)
       : callback_(callback) {}
 
   virtual void OnDetailsAvailable() OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE, callback_);
+    base::MessageLoop::current()->PostTask(FROM_HERE, callback_);
   }
 
  private:
   virtual ~MetricsMemoryDetails() {}
 
   base::Closure callback_;
   DISALLOW_COPY_AND_ASSIGN(MetricsMemoryDetails);
 };
 
 // static
@@ skipping 559 matching lines @@
     const std::vector<webkit::WebPluginInfo>& plugins) {
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
   plugins_ = plugins;
 
   // Schedules a task on a blocking pool thread to gather Google Update
   // statistics (requires Registry reads).
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&MetricsService::InitTaskGetGoogleUpdateData,
                  self_ptr_factory_.GetWeakPtr(),
-                 MessageLoop::current()->message_loop_proxy()));
+                 base::MessageLoop::current()->message_loop_proxy()));
 }
 
 // static
 void MetricsService::InitTaskGetGoogleUpdateData(
     base::WeakPtr<MetricsService> self,
     base::MessageLoopProxy* target_loop) {
   GoogleUpdateMetrics google_update_metrics;
 
 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
   const bool system_install = GoogleUpdateSettings::IsSystemInstall();
@@ skipping 90 matching lines @@
 std::string MetricsService::GenerateClientID() {
   return base::GenerateGUID();
 }
 
 //------------------------------------------------------------------------------
 // State save methods
 
 void MetricsService::ScheduleNextStateSave() {
   state_saver_factory_.InvalidateWeakPtrs();
 
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&MetricsService::SaveLocalState,
                  state_saver_factory_.GetWeakPtr()),
       base::TimeDelta::FromMinutes(kSaveStateIntervalMinutes));
 }
 
 void MetricsService::SaveLocalState() {
   PrefService* pref = g_browser_process->local_state();
   if (!pref) {
     NOTREACHED();
     return;
@@ skipping 20 matching lines @@
 
     // Schedules a task on the file thread for execution of slower
     // initialization steps (such as plugin list generation) necessary
     // for sending the initial log.  This avoids blocking the main UI
     // thread.
     BrowserThread::PostDelayedTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&MetricsService::InitTaskGetHardwareClass,
             self_ptr_factory_.GetWeakPtr(),
-            MessageLoop::current()->message_loop_proxy()),
+            base::MessageLoop::current()->message_loop_proxy()),
         base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
   }
 }
 
 void MetricsService::CloseCurrentLog() {
   if (!log_manager_.current_log())
     return;
 
   // TODO(jar): Integrate bounds on log recording more consistently, so that we
   // can stop recording logs that are too big much sooner.
@@ skipping 130 matching lines @@
 
   // Create a callback_task for OnHistogramSynchronizationDone.
   base::Closure callback = base::Bind(
       &MetricsService::OnHistogramSynchronizationDone,
       self_ptr_factory_.GetWeakPtr());
 
   // Set up the callback to task to call after we receive histograms from all
   // child processes. Wait time specifies how long to wait before absolutely
   // calling us back on the task.
   content::FetchHistogramsAsynchronously(
-      MessageLoop::current(), callback,
+      base::MessageLoop::current(), callback,
       base::TimeDelta::FromMilliseconds(kMaxHistogramGatheringWaitDuration));
 }
 
 void MetricsService::OnHistogramSynchronizationDone() {
   DCHECK(IsSingleThreaded());
   // This function should only be called as the callback from an ansynchronous
   // step.
   DCHECK(waiting_for_asynchronous_reporting_step_);
 
   waiting_for_asynchronous_reporting_step_ = false;
@@ skipping 534 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }