android: Java ChildProcessLauncherHelper instance

content/browser/child_process_launcher_helper_android.cc

 // Copyright 2017 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/browser/child_process_launcher_helper_android.h"
 
 #include <memory>
 
 #include "base/android/apk_assets.h"
 #include "base/android/context_utils.h"
 #include "base/android/jni_array.h"
 #include "base/i18n/icu_util.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "content/browser/child_process_launcher_helper.h"
 #include "content/browser/child_process_launcher_helper_posix.h"
 #include "content/browser/file_descriptor_info_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_descriptors.h"
 #include "content/public/common/content_switches.h"
 #include "gin/v8_initializer.h"
-#include "jni/ChildProcessLauncher_jni.h"
+#include "jni/ChildProcessLauncherHelper_jni.h"
 
 using base::android::AttachCurrentThread;
 using base::android::JavaParamRef;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 using base::android::ToJavaArrayOfStrings;
 
 namespace content {
-
-typedef base::Callback<void(base::ProcessHandle, int /* launch result */)>
-    StartChildProcessCallback;
-
 namespace internal {
-
 namespace {
 
 // Stops a child process based on the handle returned from StartChildProcess.
 void StopChildProcess(base::ProcessHandle handle) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(env);
-  Java_ChildProcessLauncher_stop(env, static_cast<jint>(handle));
-}
-
-// Callback invoked from Java once the process has been started.
-void ChildProcessStartedCallback(
-    ChildProcessLauncherHelper* helper,
-    base::ProcessHandle handle,
-    int launch_result) {
-  // TODO(jcivelli): Remove this by defining better what happens on what thread
-  // in the corresponding Java code.
-  ChildProcessLauncherHelper::Process process;
-  process.process = base::Process(handle);
-  if (BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER)) {
-    helper->PostLaunchOnLauncherThread(
-        std::move(process),
-        launch_result,
-        false);  // post_launch_on_client_thread_called
-    return;
-  }
-
-  bool on_client_thread = BrowserThread::CurrentlyOn(
-      static_cast<BrowserThread::ID>(helper->client_thread_id()));
-  BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
-      base::Bind(&ChildProcessLauncherHelper::PostLaunchOnLauncherThread,
-                 helper,
-                 base::Passed(std::move(process)),
-                 launch_result,
-                 on_client_thread));
-  if (on_client_thread) {
-    ChildProcessLauncherHelper::Process process;
-    process.process = base::Process(handle);
-    helper->PostLaunchOnClientThread(std::move(process), launch_result);
-  }
+  Java_ChildProcessLauncherHelper_stop(env, static_cast<jint>(handle));
 }
 
 }  // namespace
 
 void ChildProcessLauncherHelper::BeforeLaunchOnClientThread() {
   // Android only supports renderer, sandboxed utility and gpu.
   std::string process_type =
       command_line()->GetSwitchValueASCII(switches::kProcessType);
   CHECK(process_type == switches::kGpuProcess ||
         process_type == switches::kRendererProcess ||
@@ skipping 64 matching lines @@
       env, env->NewObjectArray(file_count, j_file_info_class.obj(), NULL));
   base::android::CheckException(env);
 
   for (size_t i = 0; i < file_count; ++i) {
     int fd = files_to_register->GetFDAt(i);
     PCHECK(0 <= fd);
     int id = files_to_register->GetIDAt(i);
     const auto& region = files_to_register->GetRegionAt(i);
     bool auto_close = files_to_register->OwnsFD(fd);
     ScopedJavaLocalRef<jobject> j_file_info =
-        Java_ChildProcessLauncher_makeFdInfo(env, id, fd, auto_close,
-                                             region.offset, region.size);
+        Java_ChildProcessLauncherHelper_makeFdInfo(env, id, fd, auto_close,
+                                                   region.offset, region.size);
     PCHECK(j_file_info.obj());
     env->SetObjectArrayElement(j_file_infos.obj(), i, j_file_info.obj());
     if (auto_close) {
       ignore_result(files_to_register->ReleaseFD(fd).release());
     }
   }
 
   constexpr int param_key = 0;  // TODO(boliu): Use this.
-  Java_ChildProcessLauncher_start(
-      env, base::android::GetApplicationContext(), param_key, j_argv,
-      child_process_id(), j_file_infos,
-      reinterpret_cast<intptr_t>(new StartChildProcessCallback(
-          base::Bind(&ChildProcessStartedCallback, RetainedRef(this)))));
+  java_peer_.Reset(Java_ChildProcessLauncherHelper_create(
+      env,
+      reinterpret_cast<intptr_t>(
+          new scoped_refptr<ChildProcessLauncherHelper>(this)),
+      base::android::GetApplicationContext(), param_key, j_argv,
+      child_process_id(), j_file_infos));
 
   return Process();
 }
 
 void ChildProcessLauncherHelper::AfterLaunchOnLauncherThread(
     const ChildProcessLauncherHelper::Process& process,
     const base::LaunchOptions& options) {
 }
 
-// static
 base::TerminationStatus ChildProcessLauncherHelper::GetTerminationStatus(
     const ChildProcessLauncherHelper::Process& process,
     bool known_dead,
     int* exit_code) {
-  if (Java_ChildProcessLauncher_isOomProtected(
-          AttachCurrentThread(), static_cast<jint>(process.process.Handle()))) {
+  if (Java_ChildProcessLauncherHelper_isOomProtected(AttachCurrentThread(),
+                                                     java_peer_)) {
     return base::TERMINATION_STATUS_OOM_PROTECTED;
   }
   return base::GetTerminationStatus(process.process.Handle(), exit_code);
 }
 
 // static
 bool ChildProcessLauncherHelper::TerminateProcess(
     const base::Process& process, int exit_code, bool wait) {
   StopChildProcess(process.Handle());
   return true;
 }
 
 // static
 void ChildProcessLauncherHelper::ForceNormalProcessTerminationSync(
     ChildProcessLauncherHelper::Process process) {
   DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
   VLOG(1) << "ChromeProcess: Stopping process with handle "
           << process.process.Handle();
   StopChildProcess(process.process.Handle());
 }
 
-// static
 void ChildProcessLauncherHelper::SetProcessBackgroundedOnLauncherThread(
     base::Process process,
     bool background) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(env);
-  return Java_ChildProcessLauncher_setInForeground(
-      env, static_cast<jint>(process.Handle()), !background);
+  return Java_ChildProcessLauncherHelper_setInForeground(
+      env, java_peer_, process.Handle(), !background);
 }
 
 // static
 void ChildProcessLauncherHelper::SetRegisteredFilesForService(
     const std::string& service_name,
     catalog::RequiredFileMap required_files) {
   SetFilesToShareForServicePosix(service_name, std::move(required_files));
 }
 
 // static
 void ChildProcessLauncherHelper::ResetRegisteredFilesForTesting() {
   ResetFilesToShareForTestingPosix();
 }
 
 // static
 base::File OpenFileToShare(const base::FilePath& path,
                            base::MemoryMappedFile::Region* region) {
   return base::File(base::android::OpenApkAsset(path.value(), region));
 }
 
 // Called from ChildProcessLauncher.java when the ChildProcess was
 // started.
-// |client_context| is the pointer to StartChildProcessCallback which was
-// passed in from StartChildProcess.
 // |handle| is the processID of the child process as originated in Java, 0 if
 // the ChildProcess could not be created.
 static void OnChildProcessStarted(JNIEnv*,
                                   const JavaParamRef<jclass>&,
-                                  jlong client_context,
+                                  jlong pointer,
                                   jint handle) {
-  StartChildProcessCallback* callback =
-      reinterpret_cast<StartChildProcessCallback*>(client_context);
+  scoped_refptr<ChildProcessLauncherHelper> helper = std::move(
+      *reinterpret_cast<scoped_refptr<ChildProcessLauncherHelper>*>(pointer));
+  delete reinterpret_cast<scoped_refptr<ChildProcessLauncherHelper>*>(pointer);

[Maria, 2017/03/27 19:22:51]

these two lines look really odd to me. Do you want to add a comment on what you
are doing here?

[Jay Civelli, 2017/03/27 19:49:48]

Could OnChildProcessStarted be a non static method on
ChildProcessLauncherHelper.java?
Then you would manually increase the ref count in
ChildProcessLauncherHelper::LaunchProcessOnLauncherThread() and decrease it in
here and would not have to deal with passing references around.

[boliu, 2017/03/27 20:47:53]

Ahh, good suggestion. I guess only down side is more OS_ANDROID defs in shared
header, but not that bad. Resolves both of maria's comments :p

   int launch_result = (handle == base::kNullProcessHandle)
                           ? LAUNCH_RESULT_FAILURE
                           : LAUNCH_RESULT_SUCCESS;
-  callback->Run(static_cast<base::ProcessHandle>(handle), launch_result);
-  delete callback;
+
+  // TODO(jcivelli): Remove this by defining better what happens on what thread
+  // in the corresponding Java code.
+  ChildProcessLauncherHelper::Process process;
+  process.process = base::Process(handle);
+  if (BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER)) {
+    helper->PostLaunchOnLauncherThread(
+        std::move(process), launch_result,
+        false);  // post_launch_on_client_thread_called
+    return;
+  }
+
+  bool on_client_thread = BrowserThread::CurrentlyOn(
+      static_cast<BrowserThread::ID>(helper->client_thread_id()));
+  BrowserThread::PostTask(
+      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+      base::Bind(&ChildProcessLauncherHelper::PostLaunchOnLauncherThread,
+                 helper, base::Passed(std::move(process)), launch_result,
+                 on_client_thread));
+  if (on_client_thread) {
+    ChildProcessLauncherHelper::Process process;
+    process.process = base::Process(handle);
+    helper->PostLaunchOnClientThread(std::move(process), launch_result);
+  }
 }
 
 }  // namespace internal
 
 bool RegisterChildProcessLauncher(JNIEnv* env) {
   return internal::RegisterNativesImpl(env);
 }
 
 }  // namespace content