content: Use base::MessageLoop.

content/renderer/renderer_main.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 "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
 #include "base/debug/trace_event.h"
 #include "base/hi_res_timer_manager.h"
@@ skipping 46 matching lines @@
     ChildProcess::WaitForDebugger("Renderer");
 
   // This parameter causes an assertion.
   if (command_line.HasSwitch(switches::kRendererAssertTest)) {
     DCHECK(false);
   }
 }
 
 // This is a simplified version of the browser Jankometer, which measures
 // the processing time of tasks on the render thread.
-class RendererMessageLoopObserver : public MessageLoop::TaskObserver {
+class RendererMessageLoopObserver : public base::MessageLoop::TaskObserver {
  public:
   RendererMessageLoopObserver()
       : process_times_(base::Histogram::FactoryGet(
             "Chrome.ProcMsgL RenderThread",
             1, 3600000, 50, base::Histogram::kUmaTargetedHistogramFlag)) {}
   virtual ~RendererMessageLoopObserver() {}
 
   virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
     begin_process_message_ = base::TimeTicks::Now();
   }
 
   virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
     if (!begin_process_message_.is_null())
       process_times_->AddTime(base::TimeTicks::Now() - begin_process_message_);
   }
 
  private:
   base::TimeTicks begin_process_message_;
   base::HistogramBase* const process_times_;
   DISALLOW_COPY_AND_ASSIGN(RendererMessageLoopObserver);
 };
 
 // For measuring memory usage after each task. Behind a command line flag.
-class MemoryObserver : public MessageLoop::TaskObserver {
+class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   virtual ~MemoryObserver() {}
 
   virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
   }
 
   virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
     HISTOGRAM_MEMORY_KB("Memory.RendererUsed", webkit_glue::MemoryUsageKB());
   }
@@ skipping 36 matching lines @@
   GetContentClient()->renderer()->RegisterPPAPIInterfaceFactories(
       factory_manager);
 
   base::StatsCounterTimer stats_counter_timer("Content.RendererInit");
   base::StatsScope<base::StatsCounterTimer> startup_timer(stats_counter_timer);
 
   RendererMessageLoopObserver task_observer;
 #if defined(OS_MACOSX)
   // As long as we use Cocoa in the renderer (for the forseeable future as of
   // now; see http://crbug.com/13890 for info) we need to have a UI loop.
-  MessageLoop main_message_loop(MessageLoop::TYPE_UI);
+  base::MessageLoop main_message_loop(base::MessageLoop::TYPE_UI);
 #else
   // The main message loop of the renderer services doesn't have IO or UI tasks,
   // unless in-process-plugins is used.
-  MessageLoop main_message_loop(RenderProcessImpl::InProcessPlugins() ?
-              MessageLoop::TYPE_UI : MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop main_message_loop(RenderProcessImpl::InProcessPlugins()
+                                          ? base::MessageLoop::TYPE_UI
+                                          : base::MessageLoop::TYPE_DEFAULT);
 #endif
   main_message_loop.AddTaskObserver(&task_observer);
 
   scoped_ptr<MemoryObserver> memory_observer;
   if (parsed_command_line.HasSwitch(switches::kMemoryMetrics)) {
     memory_observer.reset(new MemoryObserver());
     main_message_loop.AddTaskObserver(memory_observer.get());
   }
 
   base::PlatformThread::SetName("CrRendererMain");
@@ skipping 60 matching lines @@
     platform.RunSandboxTests(no_sandbox);
 
     startup_timer.Stop();  // End of Startup Time Measurement.
 
     if (run_loop) {
 #if defined(OS_MACOSX)
       if (pool)
         pool->Recycle();
 #endif
       TRACE_EVENT_BEGIN_ETW("RendererMain.START_MSG_LOOP", 0, 0);
-      MessageLoop::current()->Run();
+      base::MessageLoop::current()->Run();
       TRACE_EVENT_END_ETW("RendererMain.START_MSG_LOOP", 0, 0);
     }
   }
   platform.PlatformUninitialize();
   TRACE_EVENT_END_ETW("RendererMain", 0, "");
   return 0;
 }
 
 }  // namespace content