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

chrome/browser/common/cancelable_request.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/common/cancelable_request.h"
 
 CancelableRequestProvider::CancelableRequestProvider()
     : next_handle_(1) {
 }
 
@@ skipping 75 matching lines @@
 template class CancelableRequestConsumerTSimple<int>;
 
 // And the most common subclass of it.
 template class CancelableRequestConsumerT<int, 0>;
 #endif
 
 CancelableRequestBase::CancelableRequestBase()
     : provider_(NULL),
       consumer_(NULL),
       handle_(0) {
-  callback_thread_ = MessageLoop::current();
+  callback_thread_ = base::MessageLoop::current();
 }
 
 CancelableRequestBase::~CancelableRequestBase() {
 }
 
 void CancelableRequestBase::Init(CancelableRequestProvider* provider,
                                  CancelableRequestProvider::Handle handle,
                                  CancelableRequestConsumerBase* consumer) {
   DCHECK(handle_ == 0 && provider_ == NULL && consumer_ == NULL);
   provider_ = provider;
   consumer_ = consumer;
   handle_ = handle;
 }
 
 void CancelableRequestBase::DoForward(const base::Closure& forwarded_call,
                                       bool force_async) {
-  if (force_async || callback_thread_ != MessageLoop::current()) {
+  if (force_async || callback_thread_ != base::MessageLoop::current()) {
     callback_thread_->PostTask(
         FROM_HERE,
-        base::Bind(&CancelableRequestBase::ExecuteCallback, this,
-                   forwarded_call));
+        base::Bind(
+            &CancelableRequestBase::ExecuteCallback, this, forwarded_call));

[brettw, 2013/04/28 04:26:27]

Old wrapping was fine

   } else {
     // We can do synchronous callbacks when we're on the same thread.
     ExecuteCallback(forwarded_call);
   }
 }
 
 void CancelableRequestBase::ExecuteCallback(
     const base::Closure& forwarded_call) {
-  DCHECK_EQ(callback_thread_, MessageLoop::current());
+  DCHECK_EQ(callback_thread_, base::MessageLoop::current());
 
   if (!canceled_.IsSet()) {
     WillExecute();
 
     // Execute the callback.
     forwarded_call.Run();
   }
 
   // Notify the provider that the request is complete. The provider will
   // notify the consumer for us. Note that it is possible for the callback to
   // cancel this request; we must check canceled again.
   if (!canceled_.IsSet())
     NotifyCompleted();
 }