Use the same set of switches for service process autorun and for launching process from browser.

chrome/browser/service_process/service_process_control.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 "chrome/browser/service_process/service_process_control.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_delta_serialization.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/upgrade_detector.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/service_messages.h"
 #include "chrome/common/service_process_util.h"
-#include "components/cloud_devices/common/cloud_devices_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
-#include "content/public/common/child_process_host.h"
-#include "google_apis/gaia/gaia_switches.h"
-#include "ui/base/ui_base_switches.h"
 
 using content::BrowserThread;
-using content::ChildProcessHost;
 
 // ServiceProcessControl implementation.
 ServiceProcessControl::ServiceProcessControl() {
 }
 
 ServiceProcessControl::~ServiceProcessControl() {
 }
 
 void ServiceProcessControl::ConnectInternal() {
   // If the channel has already been established then we run the task
@@ skipping 68 matching lines @@
 
   // If the service process is already running then connects to it.
   if (CheckServiceProcessReady()) {
     ConnectInternal();
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents", SERVICE_EVENT_LAUNCH,
                             SERVICE_EVENT_MAX);
 
-  // A service process should have a different mechanism for starting, but now
-  // we start it as if it is a child process.
-
-#if defined(OS_LINUX)
-  int flags = ChildProcessHost::CHILD_ALLOW_SELF;
-#else
-  int flags = ChildProcessHost::CHILD_NORMAL;
-#endif
-
-  base::FilePath exe_path = ChildProcessHost::GetChildPath(flags);
-  if (exe_path.empty())
-    NOTREACHED() << "Unable to get service process binary name.";
-
-  CommandLine* cmd_line = new CommandLine(exe_path);
-  cmd_line->AppendSwitchASCII(switches::kProcessType,
-                              switches::kServiceProcess);
-
-  static const char* const kSwitchesToCopy[] = {
-    switches::kCloudPrintSetupProxy,
-    switches::kCloudPrintURL,
-    switches::kCloudPrintXmppEndpoint,
-#if defined(OS_WIN)
-    switches::kEnableCloudPrintXps,
-#endif
-    switches::kEnableLogging,
-    switches::kIgnoreUrlFetcherCertRequests,
-    switches::kLang,
-    switches::kLoggingLevel,
-    switches::kLsoUrl,
-    switches::kNoServiceAutorun,
-    switches::kUserDataDir,
-    switches::kV,
-    switches::kVModule,
-    switches::kWaitForDebugger,
-  };
-  cmd_line->CopySwitchesFrom(*CommandLine::ForCurrentProcess(),
-                             kSwitchesToCopy,
-                             arraysize(kSwitchesToCopy));
-
+  scoped_ptr<base::CommandLine> cmd_line(CreateServiceProcessCommandLine());
   // And then start the process asynchronously.
-  launcher_ = new Launcher(this, cmd_line);
+  launcher_ = new Launcher(this, cmd_line.Pass());
   launcher_->Run(base::Bind(&ServiceProcessControl::OnProcessLaunched,
                             base::Unretained(this)));
 }
 
 void ServiceProcessControl::Disconnect() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   channel_.reset();
 }
 
 void ServiceProcessControl::OnProcessLaunched() {
@@ skipping 177 matching lines @@
   bool ret = Send(new ServiceMsg_Shutdown());
   channel_.reset();
   return ret;
 }
 
 // static
 ServiceProcessControl* ServiceProcessControl::GetInstance() {
   return Singleton<ServiceProcessControl>::get();
 }
 
-ServiceProcessControl::Launcher::Launcher(ServiceProcessControl* process,
-                                          CommandLine* cmd_line)
+ServiceProcessControl::Launcher::Launcher(
+    ServiceProcessControl* process,
+    scoped_ptr<base::CommandLine> cmd_line)
     : process_(process),
-      cmd_line_(cmd_line),
+      cmd_line_(cmd_line.Pass()),
       launched_(false),
       retry_count_(0),
       process_handle_(base::kNullProcessHandle) {
 }
 
 // Execute the command line to start the process asynchronously.
 // After the command is executed, |task| is called with the process handle on
 // the UI thread.
 void ServiceProcessControl::Launcher::Run(const base::Closure& task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 55 matching lines @@
   if (base::LaunchProcess(*cmd_line_, options, &process_handle_)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&Launcher::DoDetectLaunched, this));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
   }
 }
 #endif  // !OS_MACOSX