content: Use base::MessageLoop.

content/browser/histogram_synchronizer.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 "content/browser/histogram_synchronizer.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 183 matching lines @@
   HistogramSynchronizer* current_synchronizer =
       HistogramSynchronizer::GetInstance();
   if (current_synchronizer == NULL)
     return;
 
   current_synchronizer->RegisterAndNotifyAllProcesses(
       HistogramSynchronizer::UNKNOWN,
       base::TimeDelta::FromMinutes(1));
 }
 
-void FetchHistogramsAsynchronously(MessageLoop* callback_thread,
+void FetchHistogramsAsynchronously(base::MessageLoop* callback_thread,
                                    const base::Closure& callback,
                                    base::TimeDelta wait_time) {
   HistogramSynchronizer::FetchHistogramsAsynchronously(
       callback_thread, callback, wait_time);
 }
 
 // static
 void HistogramSynchronizer::FetchHistogramsAsynchronously(
-    MessageLoop* callback_thread,
+    base::MessageLoop* callback_thread,
     const base::Closure& callback,
     base::TimeDelta wait_time) {
   DCHECK(callback_thread != NULL);
   DCHECK(!callback.is_null());
 
   HistogramSynchronizer* current_synchronizer =
       HistogramSynchronizer::GetInstance();
   current_synchronizer->SetCallbackTaskAndThread(
       callback_thread, callback);
 
@@ skipping 56 matching lines @@
 
   if (!request)
     return;
 
   // Delete request if we have heard back from all child processes.
   request->DecrementProcessesPending();
   request->DeleteIfAllDone();
 }
 
 void HistogramSynchronizer::SetCallbackTaskAndThread(
-    MessageLoop* callback_thread,
+    base::MessageLoop* callback_thread,
     const base::Closure& callback) {
   base::Closure old_callback;
-  MessageLoop* old_thread = NULL;
+  base::MessageLoop* old_thread = NULL;
   {
     base::AutoLock auto_lock(lock_);
     old_callback = callback_;
     callback_ = callback;
     old_thread = callback_thread_;
     callback_thread_ = callback_thread;
     // Prevent premature calling of our new callbacks.
     async_sequence_number_ = kNeverUsableSequenceNumber;
   }
   // Just in case there was a task pending....
   InternalPostTask(old_thread, old_callback);
 }
 
 void HistogramSynchronizer::ForceHistogramSynchronizationDoneCallback(
     int sequence_number) {
   base::Closure callback;
-  MessageLoop* thread = NULL;
+  base::MessageLoop* thread = NULL;
   {
     base::AutoLock lock(lock_);
     if (sequence_number != async_sequence_number_)
       return;
     callback = callback_;
     thread = callback_thread_;
     callback_.Reset();
     callback_thread_ = NULL;
   }
   InternalPostTask(thread, callback);
 }
 
-void HistogramSynchronizer::InternalPostTask(MessageLoop* thread,
+void HistogramSynchronizer::InternalPostTask(base::MessageLoop* thread,
                                              const base::Closure& callback) {
   if (callback.is_null() || !thread)
     return;
   thread->PostTask(FROM_HERE, callback);
 }
 
 int HistogramSynchronizer::GetNextAvailableSequenceNumber(
     ProcessHistogramRequester requester) {
   base::AutoLock auto_lock(lock_);
   ++last_used_sequence_number_;
   // Watch out for wrapping to a negative number.
   if (last_used_sequence_number_ < 0) {
     // Bypass the reserved number, which is used when a renderer spontaneously
     // decides to send some histogram data.
     last_used_sequence_number_ =
         kHistogramSynchronizerReservedSequenceNumber + 1;
   }
   DCHECK_NE(last_used_sequence_number_,
             kHistogramSynchronizerReservedSequenceNumber);
   if (requester == ASYNC_HISTOGRAMS)
     async_sequence_number_ = last_used_sequence_number_;
   return last_used_sequence_number_;
 }
 
 }  // namespace content