content/child: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/child/child_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/child/child_thread_impl.h"
 
 #include <signal.h>
 
 #include <string>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/leak_annotations.h"
 #include "base/debug/profiler.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/metrics/field_trial.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/tracked_objects.h"
 #include "components/tracing/child_trace_message_filter.h"
 #include "content/child/bluetooth/bluetooth_message_filter.h"
 #include "content/child/child_discardable_shared_memory_manager.h"
 #include "content/child/child_gpu_memory_buffer_manager.h"
 #include "content/child/child_histogram_message_filter.h"
 #include "content/child/child_process.h"
 #include "content/child/child_resource_message_filter.h"
@@ skipping 226 matching lines @@
 ChildThreadImpl::ChildThreadImpl(const Options& options)
     : router_(this),
       browser_process_io_runner_(options.browser_process_io_runner),
       channel_connected_factory_(this) {
   Init(options);
 }
 
 scoped_refptr<base::SequencedTaskRunner> ChildThreadImpl::GetIOTaskRunner() {
   if (IsInBrowserProcess())
     return browser_process_io_runner_;
-  return ChildProcess::current()->io_message_loop_proxy();
+  return ChildProcess::current()->io_task_runner();
 }
 
 void ChildThreadImpl::ConnectChannel(bool use_mojo_channel) {
   bool create_pipe_now = true;
   if (use_mojo_channel) {
     VLOG(1) << "Mojo is enabled on child";
     scoped_refptr<base::SequencedTaskRunner> io_task_runner = GetIOTaskRunner();
     DCHECK(io_task_runner);
     channel_->Init(IPC::ChannelMojo::CreateClientFactory(
                        nullptr, io_task_runner, channel_name_),
@@ skipping 10 matching lines @@
 
   g_lazy_tls.Pointer()->Set(this);
   on_channel_error_called_ = false;
   message_loop_ = base::MessageLoop::current();
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // We must make sure to instantiate the IPC Logger *before* we create the
   // channel, otherwise we can get a callback on the IO thread which creates
   // the logger, and the logger does not like being created on the IO thread.
   IPC::Logging::GetInstance();
 #endif
-  channel_ = IPC::SyncChannel::Create(
-      this, ChildProcess::current()->io_message_loop_proxy(),
-      ChildProcess::current()->GetShutDownEvent());
+  channel_ =
+      IPC::SyncChannel::Create(this, ChildProcess::current()->io_task_runner(),
+                               ChildProcess::current()->GetShutDownEvent());
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (!IsInBrowserProcess())
     IPC::Logging::GetInstance()->SetIPCSender(this);
 #endif
 
   mojo_application_.reset(new MojoApplication(GetIOTaskRunner()));
 
   sync_message_filter_ =
       new IPC::SyncMessageFilter(ChildProcess::current()->GetShutDownEvent());
   thread_safe_sender_ = new ThreadSafeSender(
-      base::MessageLoopProxy::current().get(), sync_message_filter_.get());
+      base::ThreadTaskRunnerHandle::Get().get(), sync_message_filter_.get());

[no sievers, 2015/05/20 23:02:38]

You can actually use message_loop_.task_runner() which was assigned above.

[Sami, 2015/05/21 11:39:48]

Thanks for the tip, done.

 
   resource_dispatcher_.reset(new ResourceDispatcher(
       this, message_loop()->task_runner()));
   websocket_dispatcher_.reset(new WebSocketDispatcher);
   file_system_dispatcher_.reset(new FileSystemDispatcher());
 
   histogram_message_filter_ = new ChildHistogramMessageFilter();
   resource_message_filter_ =
       new ChildResourceMessageFilter(resource_dispatcher());
 
@@ skipping 22 matching lines @@
   channel_->AddFilter(push_dispatcher_->GetFilter());
   channel_->AddFilter(service_worker_message_filter_->GetFilter());
   channel_->AddFilter(geofencing_message_filter_->GetFilter());
   channel_->AddFilter(bluetooth_message_filter_->GetFilter());
   channel_->AddFilter(navigator_connect_dispatcher_->GetFilter());
 
   if (!IsInBrowserProcess()) {
     // In single process mode, browser-side tracing will cover the whole
     // process including renderers.
     channel_->AddFilter(new tracing::ChildTraceMessageFilter(
-        ChildProcess::current()->io_message_loop_proxy()));
+        ChildProcess::current()->io_task_runner()));
   }
 
   // In single process mode we may already have a power monitor
   if (!base::PowerMonitor::Get()) {
     scoped_ptr<PowerMonitorBroadcastSource> power_monitor_source(
       new PowerMonitorBroadcastSource());
     channel_->AddFilter(power_monitor_source->GetMessageFilter());
 
     power_monitor_.reset(new base::PowerMonitor(
         power_monitor_source.Pass()));
@@ skipping 16 matching lines @@
   int connection_timeout = kConnectionTimeoutS;
   std::string connection_override =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kIPCConnectionTimeout);
   if (!connection_override.empty()) {
     int temp;
     if (base::StringToInt(connection_override, &temp))
       connection_timeout = temp;
   }
 
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&ChildThreadImpl::EnsureConnected,
-                 channel_connected_factory_.GetWeakPtr()),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(

[no sievers, 2015/05/20 23:02:38]

nit: Maybe just do message_loop_->task_runner() here also like below?

[Sami, 2015/05/21 11:39:48]

Done.

+      FROM_HERE, base::Bind(&ChildThreadImpl::EnsureConnected,
+                            channel_connected_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(connection_timeout));
 
 #if defined(OS_ANDROID)
   {
     base::AutoLock lock(g_lazy_child_thread_lock.Get());
     g_child_thread = this;
     g_child_thread_initialized = true;
   }
   // Signalling without locking is fine here because only
   // one thread can wait on the condition variable.
   g_lazy_child_thread_cv.Get().Signal();
 #endif
 
 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED)
   trace_memory_controller_.reset(new base::trace_event::TraceMemoryController(
-      message_loop_->message_loop_proxy(), ::HeapProfilerWithPseudoStackStart,
+      message_loop_->task_runner(), ::HeapProfilerWithPseudoStackStart,
       ::HeapProfilerStop, ::GetHeapProfile));
 #endif
 
   base::trace_event::MemoryDumpManager::GetInstance()->Initialize();
 
   shared_bitmap_manager_.reset(
       new ChildSharedBitmapManager(thread_safe_sender()));
 
   gpu_memory_buffer_manager_.reset(
       new ChildGpuMemoryBufferManager(thread_safe_sender()));
@@ skipping 251 matching lines @@
 
 void ChildThreadImpl::OnProcessBackgrounded(bool background) {
   // Set timer slack to maximum on main thread when in background.
   base::TimerSlack timer_slack = base::TIMER_SLACK_NONE;
   if (background)
     timer_slack = base::TIMER_SLACK_MAXIMUM;
   base::MessageLoop::current()->SetTimerSlack(timer_slack);
 }
 
 }  // namespace content