CommandLine refactoring and cleanup.

base/command_line.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "base/command_line.h"
 
 #include <algorithm>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #elif defined(OS_POSIX)
 #include <limits.h>
 #include <stdlib.h>
 #include <unistd.h>
 #endif
 
 CommandLine* CommandLine::current_process_commandline_ = NULL;
 
-// Since we use a lazy match, make sure that longer versions (like L"--")
-// are listed before shorter versions (like L"-") of similar prefixes.
+namespace {
+const CommandLine::CharType kSwitchTerminator[] = FILE_PATH_LITERAL("--");
+const CommandLine::CharType kSwitchValueSeparator[] = FILE_PATH_LITERAL("=");
+// Since we use a lazy match, make sure that longer versions (like "--")
+// are listed before shorter versions (like "-") of similar prefixes.
 #if defined(OS_WIN)
-const wchar_t* const kSwitchPrefixes[] = {L"--", L"-", L"/"};
-const wchar_t kSwitchTerminator[] = L"--";
-const wchar_t kSwitchValueSeparator[] = L"=";
+const CommandLine::CharType* const kSwitchPrefixes[] = {L"--", L"-", L"/"};
 #elif defined(OS_POSIX)
 // Unixes don't use slash as a switch.
-const char* const kSwitchPrefixes[] = {"--", "-"};
-const char kSwitchTerminator[] = "--";
-const char kSwitchValueSeparator[] = "=";
+const CommandLine::CharType* const kSwitchPrefixes[] = {"--", "-"};
 #endif
 
-#if defined(OS_WIN)
-// Lowercase a string.  This is used to lowercase switch names.
-// Is this what we really want?  It seems crazy to me.  I've left it in
-// for backwards compatibility on Windows.
-static void Lowercase(std::string* parameter) {
-  transform(parameter->begin(), parameter->end(), parameter->begin(),
-            tolower);
-}
-#endif
+void Lowercase(string* arg);
 
-CommandLine::~CommandLine() {
-}
-
-#if defined(OS_WIN)
-CommandLine::CommandLine(NoProgram no_program) {
-}
-
-void CommandLine::ParseFromString(const std::wstring& command_line) {
-  TrimWhitespace(command_line, TRIM_ALL, &command_line_string_);
-
-  if (command_line_string_.empty())
-    return;
-
-  int num_args = 0;
-  wchar_t** args = NULL;
-
-  args = CommandLineToArgvW(command_line_string_.c_str(), &num_args);
-
-  // Populate program_ with the trimmed version of the first arg.
-  TrimWhitespace(args[0], TRIM_ALL, &program_);
-
-  bool parse_switches = true;
-  for (int i = 1; i < num_args; ++i) {
-    std::wstring arg;
-    TrimWhitespace(args[i], TRIM_ALL, &arg);
-
-    if (!parse_switches) {
-      args_.push_back(arg);
-      continue;
-    }
-

[evanm, 2011/02/24 01:01:05]

It's hard to follow what's gone on in this file.  Did you move this code, or
change it, or...?

It might be helpful to move it in one change (which is trivial to review) and
then change it in a follow-up.

[msw, 2011/05/10 23:18:43]

Done (move was r76339, this change is cleaner).

-    if (arg == kSwitchTerminator) {
-      parse_switches = false;
-      continue;
-    }
-
-    std::string switch_string;
-    std::wstring switch_value;
-    if (IsSwitch(arg, &switch_string, &switch_value)) {
-      switches_[switch_string] = switch_value;
-    } else {
-      args_.push_back(arg);
-    }
-  }
-
-  if (args)
-    LocalFree(args);
-}
-
-// static
-CommandLine CommandLine::FromString(const std::wstring& command_line) {
-  CommandLine cmd;
-  cmd.ParseFromString(command_line);
-  return cmd;
-}
-
-CommandLine::CommandLine(const FilePath& program) {
-  if (!program.empty()) {
-    program_ = program.value();
-    // TODO(evanm): proper quoting here.
-    command_line_string_ = L'"' + program.value() + L'"';
-  }
-}
-
-#elif defined(OS_POSIX)
-CommandLine::CommandLine(NoProgram no_program) {
-  // Push an empty argument, because we always assume argv_[0] is a program.
-  argv_.push_back("");
-}
-
-CommandLine::CommandLine(int argc, const char* const* argv) {
-  InitFromArgv(argc, argv);
-}
-
-CommandLine::CommandLine(const std::vector<std::string>& argv) {
-  InitFromArgv(argv);
-}
-
-void CommandLine::InitFromArgv(int argc, const char* const* argv) {
-  for (int i = 0; i < argc; ++i)
-    argv_.push_back(argv[i]);
-  InitFromArgv(argv_);
-}
-
-void CommandLine::InitFromArgv(const std::vector<std::string>& argv) {
-  argv_ = argv;
-  bool parse_switches = true;
-  for (size_t i = 1; i < argv_.size(); ++i) {
-    const std::string& arg = argv_[i];
-
-    if (!parse_switches) {
-      args_.push_back(arg);
-      continue;
-    }
-
-    if (arg == kSwitchTerminator) {
-      parse_switches = false;
-      continue;
-    }
-
-    std::string switch_string;
-    std::string switch_value;
-    if (IsSwitch(arg, &switch_string, &switch_value)) {
-      switches_[switch_string] = switch_value;
-    } else {
-      args_.push_back(arg);
-    }
-  }
-}
-
-CommandLine::CommandLine(const FilePath& program) {
-  argv_.push_back(program.value());
-}
-
-#endif
-
-// static
-bool CommandLine::IsSwitch(const StringType& parameter_string,
-                           std::string* switch_string,
-                           StringType* switch_value) {
+// Returns true and fills in |switch_string| and |switch_value| if
+// |parameter_string| represents a switch.
+bool IsSwitch(const CommandLine::StringType& parameter_string,
+              string* switch_string,
+              CommandLine::StringType* switch_value) {
   switch_string->clear();
   switch_value->clear();
 
   for (size_t i = 0; i < arraysize(kSwitchPrefixes); ++i) {
-    StringType prefix(kSwitchPrefixes[i]);
+    CommandLine::StringType prefix(kSwitchPrefixes[i]);
     if (parameter_string.find(prefix) != 0)
       continue;
 
     const size_t switch_start = prefix.length();
     const size_t equals_position = parameter_string.find(
         kSwitchValueSeparator, switch_start);
-    StringType switch_native;
-    if (equals_position == StringType::npos) {
+    CommandLine::StringType switch_native;
+    if (equals_position == CommandLine::StringType::npos) {
       switch_native = parameter_string.substr(switch_start);
     } else {
       switch_native = parameter_string.substr(
           switch_start, equals_position - switch_start);
       *switch_value = parameter_string.substr(equals_position + 1);
     }
 #if defined(OS_WIN)
     *switch_string = WideToASCII(switch_native);
-    Lowercase(switch_string);
 #else
     *switch_string = switch_native;
 #endif
+    Lowercase(switch_string);
 
     return true;
   }
 
   return false;
 }
 
+#if defined(OS_WIN)
+// Lowercase a string for case-insensitivity of switches *on Windows*.
+// Is this desirable? It exists for backwards compatibility on Windows.
+void Lowercase(string* arg) {
+  transform(arg->begin(), arg->end(), arg->begin(), tolower);
+}
+
+CommandLine::StringType Native(const string& string) {
+    return ASCIIToWide(string);
+}
+
+CommandLine::StringType Native(const std::wstring& string) { return string; }
+
+// Quote a string if necessary *on Windows*, such that CommandLineToArgvW() will
+// always process it as a single argument.
+CommandLine::StringType Quote(const CommandLine::StringType& arg) {
+  // We follow the quoting rules of CommandLineToArgvW.
+  // http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
+  if (arg.find_first_of(L" \\\"") == CommandLine::StringType::npos) {
+    // No quoting necessary.
+    return arg;
+  }
+
+  std::wstring out;
+  out.push_back(L'"');
+  for (size_t i = 0; i < arg.size(); ++i) {
+    if (arg[i] == '\\') {
+      // Find the extent of this run of backslashes.
+      size_t start = i, end = start + 1;
+      for (; end < arg.size() && arg[end] == '\\'; ++end)
+        /* empty */;
+      size_t backslash_count = end - start;
+
+      // Backslashes are escapes only if the run is followed by a double quote.
+      // Since we also will end the string with a double quote, we escape for
+      // either a double quote or the end of the string.
+      if (end == arg.size() || arg[end] == '"') {
+        // To quote, we need to output 2x as many backslashes.
+        backslash_count *= 2;
+      }
+      for (size_t j = 0; j < backslash_count; ++j)
+        out.push_back('\\');
+
+      // Advance i to one before the end to balance i++ in loop.
+      i = end - 1;
+    } else if (arg[i] == '"') {
+      out.push_back('\\');
+      out.push_back('"');
+    } else {
+      out.push_back(arg[i]);
+    }
+  }
+  out.push_back('"');
+
+  return out;
+}
+#elif defined(OS_POSIX)
+void Lowercase(string* arg) {}
+
+CommandLine::StringType Native(const string& string) { return string; }
+
+CommandLine::StringType Native(const std::wstring& string) {
+  return WideToASCII(string);
+}
+
+CommandLine::StringType Quote(const CommandLine::StringType& string) {
+  return string;
+}
+#endif
+}  // namespace
+
+CommandLine::CommandLine(NoProgram no_program) {
+  SetProgram(StringType());
+}
+
+CommandLine::CommandLine(const FilePath& program) {
+  SetProgram(program.value());
+}
+
+CommandLine::CommandLine(int argc, const CommandLine::CharType* const* argv) {
+  InitFromArgv(argc, argv);
+}
+
+CommandLine::CommandLine(const StringVector& argv) {
+  InitFromArgv(argv);
+}
+
 // static
 void CommandLine::Init(int argc, const char* const* argv) {
   delete current_process_commandline_;
   current_process_commandline_ = new CommandLine;
 #if defined(OS_WIN)
   current_process_commandline_->ParseFromString(::GetCommandLineW());
 #elif defined(OS_POSIX)
   current_process_commandline_->InitFromArgv(argc, argv);
 #endif
 }
 
+// static
 void CommandLine::Reset() {
-  DCHECK(current_process_commandline_ != NULL);
+  DCHECK(current_process_commandline_);
   delete current_process_commandline_;
   current_process_commandline_ = NULL;
 }
 
 // static
 CommandLine* CommandLine::ForCurrentProcess() {
   DCHECK(current_process_commandline_);
   return current_process_commandline_;
 }
 
-bool CommandLine::HasSwitch(const std::string& switch_string) const {
+#if defined(OS_WIN)
+// static
+CommandLine CommandLine::FromString(
+    const CommandLine::StringType& command_line) {
+  CommandLine cmd;
+  cmd.ParseFromString(command_line);
+  return cmd;
+}
+#endif
+
+void CommandLine::InitFromArgv(int argc,
+    const CommandLine::CharType* const* argv) {
+  StringVector new_argv;
+  for (int i = 0; i < argc; ++i)
+    new_argv.push_back(Native(argv[i]));
+  InitFromArgv(new_argv);
+}
+
+void CommandLine::InitFromArgv(const StringVector argv) {
+  argv_.clear();
+  divider_ = 0;
+  if (argv.size() <= 0)
+    return;
+
+  // Initialize the first program argument.
+  SetProgram(argv[0]);
+
+  // Copy switches/arguments to our vector, keeping switches before arguments.
+  bool seen_kSwitchTerminator = false;
+  for (size_t i = 1; i < argv.size(); ++i) {
+    StringType arg = argv[i];
+    TrimWhitespace(arg, TRIM_ALL, &arg);
+
+    string switch_string;
+    StringType switch_value;
+    seen_kSwitchTerminator |= arg == kSwitchTerminator;
+    if (!seen_kSwitchTerminator && IsSwitch(arg, &switch_string, &switch_value))
+      AppendSwitchNative(switch_string, switch_value);
+    else
+      AppendArgNative(arg);
+  }
+}
+
+bool CommandLine::HasSwitch(const string& switch_string) const {
   std::string lowercased_switch(switch_string);
-#if defined(OS_WIN)
   Lowercase(&lowercased_switch);
-#endif
   return switches_.find(lowercased_switch) != switches_.end();
 }
 
-std::string CommandLine::GetSwitchValueASCII(
-    const std::string& switch_string) const {
-  CommandLine::StringType value = GetSwitchValueNative(switch_string);
+string CommandLine::GetSwitchValueASCII(const string& switch_string) const {
+  StringType value = GetSwitchValueNative(switch_string);
   if (!IsStringASCII(value)) {
     LOG(WARNING) << "Value of --" << switch_string << " must be ASCII.";
     return "";
   }
 #if defined(OS_WIN)
   return WideToASCII(value);
 #else
   return value;
 #endif
 }
 
-FilePath CommandLine::GetSwitchValuePath(
-    const std::string& switch_string) const {
+FilePath CommandLine::GetSwitchValuePath(const string& switch_string) const {
   return FilePath(GetSwitchValueNative(switch_string));
 }
 
 CommandLine::StringType CommandLine::GetSwitchValueNative(
-    const std::string& switch_string) const {
+    const string& switch_string) const {
   std::string lowercased_switch(switch_string);
-#if defined(OS_WIN)
   Lowercase(&lowercased_switch);
-#endif
+  SwitchMap::const_iterator result = switches_.find(lowercased_switch);
+  return result == switches_.end() ? StringType() : result->second;
+}
 
-  std::map<std::string, StringType>::const_iterator result =
-      switches_.find(lowercased_switch);
+size_t CommandLine::GetSwitchCount() const {
+  return switches_.size();
+}
 
-  if (result == switches_.end()) {
-    return CommandLine::StringType();
-  } else {
-    return result->second;
-  }
+CommandLine::StringVector CommandLine::args() const {
+  // Gather all arguments after the last switch (may include kSwitchTerminator).
+  StringVector args(argv_.begin() + divider_, argv_.end());
+
+  // Erase only the first kSwitchTerminator (maybe "--" is a legitimate page?)
+  StringVector::iterator it = args.begin();
+  for (; it < args.end() && *it != kSwitchTerminator; ++it)
+    /* empty */;
+  if (it != args.end())
+    args.erase(it);
+
+  return args;
+}
+
+CommandLine::StringType CommandLine::command_line_string() const {
+  return JoinString(argv_, FILE_PATH_LITERAL(' '));
 }
 
 FilePath CommandLine::GetProgram() const {
 #if defined(OS_WIN)
-  return FilePath(program_);
-#else
-  DCHECK_GT(argv_.size(), 0U);
-  return FilePath(argv_[0]);
+  // Ensure that quotes are not returned from GetProgram().
+  // TODO(evanm): proper quoting/handling here.
+  return FilePath(argv_.size() > 0 ? argv_[0].substr(1, argv_[0].size() - 2) :
+      StringType());
+#endif
+  return FilePath(argv_.size() > 0 ? argv_[0] : StringType());
+}
+
+void CommandLine::SetProgram(const CommandLine::StringType& program) {
+  CommandLine::StringType program_string(program);
+  TrimWhitespace(program_string, TRIM_ALL, &program_string);
+
+#if defined(OS_WIN)
+  // TODO(evanm): proper quoting here.
+  if (!program_string.empty())
+    program_string = L'"' + program + L'"';
+#endif
+
+  if (argv_.size() > 0){
+    argv_[0] = program_string;
+  } else {
+    argv_.push_back(program_string);
+    divider_ = 1;
+  }
+}
+
+void CommandLine::AppendSwitch(const string& switch_string) {
+  AppendSwitchNative(switch_string, CommandLine::StringType());
+}
+
+void CommandLine::AppendSwitchPath(const string& switch_string,
+                                   const FilePath& path) {
+  AppendSwitchNative(switch_string, path.value());
+}
+
+void CommandLine::AppendSwitchNative(const string& switch_string,
+                                     const CommandLine::StringType& value) {
+  CommandLine::StringType combined = kSwitchPrefixes[0] + Native(switch_string);
+  if (!value.empty())
+    combined += kSwitchValueSeparator + Quote(value);
+  // Append the switch and update the switches/arguments |divider_|.
+  argv_.insert(argv_.begin() + divider_++, combined);
+  switches_[switch_string] = value;
+}
+
+void CommandLine::AppendSwitchASCII(const string& switch_string,
+                                    const string& value_string) {
+  AppendSwitchNative(switch_string, Native(value_string));
+}
+
+void CommandLine::AppendSwitches(const CommandLine& other) {
+  SwitchMap::const_iterator i;
+  for (i = other.switches_.begin(); i != other.switches_.end(); ++i)
+    AppendSwitchNative(i->first, i->second);
+}
+
+void CommandLine::AppendArg(const string& value) {
+#if defined(OS_WIN)
+  DCHECK(IsStringUTF8(value));
+  AppendArgNative(UTF8ToWide(value));
+#elif defined(OS_POSIX)
+  AppendArgNative(value);
 #endif
 }
 
-#if defined(OS_POSIX)
-std::string CommandLine::command_line_string() const {
-  return JoinString(argv_, ' ');
-}
-#endif
-
-#if defined(OS_WIN)
-void CommandLine::AppendSwitch(const std::string& switch_string) {
-  command_line_string_.append(L" ");
-  command_line_string_.append(kSwitchPrefixes[0] + ASCIIToWide(switch_string));
-  switches_[switch_string] = L"";
+void CommandLine::AppendArgPath(const FilePath& path) {
+  AppendArgNative(path.value());
 }
 
-void CommandLine::AppendSwitchASCII(const std::string& switch_string,
-                                    const std::string& value_string) {
-  AppendSwitchNative(switch_string, ASCIIToWide(value_string));
-}
-
-// Quote a string if necessary, such that CommandLineToArgvW() will
-// always process it as a single argument.
-static std::wstring WindowsStyleQuote(const std::wstring& arg) {
-  // We follow the quoting rules of CommandLineToArgvW.
-  // http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
-  if (arg.find_first_of(L" \\\"") == std::wstring::npos) {
-    // No quoting necessary.
-    return arg;
-  }
-
-  std::wstring out;
-  out.push_back(L'"');
-  for (size_t i = 0; i < arg.size(); ++i) {
-    if (arg[i] == '\\') {
-      // Find the extent of this run of backslashes.
-      size_t start = i, end = start + 1;
-      for (; end < arg.size() && arg[end] == '\\'; ++end)
-        /* empty */;
-      size_t backslash_count = end - start;
-
-      // Backslashes are escapes only if the run is followed by a double quote.
-      // Since we also will end the string with a double quote, we escape for
-      // either a double quote or the end of the string.
-      if (end == arg.size() || arg[end] == '"') {
-        // To quote, we need to output 2x as many backslashes.
-        backslash_count *= 2;
-      }
-      for (size_t j = 0; j < backslash_count; ++j)
-        out.push_back('\\');
-
-      // Advance i to one before the end to balance i++ in loop.
-      i = end - 1;
-    } else if (arg[i] == '"') {
-      out.push_back('\\');
-      out.push_back('"');
-    } else {
-      out.push_back(arg[i]);
-    }
-  }
-  out.push_back('"');
-
-  return out;
-}
-
-void CommandLine::AppendSwitchNative(const std::string& switch_string,
-                                     const std::wstring& value) {
-  std::wstring combined_switch_string =
-      kSwitchPrefixes[0] + ASCIIToWide(switch_string);
-  if (!value.empty())
-    combined_switch_string += kSwitchValueSeparator + WindowsStyleQuote(value);
-
-  command_line_string_.append(L" ");
-  command_line_string_.append(combined_switch_string);
-
-  switches_[switch_string] = value;
-}
-
-void CommandLine::AppendArg(const std::string& value) {
+void CommandLine::AppendArgNative(const CommandLine::StringType& value) {
+#if defined(OS_POSIX)
   DCHECK(IsStringUTF8(value));
-  AppendArgNative(UTF8ToWide(value));
-}
-
-void CommandLine::AppendArgNative(const std::wstring& value) {
-  command_line_string_.append(L" ");
-  command_line_string_.append(WindowsStyleQuote(value));
-  args_.push_back(value);
+#endif
+  argv_.push_back(Quote(value));
 }
 
 void CommandLine::AppendArguments(const CommandLine& other,
                                   bool include_program) {
   // Verify include_program is used correctly.
-  // Logic could be shorter but this is clearer.
-  DCHECK_EQ(include_program, !other.GetProgram().empty());
+  DCHECK(!include_program || other.argv_.size() > 0);
   if (include_program)
-    program_ = other.program_;
+    SetProgram(other.GetProgram().value());
 
-  if (!command_line_string_.empty())
-    command_line_string_ += L' ';
+  // Copy switches/arguments to our vector, keeping switches before arguments.
+  bool seen_kSwitchTerminator = false;
+  for (size_t i = 1; i < other.argv_.size(); ++i) {
+    StringType arg = other.argv_[i];
+    TrimWhitespace(arg, TRIM_ALL, &arg);
 
-  command_line_string_ += other.command_line_string_;
-
-  std::map<std::string, StringType>::const_iterator i;
-  for (i = other.switches_.begin(); i != other.switches_.end(); ++i)
-    switches_[i->first] = i->second;
+    string switch_string;
+    StringType switch_value;
+    seen_kSwitchTerminator |= arg == kSwitchTerminator;
+    if (!seen_kSwitchTerminator && IsSwitch(arg, &switch_string, &switch_value))
+      AppendSwitchNative(switch_string, switch_value);
+    else
+      AppendArgNative(arg);
+  }
 }
 
-void CommandLine::PrependWrapper(const std::wstring& wrapper) {
+void CommandLine::PrependWrapper(const StringType& wrapper) {
   if (wrapper.empty())
     return;
   // The wrapper may have embedded arguments (like "gdb --args"). In this case,
   // we don't pretend to do anything fancy, we just split on spaces.
-  std::vector<std::wstring> wrapper_and_args;
-  base::SplitString(wrapper, ' ', &wrapper_and_args);
-  program_ = wrapper_and_args[0];
-  command_line_string_ = wrapper + L" " + command_line_string_;
-}
-
-#elif defined(OS_POSIX)
-void CommandLine::AppendSwitch(const std::string& switch_string) {
-  argv_.push_back(kSwitchPrefixes[0] + switch_string);
-  switches_[switch_string] = "";
-}
-
-void CommandLine::AppendSwitchNative(const std::string& switch_string,
-                                     const std::string& value) {
-  std::string combined_switch_string = kSwitchPrefixes[0] + switch_string;
-  if (!value.empty())
-    combined_switch_string += kSwitchValueSeparator + value;
-  argv_.push_back(combined_switch_string);
-  switches_[switch_string] = value;
-}
-
-void CommandLine::AppendSwitchASCII(const std::string& switch_string,
-                                    const std::string& value_string) {
-  AppendSwitchNative(switch_string, value_string);
-}
-
-void CommandLine::AppendArg(const std::string& value) {
-  AppendArgNative(value);
-}
-
-void CommandLine::AppendArgNative(const std::string& value) {
-  DCHECK(IsStringUTF8(value));
-  argv_.push_back(value);
-}
-
-void CommandLine::AppendArguments(const CommandLine& other,
-                                  bool include_program) {
-  // Verify include_program is used correctly.
-  // Logic could be shorter but this is clearer.
-  DCHECK_EQ(include_program, !other.GetProgram().empty());
-
-  if (include_program)
-    argv_[0] = other.argv_[0];
-
-  // Skip the first arg when copying since it's the program but push all
-  // arguments to our arg vector.
-  for (size_t i = 1; i < other.argv_.size(); ++i)
-    argv_.push_back(other.argv_[i]);
-
-  std::map<std::string, StringType>::const_iterator i;
-  for (i = other.switches_.begin(); i != other.switches_.end(); ++i)
-    switches_[i->first] = i->second;
-}
-
-void CommandLine::PrependWrapper(const std::string& wrapper) {
-  // The wrapper may have embedded arguments (like "gdb --args"). In this case,
-  // we don't pretend to do anything fancy, we just split on spaces.
-  std::vector<std::string> wrapper_and_args;
-  base::SplitString(wrapper, ' ', &wrapper_and_args);
-  argv_.insert(argv_.begin(), wrapper_and_args.begin(), wrapper_and_args.end());
-}
-
-#endif
-
-void CommandLine::AppendArgPath(const FilePath& path) {
-  AppendArgNative(path.value());
-}
-
-void CommandLine::AppendSwitchPath(const std::string& switch_string,
-                                   const FilePath& path) {
-  AppendSwitchNative(switch_string, path.value());
+  StringVector prefix;
+  base::SplitString(wrapper, FILE_PATH_LITERAL(' '), &prefix);
+  // Prepend the wrapper and update the switches/arguments |divider_|.
+  argv_.insert(argv_.begin(), prefix.begin(), prefix.end());
+  divider_ += prefix.size();
 }
 
 void CommandLine::CopySwitchesFrom(const CommandLine& source,
                                    const char* const switches[],
                                    size_t count) {
   for (size_t i = 0; i < count; ++i) {
     if (source.HasSwitch(switches[i])) {
       StringType value = source.GetSwitchValueNative(switches[i]);
       AppendSwitchNative(switches[i], value);
     }
   }
 }
 
-// private
-CommandLine::CommandLine() {
+#if defined(OS_WIN)
+void CommandLine::ParseFromString(const CommandLine::StringType& command_line) {
+  StringType command_line_string;
+  TrimWhitespace(command_line, TRIM_ALL, &command_line_string);
+  if (command_line_string.empty())
+    return;
+
+  int argc = 0;
+  wchar_t** argv = NULL;
+  argv = ::CommandLineToArgvW(command_line_string.c_str(), &argc);
+
+  CHECK(argv);
+  InitFromArgv(argc, argv);
+  LocalFree(argv);
 }
-
-// static
-CommandLine* CommandLine::ForCurrentProcessMutable() {
-  DCHECK(current_process_commandline_);
-  return current_process_commandline_;
-}
+#endif