CommandLine API rework

chrome/browser/plugin_process_host.cc

 // Copyright (c) 2006-2008 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/plugin_process_host.h"
 
 #include <windows.h>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 443 matching lines @@
                                   this));
   if (!channel_->Connect())
     return false;
 
   // build command line for plugin, we have to quote the plugin's path to deal
   // with spaces.
   std::wstring exe_path;
   if (!PathService::Get(base::FILE_EXE, &exe_path))
     return false;
 
-  std::wstring cmd_line(L"\"");
-  cmd_line += exe_path;
-  cmd_line += L"\"";
+  CommandLine cmd_line(exe_path);
   if (logging::DialogsAreSuppressed())
-    CommandLine::AppendSwitch(&cmd_line, switches::kNoErrorDialogs);
+    cmd_line.AppendSwitch(switches::kNoErrorDialogs);
 
-  CommandLine browser_command_line;
+  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
 
   // propagate the following switches to the plugin command line (along with
   // any associated values) if present in the browser command line
   static const wchar_t* const switch_names[] = {
     switches::kPluginStartupDialog,
     switches::kNoSandbox,
     switches::kSafePlugins,
     switches::kTestSandbox,
     switches::kUserAgent,
     switches::kDisableBreakpad,
     switches::kFullMemoryCrashReport,
     switches::kEnableLogging,
     switches::kDisableLogging,
     switches::kLoggingLevel,
     switches::kUserDataDir,
     switches::kAllowAllActiveX,
     switches::kEnableDCHECK,
     switches::kSilentDumpOnDCHECK,
     switches::kMemoryProfiling,
     switches::kUseLowFragHeapCrt,
   };
 
   for (int i = 0; i < arraysize(switch_names); ++i) {
     if (browser_command_line.HasSwitch(switch_names[i])) {
-      CommandLine::AppendSwitchWithValue(
-          &cmd_line, switch_names[i],
+      cmd_line.AppendSwitchWithValue(
+          switch_names[i],
           browser_command_line.GetSwitchValue(switch_names[i]));
     }
   }
 
   // If specified, prepend a launcher program to the command line.
   std::wstring plugin_launcher =
       browser_command_line.GetSwitchValue(switches::kPluginLauncher);
-  if (!plugin_launcher.empty())
-    cmd_line = plugin_launcher + L" " + cmd_line;
+  if (!plugin_launcher.empty()) {
+    CommandLine new_cmd_line = CommandLine(plugin_launcher);
+    new_cmd_line.AppendArguments(cmd_line, true);
+    cmd_line = new_cmd_line;
+  }
 
   if (!locale.empty()) {
     // Pass on the locale so the null plugin will use the right language in the
     // prompt to install the desired plugin.
-    CommandLine::AppendSwitchWithValue(&cmd_line, switches::kLang, locale);
+    cmd_line.AppendSwitchWithValue(switches::kLang, locale);
   }
 
-  CommandLine::AppendSwitchWithValue(&cmd_line,
-                                     switches::kProcessType,
-                                     switches::kPluginProcess);
+  cmd_line.AppendSwitchWithValue(switches::kProcessType,
+                                 switches::kPluginProcess);
 
-  CommandLine::AppendSwitchWithValue(&cmd_line,
-                                     switches::kProcessChannelID,
-                                     channel_id_);
+  cmd_line.AppendSwitchWithValue(switches::kProcessChannelID,
+                                 channel_id_);
 
-  CommandLine::AppendSwitchWithValue(&cmd_line,
-                                     switches::kPluginPath,
-                                     plugin_path.ToWStringHack());
+  cmd_line.AppendSwitchWithValue(switches::kPluginPath,
+                                 plugin_path.ToWStringHack());
 
   bool in_sandbox = !browser_command_line.HasSwitch(switches::kNoSandbox) &&
                     browser_command_line.HasSwitch(switches::kSafePlugins);
 
   bool child_needs_help =
       DebugFlags::ProcessDebugFlags(&cmd_line, DebugFlags::PLUGIN, in_sandbox);
 
   if (in_sandbox) {
     // spawn the child process in the sandbox
     sandbox::BrokerServices* broker_service =
         g_browser_process->broker_services();
 
     sandbox::ResultCode result;
     PROCESS_INFORMATION target = {0};
     sandbox::TargetPolicy* policy = broker_service->CreatePolicy();
 
     std::wstring trusted_plugins =
         browser_command_line.GetSwitchValue(switches::kTrustedPlugins);
     if (!AddPolicyForPlugin(plugin_path, activex_clsid, trusted_plugins,
                             policy)) {
       NOTREACHED();
       return false;
     }
 
     if (!AddGenericPolicy(policy)) {
       NOTREACHED();
       return false;
     }
 
-    result = broker_service->SpawnTarget(exe_path.c_str(),
-                                         cmd_line.c_str(), policy, &target);
+    result =
+        broker_service->SpawnTarget(exe_path.c_str(),
+                                    cmd_line.command_line_string().c_str(),
+                                    policy, &target);
     policy->Release();
     if (sandbox::SBOX_ALL_OK != result)
       return false;
 
     ResumeThread(target.hThread);
     CloseHandle(target.hThread);
     process_.set_handle(target.hProcess);
 
     // Help the process a little. It can't start the debugger by itself if
     // the process is in a sandbox.
@@ skipping 366 matching lines @@
 void PluginProcessHost::OnDestroyWindow(HWND window) {
   plugin_service_->main_message_loop()->PostTask(FROM_HERE,
       new DestroyWindowTask(window));
 }
 
 void PluginProcessHost::Shutdown() {
 
   Send(new PluginProcessMsg_BrowserShutdown);
 }