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

chrome/browser/common/cancelable_request.h

 // 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.
 
 // CancelableRequestProviders and Consumers work together to make requests that
 // execute on a background thread in the provider and return data to the
 // consumer. These classes collaborate to keep a list of open requests and to
 // make sure that requests do not outlive either of the objects involved in the
 // transaction.
 //
@@ skipping 569 matching lines @@
     consumer_->DidExecute(provider_, handle_);
   }
 
   // Cover method for CancelableRequestConsumerBase::WillExecute.
   void WillExecute() {
     consumer_->WillExecute(provider_, handle_);
   }
 
   // The message loop that this request was created on. The callback will
   // happen on the same thread.
-  MessageLoop* callback_thread_;
+  base::MessageLoop* callback_thread_;
 
   // The provider for this request. When we execute, we will notify this that
   // request is complete to it can remove us from the requests it tracks.
   CancelableRequestProvider* provider_;
 
   // Notified after we execute that the request is complete.  This should only
   // be accessed if !canceled_.IsSet(), otherwise the pointer is invalid.
   CancelableRequestConsumerBase* consumer_;
 
   // The handle to this request inside the provider. This will be initialized
@@ skipping 62 matching lines @@
   // calling this. It is optional in the cancelled case. In the non-cancelled
   // case, this MUST be called.
   //
   // If there are any pointers in the parameters, they must live at least as
   // long as the request so that it can be forwarded to the other thread.
   // For complex objects, this would typically be done by having a derived
   // request own the data itself.
   void ForwardResult(const TupleType& param) {
     DCHECK(callback_.get());
     if (!canceled()) {
-      if (callback_thread_ == MessageLoop::current()) {
+      if (callback_thread_ == base::MessageLoop::current()) {
         // We can do synchronous callbacks when we're on the same thread.
         ExecuteCallback(param);
       } else {
         callback_thread_->PostTask(
             FROM_HERE,
             base::Bind(&CancelableRequest<CB>::ExecuteCallback, this, param));
       }
     }
   }
 
@@ skipping 323 matching lines @@
   }
 
   // The value.
   Type value;
 
  protected:
   virtual ~CancelableRequest1() {}
 };
 
 #endif  // CHROME_BROWSER_COMMON_CANCELABLE_REQUEST_H_