content: Use base::MessageLoop.

content/test/net/url_request_slow_download_job.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/test/net/url_request_slow_download_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 19 matching lines @@
   "http://url.handled.by.slow.download/download-error";
 
 const int URLRequestSlowDownloadJob::kFirstDownloadSize = 1024 * 35;
 const int URLRequestSlowDownloadJob::kSecondDownloadSize = 1024 * 10;
 
 // static
 base::LazyInstance<URLRequestSlowDownloadJob::SlowJobsSet>::Leaky
     URLRequestSlowDownloadJob::pending_requests_ = LAZY_INSTANCE_INITIALIZER;
 
 void URLRequestSlowDownloadJob::Start() {
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestSlowDownloadJob::StartAsync,
                  weak_factory_.GetWeakPtr()));
 }
 
 // static
 void URLRequestSlowDownloadJob::AddUrlHandler() {
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
   filter->AddUrlHandler(GURL(kUnknownSizeUrl),
                         &URLRequestSlowDownloadJob::Factory);
@@ skipping 128 matching lines @@
   VLOG(10) << __FUNCTION__ << " called at position "
            << bytes_already_sent_ << " in the stream.";
   ReadStatus status = FillBufferHelper(buf, buf_size, bytes_read);
   switch (status) {
     case BUFFER_FILLED:
       return true;
     case REQUEST_BLOCKED:
       buffer_ = buf;
       buffer_size_ = buf_size;
       SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
-      MessageLoop::current()->PostDelayedTask(
+      base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus,
                      weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(100));
       return false;
     case REQUEST_COMPLETE:
       *bytes_read = 0;
       return true;
   }
   NOTREACHED();
   return true;
 }
 
 void URLRequestSlowDownloadJob::CheckDoneStatus() {
   if (should_finish_download_) {
     VLOG(10) << __FUNCTION__ << " called w/ should_finish_download_ set.";
     DCHECK(NULL != buffer_);
     int bytes_written = 0;
     ReadStatus status = FillBufferHelper(buffer_, buffer_size_, &bytes_written);
     DCHECK_EQ(BUFFER_FILLED, status);
     buffer_ = NULL;                     // Release the reference.
     SetStatus(net::URLRequestStatus());
     NotifyReadComplete(bytes_written);
   } else if (should_error_download_) {
     VLOG(10) << __FUNCTION__ << " called w/ should_finish_ownload_ set.";
     NotifyDone(net::URLRequestStatus(
         net::URLRequestStatus::FAILED, net::ERR_CONNECTION_RESET));
   } else {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(100));
   }
 }
 
 // Public virtual version.
 void URLRequestSlowDownloadJob::GetResponseInfo(net::HttpResponseInfo* info) {
   // Forward to private const version.
@@ skipping 35 matching lines @@
   info->headers = new net::HttpResponseHeaders(raw_headers);
 }
 
 bool URLRequestSlowDownloadJob::GetMimeType(std::string* mime_type) const {
   net::HttpResponseInfo info;
   GetResponseInfoConst(&info);
   return info.headers && info.headers->GetMimeType(mime_type);
 }
 
 }  // namespace content