content: Use base::MessageLoop.

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 711 matching lines @@
   WebKit::initialize(webkit_platform_support_.get());
   WebKit::setSharedWorkerRepository(
       webkit_platform_support_.get()->sharedWorkerRepository());
   WebKit::setIDBFactory(
       webkit_platform_support_.get()->idbFactory());
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   bool enable = command_line.HasSwitch(switches::kEnableThreadedCompositing);
   if (enable) {
-    MessageLoop* override_loop =
+    base::MessageLoop* override_loop =
         GetContentClient()->renderer()->OverrideCompositorMessageLoop();
     if (override_loop) {
       compositor_message_loop_proxy_ = override_loop->message_loop_proxy();
     } else {
       compositor_thread_.reset(new base::Thread("Compositor"));
       compositor_thread_->Start();
       compositor_message_loop_proxy_ =
           compositor_thread_->message_loop_proxy();
     }
 
@@ skipping 104 matching lines @@
     RenderThreadImpl::HostAllocateSharedMemoryBuffer(size_t size) {
   if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
     return scoped_ptr<base::SharedMemory>();
 
   base::SharedMemoryHandle handle;
   bool success;
   IPC::Message* message =
       new ChildProcessHostMsg_SyncAllocateSharedMemory(size, &handle);
 
   // Allow calling this from the compositor thread.
-  if (MessageLoop::current() == message_loop())
+  if (base::MessageLoop::current() == message_loop())
     success = ChildThread::Send(message);
   else
     success = sync_message_filter()->Send(message);
 
   if (!success)
     return scoped_ptr<base::SharedMemory>();
 
   if (!base::SharedMemory::IsHandleValid(handle))
     return scoped_ptr<base::SharedMemory>();
 
@@ skipping 222 matching lines @@
     return false;  // We must be shutting down.
 
   return true;
 }
 
 bool RenderThreadImpl::IsMainThread() {
   return !!current();
 }
 
 bool RenderThreadImpl::IsIOThread() {
-  return MessageLoop::current() == ChildProcess::current()->io_message_loop();
+  return base::MessageLoop::current() ==
+         ChildProcess::current()->io_message_loop();
 }
 
 MessageLoop* RenderThreadImpl::GetMainLoop() {
   return message_loop();
 }
 
 scoped_refptr<base::MessageLoopProxy> RenderThreadImpl::GetIOLoopProxy() {
   return ChildProcess::current()->io_message_loop_proxy();
 }
 
@@ skipping 14 matching lines @@
                "surface_id",
                surface_id);
 
   int32 route_id = MSG_ROUTING_NONE;
   IPC::Message* message = new GpuHostMsg_CreateViewCommandBuffer(
       surface_id,
       init_params,
       &route_id);
 
   // Allow calling this from the compositor thread.
-  if (MessageLoop::current() == message_loop())
+  if (base::MessageLoop::current() == message_loop())
     ChildThread::Send(message);
   else
     sync_message_filter()->Send(message);
 
   return route_id;
 }
 
 void RenderThreadImpl::CreateImage(
     gfx::PluginWindowHandle window,
     int32 image_id,
@@ skipping 177 matching lines @@
   GetContentClient()->SetActiveURL(data);
   CHECK(false);
 }
 
 void RenderThreadImpl::OnSetWebKitSharedTimersSuspended(bool suspend) {
   ToggleWebKitSharedTimer(suspend);
 }
 
 scoped_refptr<base::MessageLoopProxy>
 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
-  DCHECK(message_loop() == MessageLoop::current());
+  DCHECK(message_loop() == base::MessageLoop::current());
   if (!file_thread_) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }
 
 void RenderThreadImpl::SetFlingCurveParameters(
     const std::vector<float>& new_touchpad,
     const std::vector<float>& new_touchscreen) {
   webkit_platform_support_->SetFlingCurveParameters(new_touchpad,
                                                     new_touchscreen);
 
 }
 
 }  // namespace content