content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/browser/browser_main_loop.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/browser/browser_main_loop.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/memory_pressure_monitor.h"
-#include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/pending_task.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "base/process/process_metrics.h"
 #include "base/profiler/scoped_profile.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer/hi_res_timer_manager.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/device_sensors/device_inertial_sensor_service.h"
@@ skipping 592 matching lines @@
   }
 
   base::trace_event::MemoryDumpManager::GetInstance()->Initialize();
 
   // Enable the dump providers.
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       HostSharedBitmapManager::current());
 
 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED)
   trace_memory_controller_.reset(new base::trace_event::TraceMemoryController(
-      base::MessageLoop::current()->message_loop_proxy(),
+      base::MessageLoop::current()->task_runner(),
       ::HeapProfilerWithPseudoStackStart, ::HeapProfilerStop,
       ::GetHeapProfile));
 #endif
 }
 
 int BrowserMainLoop::PreCreateThreads() {
   if (parts_) {
     TRACE_EVENT0("startup",
         "BrowserMainLoop::CreateThreads:PreCreateThreads");
     TRACK_SCOPED_REGION("Startup", "BrowserMainLoop::PreCreateThreads");
@@ skipping 64 matching lines @@
   return result_code_;
 }
 
 void BrowserMainLoop::CreateStartupTasks() {
   TRACE_EVENT0("startup", "BrowserMainLoop::CreateStartupTasks");
   TRACK_SCOPED_REGION("Startup", "BrowserMainLoop::CreateStartupTasks");
 
   // First time through, we really want to create all the tasks
   if (!startup_task_runner_.get()) {
 #if defined(OS_ANDROID)
-    startup_task_runner_ = make_scoped_ptr(new StartupTaskRunner(
-        base::Bind(&BrowserStartupComplete),
-        base::MessageLoop::current()->message_loop_proxy()));
+    startup_task_runner_ = make_scoped_ptr(
+        new StartupTaskRunner(base::Bind(&BrowserStartupComplete),
+                              base::ThreadTaskRunnerHandle::Get()));
 #else
-    startup_task_runner_ = make_scoped_ptr(new StartupTaskRunner(
-        base::Callback<void(int)>(),
-        base::MessageLoop::current()->message_loop_proxy()));
+    startup_task_runner_ = make_scoped_ptr(
+        new StartupTaskRunner(base::Callback<void(int)>(),
+                              base::ThreadTaskRunnerHandle::Get()));
 #endif
     StartupTask pre_create_threads =
         base::Bind(&BrowserMainLoop::PreCreateThreads, base::Unretained(this));
     startup_task_runner_->AddTask(pre_create_threads);
 
     StartupTask create_threads =
         base::Bind(&BrowserMainLoop::CreateThreads, base::Unretained(this));
     startup_task_runner_->AddTask(create_threads);
 
     StartupTask browser_thread_started = base::Bind(
@@ skipping 466 matching lines @@
       "BrowserMainLoop::BrowserThreadsStarted:InitSpeechRecognition");
     speech_recognition_manager_.reset(new SpeechRecognitionManagerImpl(
         audio_manager_.get(), media_stream_manager_.get()));
   }
 
   {
     TRACE_EVENT0(
         "startup",
         "BrowserMainLoop::BrowserThreadsStarted::InitUserInputMonitor");
     user_input_monitor_ = media::UserInputMonitor::Create(
-        io_thread_->message_loop_proxy(), main_thread_->message_loop_proxy());
+        io_thread_->task_runner(), main_thread_->task_runner());
   }
 
   {
     TRACE_EVENT0("startup",
                  "BrowserMainLoop::BrowserThreadsStarted::TimeZoneMonitor");
     time_zone_monitor_ = TimeZoneMonitor::Create();
   }
 
   // Alert the clipboard class to which threads are allowed to access the
   // clipboard:
@@ skipping 83 matching lines @@
   return true;
 }
 
 void BrowserMainLoop::MainMessageLoopRun() {
 #if defined(OS_ANDROID)
   // Android's main message loop is the Java message loop.
   NOTREACHED();
 #else
   DCHECK(base::MessageLoopForUI::IsCurrent());
   if (parameters_.ui_task) {
-    base::MessageLoopForUI::current()->PostTask(FROM_HERE,
-                                                *parameters_.ui_task);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  *parameters_.ui_task);
   }
 
   base::RunLoop run_loop;
   run_loop.Run();
 #endif
 }
 
 base::FilePath BrowserMainLoop::GetStartupTraceFileName(
     const base::CommandLine& command_line) const {
   base::FilePath trace_file = command_line.GetSwitchValuePath(
@@ skipping 41 matching lines @@
   DCHECK(is_tracing_startup_);
 
   is_tracing_startup_ = false;
   TracingController::GetInstance()->DisableRecording(
       TracingController::CreateFileSink(
           startup_trace_file_,
           base::Bind(OnStoppedStartupTracing, startup_trace_file_)));
 }
 
 }  // namespace content