Adding container class for chromoting client runtimes.

remoting/client/jni/chromoting_jni_runtime.cc

 // Copyright 2013 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/client/jni/chromoting_jni_runtime.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/library_loader/library_loader_hooks.h"
@@ skipping 195 matching lines @@
 }
 
 // ChromotingJniRuntime implementation.
 
 // static
 ChromotingJniRuntime* ChromotingJniRuntime::GetInstance() {
   return base::Singleton<ChromotingJniRuntime>::get();
 }
 
 ChromotingJniRuntime::ChromotingJniRuntime() {
-  // On Android, the UI thread is managed by Java, so we need to attach and
-  // start a special type of message loop to allow Chromium code to run tasks.
-  ui_loop_.reset(new base::MessageLoopForUI());
-  ui_loop_->Start();
+  // Grab or create the threads.
+  // TODO(nicholss) We could runtime this as a constructor argument when jni
+  // runtime is not no longer a singleton.
 
-  // TODO(solb) Stop pretending to control the managed UI thread's lifetime.
-  ui_task_runner_ = new AutoThreadTaskRunner(
-      ui_loop_->task_runner(), base::MessageLoop::QuitWhenIdleClosure());
-  network_task_runner_ = AutoThread::CreateWithType("native_net",
-                                                    ui_task_runner_,
-                                                    base::MessageLoop::TYPE_IO);
-  display_task_runner_ = AutoThread::Create("native_disp",
-                                            ui_task_runner_);
+  if (!base::MessageLoop::current()) {
+    VLOG(1) << "Starting main message loop";
+    // On Android, the UI thread is managed by Java, so we need to attach and
+    // start a special type of message loop to allow Chromium code to run tasks.
+    ui_loop_.reset(new base::MessageLoopForUI());
+    ui_loop_->Start();
+  } else {
+    VLOG(1) << "Using existing main message loop";
+    ui_loop_.reset(base::MessageLoopForUI::current());
+  }
 
-  url_requester_ =
-      new URLRequestContextGetter(network_task_runner_, network_task_runner_);
+  // Pass the main ui loop already attached to be used for creating threads.
+  runtime_ = ChromotingClientRuntime::Create(ui_loop_.get());
 }
 
 ChromotingJniRuntime::~ChromotingJniRuntime() {
   // The singleton should only ever be destroyed on the main thread.
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
 
   // The session must be shut down first, since it depends on our other
   // components' still being alive.
   DisconnectFromHost();
 
   base::WaitableEvent done_event(false, false);
-  network_task_runner_->PostTask(FROM_HERE, base::Bind(
-      &ChromotingJniRuntime::DetachFromVmAndSignal,
-      base::Unretained(this),
-      &done_event));
+  network_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ChromotingJniRuntime::DetachFromVmAndSignal,
+                            base::Unretained(this), &done_event));
   done_event.Wait();
-  display_task_runner_->PostTask(FROM_HERE, base::Bind(
-      &ChromotingJniRuntime::DetachFromVmAndSignal,
-      base::Unretained(this),
-      &done_event));
+  display_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ChromotingJniRuntime::DetachFromVmAndSignal,
+                            base::Unretained(this), &done_event));
   done_event.Wait();
   base::android::LibraryLoaderExitHook();
   base::android::DetachFromVM();
 }
 
 void ChromotingJniRuntime::ConnectToHost(const std::string& username,
                                          const std::string& auth_token,
                                          const std::string& host_jid,
                                          const std::string& host_id,
                                          const std::string& host_pubkey,
                                          const std::string& pairing_id,
                                          const std::string& pairing_secret,
                                          const std::string& capabilities,
                                          const std::string& flags) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
   DCHECK(!session_.get());
   session_ = new ChromotingJniInstance(this, username, auth_token, host_jid,
                                        host_id, host_pubkey, pairing_id,
                                        pairing_secret, capabilities, flags);
 }
 
 void ChromotingJniRuntime::DisconnectFromHost() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
   if (session_.get()) {
     session_->Disconnect();
     session_ = nullptr;
   }
 }
 
 void ChromotingJniRuntime::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_onConnectionState(env, state, error);
 }
 
 void ChromotingJniRuntime::DisplayAuthenticationPrompt(bool pairing_supported) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_displayAuthenticationPrompt(env, pairing_supported);
 }
 
 void ChromotingJniRuntime::CommitPairingCredentials(const std::string& host,
                                                     const std::string& id,
                                                     const std::string& secret) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_host = ConvertUTF8ToJavaString(env, host);
   ScopedJavaLocalRef<jstring> j_id = ConvertUTF8ToJavaString(env, id);
   ScopedJavaLocalRef<jstring> j_secret = ConvertUTF8ToJavaString(env,secret);
 
   Java_JniInterface_commitPairingCredentials(
       env, j_host.obj(), j_id.obj(), j_secret.obj());
 }
 
 void ChromotingJniRuntime::FetchThirdPartyToken(const GURL& token_url,
                                                 const std::string& client_id,
                                                 const std::string& scope) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
   JNIEnv* env = base::android::AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_url =
       ConvertUTF8ToJavaString(env, token_url.spec());
   ScopedJavaLocalRef<jstring> j_client_id =
       ConvertUTF8ToJavaString(env, client_id);
   ScopedJavaLocalRef<jstring> j_scope = ConvertUTF8ToJavaString(env, scope);
 
   Java_JniInterface_fetchThirdPartyToken(
       env, j_url.obj(), j_client_id.obj(), j_scope.obj());
 }
 
 void ChromotingJniRuntime::SetCapabilities(const std::string& capabilities) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
   JNIEnv* env = base::android::AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_cap =
       ConvertUTF8ToJavaString(env, capabilities);
 
   Java_JniInterface_setCapabilities(env, j_cap.obj());
 }
 
 void ChromotingJniRuntime::HandleExtensionMessage(const std::string& type,
                                                   const std::string& message) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
   JNIEnv* env = base::android::AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_type = ConvertUTF8ToJavaString(env, type);
   ScopedJavaLocalRef<jstring> j_message = ConvertUTF8ToJavaString(env, message);
 
   Java_JniInterface_handleExtensionMessage(env, j_type.obj(), j_message.obj());
 }
 
 base::android::ScopedJavaLocalRef<jobject> ChromotingJniRuntime::NewBitmap(
     int width, int height) {
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_JniInterface_newBitmap(env, width, height);
 }
 
 void ChromotingJniRuntime::UpdateFrameBitmap(jobject bitmap) {
-  DCHECK(display_task_runner_->BelongsToCurrentThread());
+  DCHECK(display_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_setVideoFrame(env, bitmap);
 }
 
 void ChromotingJniRuntime::UpdateCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
-  DCHECK(display_task_runner_->BelongsToCurrentThread());
+  DCHECK(display_task_runner()->BelongsToCurrentThread());
 
   // const_cast<> is safe as long as the Java updateCursorShape() method copies
   // the data out of the buffer without mutating it, and doesn't keep any
   // reference to the buffer afterwards. Unfortunately, there seems to be no way
   // to create a read-only ByteBuffer from a pointer-to-const.
   char* data = string_as_array(const_cast<std::string*>(&cursor_shape.data()));
   int cursor_total_bytes =
       cursor_shape.width() * cursor_shape.height() * kBytesPerPixel;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> buffer(env,
       env->NewDirectByteBuffer(data, cursor_total_bytes));
   Java_JniInterface_updateCursorShape(env,
                                       cursor_shape.width(),
                                       cursor_shape.height(),
                                       cursor_shape.hotspot_x(),
                                       cursor_shape.hotspot_y(),
                                       buffer.obj());
 }
 
 void ChromotingJniRuntime::RedrawCanvas() {
-  DCHECK(display_task_runner_->BelongsToCurrentThread());
+  DCHECK(display_task_runner()->BelongsToCurrentThread());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_JniInterface_redrawGraphicsInternal(env);
 }
 
 void ChromotingJniRuntime::DetachFromVmAndSignal(base::WaitableEvent* waiter) {
   base::android::DetachFromVM();
   waiter->Signal();
 }
 }  // namespace remoting