Revert of Remove dependency on content from remoting_host.

remoting/host/chromoting_host_context.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 "remoting/host/chromoting_host_context.h"
 
-#include "base/bind.h"
 #include "base/threading/thread_restrictions.h"
+#include "content/public/browser/browser_thread.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/url_request_context_getter.h"
 
 namespace remoting {
 
 namespace {
 
 void DisallowBlockingOperations() {
   base::ThreadRestrictions::SetIOAllowed(false);
   base::ThreadRestrictions::DisallowWaiting();
@@ skipping 101 matching lines @@
       AutoThread::CreateWithType("ChromotingInputThread", ui_task_runner,
                                  base::MessageLoop::TYPE_IO),
       network_task_runner,
       AutoThread::Create("ChromotingCaptureThread", ui_task_runner),
       AutoThread::Create("ChromotingEncodeThread", ui_task_runner),
       make_scoped_refptr(
           new URLRequestContextGetter(network_task_runner, file_task_runner))));
 }
 
 #if defined(OS_CHROMEOS)
+namespace {
+// Retrieves the task_runner from the browser thread with |id|.
+scoped_refptr<AutoThreadTaskRunner> WrapBrowserThread(
+    content::BrowserThread::ID id) {
+  // AutoThreadTaskRunner is a TaskRunner with the special property that it will
+  // continue to process tasks until no references remain, at least. The
+  // QuitClosure we usually pass does the simple thing of stopping the
+  // underlying TaskRunner.  Since we are re-using the ui_task_runner of the
+  // browser thread, we cannot stop it explicitly.  Therefore, base::DoNothing
+  // is passed in as the quit closure.
+  // TODO(kelvinp): Fix this (See crbug.com/428187).
+  return new AutoThreadTaskRunner(
+      content::BrowserThread::GetMessageLoopProxyForThread(id).get(),
+      base::Bind(&base::DoNothing));
+}
+
+}  // namespace
 
 // static
 scoped_ptr<ChromotingHostContext> ChromotingHostContext::CreateForChromeOS(
-    scoped_refptr<net::URLRequestContextGetter> url_request_context_getter,
-    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
+    scoped_refptr<net::URLRequestContextGetter> url_request_context_getter) {
   DCHECK(url_request_context_getter.get());
 
+  // Use BrowserThread::FILE as the joiner as it is the only browser-thread
+  // that allows blocking I/O, which is required by thread joining.
+  // TODO(kelvinp): Fix AutoThread so that it can be joinable on task runners
+  // that disallow I/O (crbug.com/428466).
+  scoped_refptr<AutoThreadTaskRunner> file_task_runner =
+      WrapBrowserThread(content::BrowserThread::FILE);
 
-  // AutoThreadTaskRunner is a TaskRunner with the special property that it will
-  // continue to process tasks until no references remain, at least. The
-  // QuitClosure we usually pass does the simple thing of stopping the
-  // underlying TaskRunner. Since we are re-using browser's threads, we cannot
-  // stop them explicitly. Therefore, base::DoNothing is passed in as the quit
-  // closure.
-  scoped_refptr<AutoThreadTaskRunner> io_auto_task_runner =
-      new AutoThreadTaskRunner(io_task_runner, base::Bind(&base::DoNothing));
-  scoped_refptr<AutoThreadTaskRunner> file_auto_task_runner =
-      new AutoThreadTaskRunner(file_task_runner, base::Bind(&base::DoNothing));
-  scoped_refptr<AutoThreadTaskRunner> ui_auto_task_runner =
-      new AutoThreadTaskRunner(ui_task_runner, base::Bind(&base::DoNothing));
+  scoped_refptr<AutoThreadTaskRunner> ui_task_runner =
+      WrapBrowserThread(content::BrowserThread::UI);
 
-  // Use browser's file thread as the joiner as it is the only browser-thread
-  // that allows blocking I/O, which is required by thread joining.
   return make_scoped_ptr(new ChromotingHostContext(
-      ui_auto_task_runner,
-      AutoThread::Create("ChromotingAudioThread", file_auto_task_runner),
-      file_auto_task_runner,
-      ui_auto_task_runner,  // input_task_runner
-      io_auto_task_runner,  // network_task_runner
-      ui_auto_task_runner,  // video_capture_task_runner
-      AutoThread::Create("ChromotingEncodeThread", file_auto_task_runner),
+      ui_task_runner,
+      AutoThread::CreateWithType("ChromotingAudioThread", file_task_runner,
+                                 base::MessageLoop::TYPE_IO),
+      file_task_runner,
+      AutoThread::CreateWithType("ChromotingInputThread", file_task_runner,
+                                 base::MessageLoop::TYPE_IO),
+      WrapBrowserThread(content::BrowserThread::IO),  // network_task_runner
+      ui_task_runner,  // video_capture_task_runner
+      AutoThread::CreateWithType("ChromotingEncodeThread", file_task_runner,
+                                 base::MessageLoop::TYPE_IO),
       url_request_context_getter));
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace remoting