Set up content in-process main threads via factory

content/browser/utility_process_host_impl.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/utility_process_host_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/browser/browser_child_process_host_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
-#include "content/child/child_process.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/utility_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
-#include "content/utility/utility_thread_impl.h"
 #include "ipc/ipc_switches.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(OS_WIN)
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #endif
 
 namespace content {
 
 #if defined(OS_WIN)
 // NOTE: changes to this class need to be reviewed by the security team.
 class UtilitySandboxedProcessLauncherDelegate
     : public SandboxedProcessLauncherDelegate {
  public:
   explicit UtilitySandboxedProcessLauncherDelegate(
     const base::FilePath& exposed_dir) : exposed_dir_(exposed_dir) {}
   virtual ~UtilitySandboxedProcessLauncherDelegate() {}
 
   virtual void PreSandbox(bool* disable_default_policy,
                           base::FilePath* exposed_dir) OVERRIDE {
     *exposed_dir = exposed_dir_;
   }
 
 private:
   base::FilePath exposed_dir_;
 };
 #endif
 
-// We want to ensure there's only one utility thread running at a time, as there
-// are many globals used in the utility process.
-static base::LazyInstance<base::Lock> g_one_utility_thread_lock;
 
-// Single process not supported in multiple dll mode currently.
-#if !defined(CHROME_MULTIPLE_DLL)
-class UtilityMainThread : public base::Thread {
- public:
-  UtilityMainThread(const std::string& channel_id)
-      : Thread("Chrome_InProcUtilityThread"),
-        channel_id_(channel_id) {
-  }
-
-  virtual ~UtilityMainThread() {
-    Stop();
-  }
-
- private:
-  // base::Thread implementation:
-  virtual void Init() OVERRIDE {
-    // We need to return right away or else the main thread that started us will
-    // hang.
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&UtilityMainThread::InitInternal, base::Unretained(this)));
-  }
-
-  virtual void CleanUp() OVERRIDE {
-    child_process_.reset();
-
-    // See comment in RendererMainThread.
-    SetThreadWasQuitProperly(true);
-    g_one_utility_thread_lock.Get().Release();
-  }
-
-  void InitInternal() {
-    g_one_utility_thread_lock.Get().Acquire();
-    child_process_.reset(new ChildProcess());
-    child_process_->set_main_thread(new UtilityThreadImpl(channel_id_));
-  }
-
-  std::string channel_id_;
-  scoped_ptr<ChildProcess> child_process_;
-
-  DISALLOW_COPY_AND_ASSIGN(UtilityMainThread);
-};
-#endif  // !CHROME_MULTIPLE_DLL
+UtilityMainThreadFactoryFunction g_utility_main_thread_factory = NULL;
 
 UtilityProcessHost* UtilityProcessHost::Create(
     UtilityProcessHostClient* client,
     base::SequencedTaskRunner* client_task_runner) {
   return new UtilityProcessHostImpl(client, client_task_runner);
 }
 
+void UtilityProcessHost::RegisterUtilityMainThreadFactory(
+    UtilityMainThreadFactoryFunction create) {
+  g_utility_main_thread_factory = create;
+}
+
 UtilityProcessHostImpl::UtilityProcessHostImpl(
     UtilityProcessHostClient* client,
     base::SequencedTaskRunner* client_task_runner)
     : client_(client),
       client_task_runner_(client_task_runner),
       is_batch_mode_(false),
       is_mdns_enabled_(false),
       no_sandbox_(false),
 #if defined(OS_LINUX)
       child_flags_(ChildProcessHost::CHILD_ALLOW_SELF),
@@ skipping 69 matching lines @@
   // Name must be set or metrics_service will crash in any test which
   // launches a UtilityProcessHost.
   process_.reset(new BrowserChildProcessHostImpl(PROCESS_TYPE_UTILITY, this));
   process_->SetName(ASCIIToUTF16("utility process"));
 
   std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty())
     return false;
 
   // Single process not supported in multiple dll mode currently.
-#if !defined(CHROME_MULTIPLE_DLL)
-  if (RenderProcessHost::run_renderer_in_process()) {
+  if (RenderProcessHost::run_renderer_in_process() &&
+      g_utility_main_thread_factory) {
     // See comment in RenderProcessHostImpl::Init() for the background on why we
     // support single process mode this way.
-    in_process_thread_.reset(new UtilityMainThread(channel_id));
+    in_process_thread_.reset(g_utility_main_thread_factory(channel_id));
     in_process_thread_->Start();
-  } else
-#endif  // !CHROME_MULTIPLE_DLL
-  {
+  } else {
     const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
     int child_flags = child_flags_;
 
 #if defined(OS_POSIX)
     bool has_cmd_prefix = browser_command_line.HasSwitch(
         switches::kUtilityCmdPrefix);
 
     // When running under gdb, forking /proc/self/exe ends up forking the gdb
     // executable instead of Chromium. It is almost safe to assume that no
     // updates will happen while a developer is running with
@@ skipping 70 matching lines @@
 }
 
 void UtilityProcessHostImpl::OnProcessCrashed(int exit_code) {
   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UtilityProcessHostClient::OnProcessCrashed, client_.get(),
             exit_code));
 }
 
 }  // namespace content