CommandLine API rework

chrome/browser/renderer_host/browser_render_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/renderer_host/browser_render_process_host.h"
 
 #include <algorithm>
 #include <sstream>
 #include <vector>
 
@@ skipping 149 matching lines @@
 
   scoped_refptr<ResourceMessageFilter> resource_message_filter =
       new ResourceMessageFilter(g_browser_process->resource_dispatcher_host(),
                                 PluginService::GetInstance(),
                                 g_browser_process->print_job_manager(),
                                 host_id(),
                                 profile(),
                                 widget_helper_,
                                 profile()->GetSpellChecker());
 
-  CommandLine browser_command_line;
+  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
 
   // setup IPC channel
   std::wstring channel_id = GenerateRandomChannelID(this);
   channel_.reset(
       new IPC::SyncChannel(channel_id, IPC::Channel::MODE_SERVER, this,
                            resource_message_filter,
                            io_thread->message_loop(), true,
                            g_browser_process->shutdown_event()));
   // As a preventive mesure, we DCHECK if someone sends a synchronous message
   // with no time-out, which in the context of the browser process we should not
   // be doing.
   channel_->set_sync_messages_with_no_timeout_allowed(false);
 
   // build command line for renderer, we have to quote the executable name to
   // deal with spaces
   std::wstring renderer_path =
       browser_command_line.GetSwitchValue(switches::kRendererPath);
   if (renderer_path.empty())
     if (!GetRendererPath(&renderer_path))
       return false;
-  std::wstring cmd_line;
-  cmd_line = L"\"" + renderer_path + L"\"";
+  CommandLine cmd_line(renderer_path);
   if (logging::DialogsAreSuppressed())
-    CommandLine::AppendSwitch(&cmd_line, switches::kNoErrorDialogs);
+    cmd_line.AppendSwitch(switches::kNoErrorDialogs);
 
   // propagate the following switches to the renderer command line
   // (along with any associated values) if present in the browser command line
   static const wchar_t* const switch_names[] = {
     switches::kRendererAssertTest,
     switches::kRendererCrashTest,
     switches::kRendererStartupDialog,
     switches::kNoSandbox,
     switches::kTestSandbox,
     switches::kInProcessPlugins,
@@ skipping 17 matching lines @@
     switches::kSilentDumpOnDCHECK,
     switches::kDisablePopupBlocking,
     switches::kUseLowFragHeapCrt,
     switches::kGearsInRenderer,
     switches::kEnableUserScripts,
     switches::kEnableVideo,
   };
 
   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]));
     }
   }
 
   // Pass on the browser locale.
   const std::wstring locale = g_browser_process->GetApplicationLocale();
-  CommandLine::AppendSwitchWithValue(&cmd_line, switches::kLang, locale);
+  cmd_line.AppendSwitchWithValue(switches::kLang, locale);
 
   bool in_sandbox = !browser_command_line.HasSwitch(switches::kNoSandbox);
   if (browser_command_line.HasSwitch(switches::kInProcessPlugins)) {
     // In process plugins won't work if the sandbox is enabled.
     in_sandbox = false;
   }
 
   bool child_needs_help =
       DebugFlags::ProcessDebugFlags(&cmd_line,
                                     DebugFlags::RENDERER,
                                     in_sandbox);
-  CommandLine::AppendSwitchWithValue(&cmd_line,
-                                     switches::kProcessType,
-                                     switches::kRendererProcess);
+  cmd_line.AppendSwitchWithValue(switches::kProcessType,
+                                 switches::kRendererProcess);
 
-  CommandLine::AppendSwitchWithValue(&cmd_line,
-                                     switches::kProcessChannelID,
-                                     channel_id);
+  cmd_line.AppendSwitchWithValue(switches::kProcessChannelID,
+                                 channel_id);
 
   const std::wstring& profile_path =
       browser_command_line.GetSwitchValue(switches::kUserDataDir);
   if (!profile_path.empty())
-    CommandLine::AppendSwitchWithValue(&cmd_line, switches::kUserDataDir,
-                                       profile_path);
+    cmd_line.AppendSwitchWithValue(switches::kUserDataDir,
+                                   profile_path);
 
   bool run_in_process = run_renderer_in_process();
   if (run_in_process) {
     // Crank up a thread and run the initialization there.  With the way that
     // messages flow between the browser and renderer, this thread is required
     // to prevent a deadlock in single-process mode.  When using multiple
     // processes, the primordial thread in the renderer process has a message
     // loop which is used for sending messages asynchronously to the io thread
     // in the browser process.  If we don't create this thread, then the
     // RenderThread is both responsible for rendering and also for
     // communicating IO.  This can lead to deadlocks where the RenderThread is
     // waiting for the IO to complete, while the browsermain is trying to pass
     // an event to the RenderThread.
     //
     // TODO: We should consider how to better cleanup threads on exit.
     base::Thread *render_thread = new RendererMainThread(channel_id);
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_IO;
     render_thread->StartWithOptions(options);
   } else {
     if (g_browser_process->local_state() &&
         g_browser_process->local_state()->GetBoolean(
             prefs::kStartRenderersManually)) {
       std::wstring message =
-        L"Please start a renderer process using:\n" + cmd_line;
+          L"Please start a renderer process using:\n" +
+          cmd_line.command_line_string();
 
       // We don't know the owner window for BrowserRenderProcessHost and therefore we
       // pass a NULL HWND argument.
       win_util::MessageBox(NULL,
                            message,
                            switches::kBrowserStartRenderersManually,
                            MB_OK);
     } else {
       if (in_sandbox) {
         // spawn the child process in the sandbox
@@ skipping 21 matching lines @@
           policy->SetDesktop(kDesktopName);
         } else {
           DLOG(WARNING) << "Failed to apply desktop security to the renderer";
         }
 
         if (!AddGenericPolicy(policy)) {
           NOTREACHED();
           return false;
         }
 
-        CommandLine command_line;
-        if (command_line.HasSwitch(switches::kGearsInRenderer)) {
+        if (browser_command_line.HasSwitch(switches::kGearsInRenderer)) {
           if (!AddPolicyForGearsInRenderer(policy)) {
             NOTREACHED();
             return false;
           }
         }
 
         if (!AddDllEvictionPolicy(policy)) {
           NOTREACHED();
           return false;
         }
 
-        result = broker_service->SpawnTarget(renderer_path.c_str(),
-                                             cmd_line.c_str(),
-                                             policy, &target);
+        result =
+            broker_service->SpawnTarget(renderer_path.c_str(),
+                                        cmd_line.command_line_string().c_str(),
+                                        policy, &target);
         policy->Release();
 
         if (desktop)
           CloseDesktop(desktop);
 
         if (sandbox::SBOX_ALL_OK != result)
           return false;
 
         bool on_sandbox_desktop = (desktop != NULL);
         NotificationService::current()->Notify(
@@ skipping 101 matching lines @@
   base::SharedMemoryHandle handle_for_process = NULL;
   visitedlink_master->ShareToProcess(GetRendererProcessHandle(),
                                      &handle_for_process);
   DCHECK(handle_for_process);
   if (handle_for_process) {
     channel_->Send(new ViewMsg_VisitedLink_NewTable(handle_for_process));
   }
 }
 
 void BrowserRenderProcessHost::InitUserScripts() {
-  CommandLine command_line;
-  if (!command_line.HasSwitch(switches::kEnableUserScripts)) {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableUserScripts)) {
     return;
   }
 
   // TODO(aa): Figure out lifetime and ownership of this object
   // - VisitedLinkMaster is owned by Profile, but there has been talk of
   //   having scripts live elsewhere besides the profile.
   // - File IO should be asynchronous (see VisitedLinkMaster), but how do we
   //   get scripts to the first renderer without blocking startup? Should we
   //   cache some information across restarts?
   UserScriptMaster* user_script_master = profile()->GetUserScriptMaster();
@@ skipping 241 matching lines @@
         SendUserScriptsUpdate(shared_memory);
       }
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }