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

chrome/browser/nacl_host/nacl_browser.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/nacl_host/nacl_browser.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 333 matching lines @@
 }
 
 void NaClBrowser::CheckWaiting() {
   if (!IsOk() || IsReady()) {
     // Queue the waiting tasks into the message loop.  This helps avoid
     // re-entrancy problems that could occur if the closure was invoked
     // directly.  For example, this could result in use-after-free of the
     // process host.
     for (std::vector<base::Closure>::iterator iter = waiting_.begin();
          iter != waiting_.end(); ++iter) {
-      MessageLoop::current()->PostTask(FROM_HERE, *iter);
+      base::MessageLoop::current()->PostTask(FROM_HERE, *iter);
     }
     waiting_.clear();
   }
 }
 
 void NaClBrowser::MarkAsFailed() {
   ok_ = false;
   CheckWaiting();
 }
 
@@ skipping 70 matching lines @@
   if (validation_cache_state_ != NaClResourceReady) {
     validation_cache_state_ = NaClResourceReady;
     CheckWaiting();
   }
 }
 
 void NaClBrowser::MarkValidationCacheAsModified() {
   if (!validation_cache_is_modified_) {
     // Wait before persisting to disk.  This can coalesce multiple cache
     // modifications info a single disk write.
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
          FROM_HERE,
          base::Bind(&NaClBrowser::PersistValidationCache,
                     weak_factory_.GetWeakPtr()),
          base::TimeDelta::FromMilliseconds(kValidationCacheCoalescingTimeMS));
     validation_cache_is_modified_ = true;
   }
 }
 
 void NaClBrowser::PersistValidationCache() {
   // validation_cache_is_modified_ may be false if the cache was cleared while
   // this delayed task was pending.
   // validation_cache_file_path_ may be empty if something went wrong during
   // initialization.
   if (validation_cache_is_modified_ && !validation_cache_file_path_.empty()) {
     Pickle* pickle = new Pickle();
     validation_cache_.Serialize(pickle);
 
     // Pass the serialized data to another thread to write to disk.  File IO is
     // not allowed on the IO thread (which is the thread this method runs on)
     // because it can degrade the responsiveness of the browser.
     // The task is sequenced so that multiple writes happen in order.
     content::BrowserThread::PostBlockingPoolSequencedTask(
         kValidationCacheSequenceName,
         FROM_HERE,
         base::Bind(WriteCache, validation_cache_file_path_,
                    base::Owned(pickle)));
   }
   validation_cache_is_modified_ = false;
 }