Introduce background Download process to android

content/browser/android/child_process_launcher_android.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 "content/browser/android/child_process_launcher_android.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "content/browser/file_descriptor_info_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/media/android/media_web_contents_observer_android.h"
 #include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/child_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "jni/ChildProcessLauncher_jni.h"
 #include "media/base/android/media_player_android.h"
 #include "ui/gl/android/surface_texture.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ToJavaArrayOfStrings;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 using content::StartChildProcessCallback;
@@ skipping 49 matching lines @@
 
   if (player != player_manager->GetFullscreenPlayer()) {
     gfx::ScopedJavaSurface scoped_surface(surface);
     player->SetVideoSurface(std::move(scoped_surface));
   }
 #else
   NOTREACHED();
 #endif
 }
 
+void EmptyCallback(base::ProcessHandle) {}
+
+void LaunchDownloadProcess(base::CommandLine* cmd_line, int child_process_id) {
+  scoped_ptr<base::CommandLine> cmd_line_deleter(cmd_line);
+  StartChildProcess(cmd_line->argv(), child_process_id,

[no sievers, 2016/02/02 01:37:38]

How about a different Java entry point, if all the arguments don't apply?

[qinmin, 2016/02/02 20:51:41]

Done. Call startDownloadProcess() in the java class.

+                    FileDescriptorInfoImpl::Create(),
+                    std::map<int, base::MemoryMappedFile::Region>(),
+                    base::Bind(&EmptyCallback));
+}
+
 }  // anonymous namespace
 
 // 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,
                                   jint handle) {
   StartChildProcessCallback* callback =
       reinterpret_cast<StartChildProcessCallback*>(client_context);
   if (handle)
     callback->Run(static_cast<base::ProcessHandle>(handle));
   delete callback;
 }
 
+void StartDownloadProcess() {
+  base::FilePath exe_path = content::ChildProcessHost::GetChildPath(
+      content::ChildProcessHost::CHILD_NORMAL);
+  if (exe_path.empty()) {
+    NOTREACHED() << "Unable to get download process binary name.";
+    return;
+  }
+  base::CommandLine* cmd_line = new base::CommandLine(exe_path);
+  cmd_line->AppendSwitchASCII(switches::kProcessType,
+                              switches::kDownloadProcess);
+  cmd_line->AppendSwitch(switches::kNoSandbox);
+  int child_process_id = ChildProcessHostImpl::GenerateChildProcessUniqueId();
+  GetContentClient()->browser()->AppendExtraCommandLineSwitches(
+      cmd_line, child_process_id);
+
+  const base::CommandLine browser_command_line =
+      *base::CommandLine::ForCurrentProcess();
+  static const char* kForwardSwitches[] = {
+      switches::kDisableLogging,
+      switches::kEnableLogging,
+      switches::kLoggingLevel,
+  };
+  cmd_line->CopySwitchesFrom(browser_command_line, kForwardSwitches,
+                             arraysize(kForwardSwitches));
+  CHECK(!cmd_line->HasSwitch(switches::kSingleProcess));
+  BrowserThread::PostTask(
+      BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+      base::Bind(&LaunchDownloadProcess, cmd_line, child_process_id));
+}
+
 void StartChildProcess(
     const base::CommandLine::StringVector& argv,
     int child_process_id,
     scoped_ptr<content::FileDescriptorInfo> files_to_register,
     const std::map<int, base::MemoryMappedFile::Region>& regions,
     const StartChildProcessCallback& callback) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(env);
 
   // Create the Command line String[]
   ScopedJavaLocalRef<jobjectArray> j_argv = ToJavaArrayOfStrings(env, argv);
 
   size_t file_count = files_to_register->GetMappingSize();
-  DCHECK(file_count > 0);
 
   ScopedJavaLocalRef<jclass> j_file_info_class = base::android::GetClass(
       env, "org/chromium/content/browser/FileDescriptorInfo");
   ScopedJavaLocalRef<jobjectArray> j_file_infos(
       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);
@@ skipping 102 matching lines @@
 jboolean IsSingleProcess(JNIEnv* env, const JavaParamRef<jclass>& clazz) {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSingleProcess);
 }
 
 bool RegisterChildProcessLauncher(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content