Remote assistance on Chrome OS Part IV - It2MeHost

remoting/host/chromoting_host_context.cc

Index: remoting/host/chromoting_host_context.cc
diff --git a/remoting/host/chromoting_host_context.cc b/remoting/host/chromoting_host_context.cc
index 754ea8b5c23be1bd7643b20d9eb0a9bde81803d1..99aa75b206845da142fdff2c9bf36f0174501578 100644
--- a/remoting/host/chromoting_host_context.cc
+++ b/remoting/host/chromoting_host_context.cc
@@ -4,64 +4,39 @@
 
 #include "remoting/host/chromoting_host_context.h"
 
-#include <string>
-
-#include "base/bind.h"
+#include "content/public/browser/browser_thread.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/url_request_context_getter.h"
 
 namespace remoting {
 
 ChromotingHostContext::ChromotingHostContext(
-    AutoThreadTaskRunner* ui_task_runner)
-    : ui_task_runner_(ui_task_runner) {
-#if defined(OS_WIN)
-  // On Windows the AudioCapturer requires COM, so we run a single-threaded
-  // apartment, which requires a UI thread.
-  audio_task_runner_ =
-      AutoThread::CreateWithLoopAndComInitTypes("ChromotingAudioThread",
-                                                ui_task_runner_,
-                                                base::MessageLoop::TYPE_UI,
-                                                AutoThread::COM_INIT_STA);
-#else // !defined(OS_WIN)
-  audio_task_runner_ = AutoThread::CreateWithType(
-      "ChromotingAudioThread", ui_task_runner_, base::MessageLoop::TYPE_IO);
-#endif  // !defined(OS_WIN)
-
-  file_task_runner_ = AutoThread::CreateWithType(
-      "ChromotingFileThread", ui_task_runner_, base::MessageLoop::TYPE_IO);
-  input_task_runner_ = AutoThread::CreateWithType(
-      "ChromotingInputThread", ui_task_runner_, base::MessageLoop::TYPE_IO);
-  network_task_runner_ = AutoThread::CreateWithType(
-      "ChromotingNetworkThread", ui_task_runner_, base::MessageLoop::TYPE_IO);
-  video_capture_task_runner_ =
-      AutoThread::Create("ChromotingCaptureThread", ui_task_runner_);
-  video_encode_task_runner_ = AutoThread::Create(
-      "ChromotingEncodeThread", ui_task_runner_);
-
-  url_request_context_getter_ = new URLRequestContextGetter(
-      network_task_runner_, file_task_runner_);
+    scoped_refptr<AutoThreadTaskRunner> ui_task_runner,
+    scoped_refptr<AutoThreadTaskRunner> audio_task_runner,
+    scoped_refptr<AutoThreadTaskRunner> file_task_runner,
+    scoped_refptr<AutoThreadTaskRunner> input_task_runner,
+    scoped_refptr<AutoThreadTaskRunner> network_task_runner,
+    scoped_refptr<AutoThreadTaskRunner> video_capture_task_runner,
+    scoped_refptr<AutoThreadTaskRunner> video_encode_task_runner,
+    scoped_refptr<net::URLRequestContextGetter> url_request_context_getter)
+    : ui_task_runner_(ui_task_runner),
+      audio_task_runner_(audio_task_runner),
+      file_task_runner_(file_task_runner),
+      input_task_runner_(input_task_runner),
+      network_task_runner_(network_task_runner),
+      video_capture_task_runner_(video_capture_task_runner),
+      video_encode_task_runner_(video_encode_task_runner),
+      url_request_context_getter_(url_request_context_getter) {
 }
 
 ChromotingHostContext::~ChromotingHostContext() {
 }
 
-scoped_ptr<ChromotingHostContext> ChromotingHostContext::Create(
-    scoped_refptr<AutoThreadTaskRunner> ui_task_runner) {
-  DCHECK(ui_task_runner->BelongsToCurrentThread());
-
-  scoped_ptr<ChromotingHostContext> context(
-      new ChromotingHostContext(ui_task_runner.get()));
-  if (!context->audio_task_runner_.get() || !context->file_task_runner_.get() ||
-      !context->input_task_runner_.get() ||
-      !context->network_task_runner_.get() ||
-      !context->video_capture_task_runner_.get() ||
-      !context->video_encode_task_runner_.get() ||
-      !context->url_request_context_getter_.get()) {
-    context.reset();
-  }
-
-  return context.Pass();
+scoped_ptr<ChromotingHostContext> ChromotingHostContext::Copy() {
+  return make_scoped_ptr(new ChromotingHostContext(
+      ui_task_runner_, audio_task_runner_, file_task_runner_,
+      input_task_runner_, network_task_runner_, video_capture_task_runner_,
+      video_encode_task_runner_, url_request_context_getter_));
 }
 
 scoped_refptr<AutoThreadTaskRunner>
@@ -104,4 +79,80 @@ ChromotingHostContext::url_request_context_getter() {
   return url_request_context_getter_;
 }
 
+scoped_ptr<ChromotingHostContext> ChromotingHostContext::Create(
+    scoped_refptr<AutoThreadTaskRunner> ui_task_runner) {
+#if defined(OS_WIN)
+  // On Windows the AudioCapturer requires COM, so we run a single-threaded
+  // apartment, which requires a UI thread.
+  scoped_refptr<AutoThreadTaskRunner> audio_task_runner =
+      AutoThread::CreateWithLoopAndComInitTypes(
+          "ChromotingAudioThread", ui_task_runner, base::MessageLoop::TYPE_UI,
+          AutoThread::COM_INIT_STA);
+#else   // !defined(OS_WIN)
+  scoped_refptr<AutoThreadTaskRunner> audio_task_runner =
+      AutoThread::CreateWithType("ChromotingAudioThread", ui_task_runner,
+                                 base::MessageLoop::TYPE_IO);
+#endif  // !defined(OS_WIN)
+  scoped_refptr<AutoThreadTaskRunner> file_task_runner =
+      AutoThread::CreateWithType("ChromotingFileThread", ui_task_runner,
+                                 base::MessageLoop::TYPE_IO);
+  scoped_refptr<AutoThreadTaskRunner> network_task_runner =
+      AutoThread::CreateWithType("ChromotingNetworkThread", ui_task_runner,
+                                 base::MessageLoop::TYPE_IO);
+
+  return make_scoped_ptr(new ChromotingHostContext(
+      ui_task_runner,
+      audio_task_runner,
+      file_task_runner,
+      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|.
+AutoThreadTaskRunner* GetTaskRunner(content::BrowserThread::ID id) {

[Wez, 2014/10/24 23:29:27]

Suggest WrapBrowserThread() as more descriptive name for this.

[Wez, 2014/10/24 23:29:27]

scoped_refptr<>

[kelvinp, 2014/10/29 01:22:52]

Done.

[kelvinp, 2014/10/29 01:22:52]

Done.

+  // This is a hack.  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.

[Wez, 2014/10/24 23:29:27]

Let's add a bug, and refer to it here, for fixing that somehow.

[kelvinp, 2014/10/29 01:22:52]

Done.

+  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) {
+  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.
+  scoped_refptr<AutoThreadTaskRunner> joiner_task_runner =
+      GetTaskRunner(content::BrowserThread::FILE);
+
+  return make_scoped_ptr(new ChromotingHostContext(
+      GetTaskRunner(content::BrowserThread::UI),
+      AutoThread::CreateWithType("ChromotingAudioThread", joiner_task_runner,
+                                 base::MessageLoop::TYPE_IO),
+      GetTaskRunner(content::BrowserThread::FILE),

[Wez, 2014/10/24 23:29:27]

You already wrapped FILE, above; just re-use that here.

[kelvinp, 2014/10/29 01:22:52]

Done.

+      AutoThread::CreateWithType("ChromotingInputThread", joiner_task_runner,
+                                 base::MessageLoop::TYPE_IO),
+      GetTaskRunner(content::BrowserThread::IO), // network_task_runner
+      GetTaskRunner(content::BrowserThread::UI), // video_capture_task_runner

[Wez, 2014/10/24 23:29:27]

You already wrapped UI, above; re-use that here.

[kelvinp, 2014/10/29 01:22:52]

Done.

+      AutoThread::CreateWithType("ChromotingEncodeThread", joiner_task_runner,
+                                 base::MessageLoop::TYPE_IO),

[Wez, 2014/10/24 23:29:27]

Why does encode need an I/O thread...?

[kelvinp, 2014/10/29 01:22:52]

I am not sure.  The implementation on the existing platform uses a task runner
with TYPE_IO.

+      url_request_context_getter));
+}
+#endif  // defined(OS_CHROMEOS)
+
 }  // namespace remoting