content: Add an overridable task runner to ChildThreadImpl

content/child/child_thread_impl.h

 // 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.
 
 #ifndef CONTENT_CHILD_CHILD_THREAD_IMPL_H_
 #define CONTENT_CHILD_CHILD_THREAD_IMPL_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 62 matching lines @@
   // must be terminated before Shutdown returns. In particular, if a subsystem
   // has a thread that post tasks to ChildProcess::main_thread(), that thread
   // should be joined in Shutdown().
   ~ChildThreadImpl() override;
   virtual void Shutdown();
 
   // IPC::Sender implementation:
   bool Send(IPC::Message* msg) override;
 
   // ChildThread implementation:
+  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override;

[no sievers, 2015/03/04 19:15:02]

Is there a way (at least longer term) how we could make it more clear how to get
the right task runner for the different call sites? Esp. since
ChildThreadImpl::message_loop() is also public, and MessageLoop also has
GetTaskRunner().

Could you also explain in the cl description what exactly the impact/bug was of
using the wrong task runner and bypassing the scheduler?

[Sami, 2015/03/04 19:39:28]

I agree that it's a mess :( To add on top of the things you mentioned, there's
base::MessageLoop::current(), base::MessageLoopProxy::current() and
ThreadTaskRunnerHandle::Get().

I tried removing message_loop() here but couldn't because some callers want to
add task observers to it, which you can't do with a SingleThreadTaskRunner.
Maybe one way to clean this up would be to separate out task observing into a
new interface (or possibly into SingleThreadTaskRunner) so that fewer things
need to care about the concrete message loop.

Longer term I'd like to remove most if not all global ways to get to a task
runner and require everyone to plumb the task runners to where they are needed.
That's a little ways off though :)

I'll add some instructions here on how to use this.
Done.

 #if defined(OS_WIN)
   void PreCacheFont(const LOGFONT& log_font) override;
   void ReleaseCachedFonts() override;
 #endif
 
   IPC::SyncChannel* channel() { return channel_.get(); }
 
   MessageRouter* GetRouter();
 
   // Allocates a block of shared memory of the given size. Returns NULL on
@@ skipping 153 matching lines @@
   // Handles resource loads for this process.
   scoped_ptr<ResourceDispatcher> resource_dispatcher_;
 
   scoped_ptr<WebSocketDispatcher> websocket_dispatcher_;
 
   // The OnChannelError() callback was invoked - the channel is dead, don't
   // attempt to communicate.
   bool on_channel_error_called_;
 
   base::MessageLoop* message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   scoped_ptr<FileSystemDispatcher> file_system_dispatcher_;
 
   scoped_ptr<QuotaDispatcher> quota_dispatcher_;
 
   scoped_refptr<ChildHistogramMessageFilter> histogram_message_filter_;
 
   scoped_refptr<ChildResourceMessageFilter> resource_message_filter_;
 
   scoped_refptr<ServiceWorkerMessageFilter> service_worker_message_filter_;
@@ skipping 31 matching lines @@
 
 struct ChildThreadImpl::Options {
   ~Options();
 
   class Builder;
 
   std::string channel_name;
   bool use_mojo_channel;
   bool in_browser_process;
   std::vector<IPC::MessageFilter*> startup_filters;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
 
  private:
   Options();
 };
 
 class ChildThreadImpl::Options::Builder {
  public:
   Builder();
 
   Builder& InBrowserProcess(bool in_browser_process);
   Builder& UseMojoChannel(bool use_mojo_channel);
   Builder& WithChannelName(const std::string& channel_name);
   Builder& AddStartupFilter(IPC::MessageFilter* filter);
+  Builder& WithTaskRunner(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   Options Build();
 
  private:
   struct Options options_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_CHILD_THREAD_IMPL_H_