CommandLine: add a CopySwitchesFrom() for copying from another CommandLine

base/command_line.cc

 // Copyright (c) 2010 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"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #elif defined(OS_POSIX)
@@ skipping 273 matching lines @@
   return HasSwitch(WideToASCII(switch_string));
 }
 
 std::string CommandLine::GetSwitchValueASCII(
     const std::string& switch_string) const {
   return WideToASCII(GetSwitchValue(switch_string));
 }
 
 FilePath CommandLine::GetSwitchValuePath(
     const std::string& switch_string) const {
-  return FilePath::FromWStringHack(GetSwitchValue(switch_string));
+  return FilePath(GetSwitchValueNative(switch_string));
 }
 
-std::wstring CommandLine::GetSwitchValue(
+CommandLine::StringType CommandLine::GetSwitchValueNative(
     const std::string& switch_string) const {
   std::string lowercased_switch(switch_string);
 #if defined(OS_WIN)
   Lowercase(&lowercased_switch);
 #endif
 
   std::map<std::string, StringType>::const_iterator result =
       switches_.find(lowercased_switch);
 
   if (result == switches_.end()) {
-    return L"";
+    return CommandLine::StringType();
   } else {
-#if defined(OS_WIN)
     return result->second;
-#else
-    return base::SysNativeMBToWide(result->second);
-#endif
   }
 }
 
 std::wstring CommandLine::GetSwitchValue(
+    const std::string& switch_string) const {
+  // TODO(evanm): deprecate.
+  CommandLine::StringType value = GetSwitchValueNative(switch_string);
+#if defined(OS_WIN)
+  return value;
+#else
+  return base::SysNativeMBToWide(value);
+#endif
+}
+
+std::wstring CommandLine::GetSwitchValue(
     const std::wstring& switch_string) const {
+  // TODO(evanm): deprecate.
   return GetSwitchValue(WideToASCII(switch_string));
 }
 
 FilePath CommandLine::GetProgram() const {
   return FilePath::FromWStringHack(program());
 }
 
 #if defined(OS_WIN)
 std::wstring CommandLine::program() const {
   return program_;
@@ skipping 40 matching lines @@
 #if defined(OS_WIN)
 void CommandLine::AppendSwitch(const std::string& switch_string) {
   std::wstring prefixed_switch_string = PrefixedSwitchString(switch_string);
   command_line_string_.append(L" ");
   command_line_string_.append(prefixed_switch_string);
   switches_[switch_string] = L"";
 }
 
 void CommandLine::AppendSwitchWithValue(const std::string& switch_string,
                                         const std::wstring& value_string) {
+  AppendSwitchNative(switch_string, value_string);
+}
+
+void CommandLine::AppendSwitchNative(const std::string& switch_string,
+                                     const std::wstring& value_string) {
   std::wstring value_string_edit;
 
   // NOTE(jhughes): If the value contains a quotation mark at one
   //                end but not both, you may get unusable output.
   if (!value_string.empty() &&
       (value_string.find(L" ") != std::wstring::npos) &&
       (value_string[0] != L'"') &&
       (value_string[value_string.length() - 1] != L'"')) {
     // need to provide quotes
     value_string_edit = StringPrintf(L"\"%ls\"", value_string.c_str());
@@ skipping 36 matching lines @@
   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) {
+  argv_.push_back(kSwitchPrefixes[0] + switch_string +
+                  kSwitchValueSeparator + value);
+  switches_[switch_string] = value;
+}
+
 void CommandLine::AppendSwitchWithValue(const std::string& switch_string,
                                         const std::wstring& value_string) {
+  // TODO(evanm): deprecate.
   std::string mb_value = base::SysWideToNativeMB(value_string);
-
-  argv_.push_back(kSwitchPrefixes[0] + switch_string +
-                  kSwitchValueSeparator + mb_value);
-  switches_[switch_string] = mb_value;
+  AppendSwitchNative(switch_string, mb_value);
 }
 
 void CommandLine::AppendLooseValue(const std::wstring& value) {
   argv_.push_back(base::SysWideToNativeMB(value));
 }
 
 void CommandLine::AppendArguments(const CommandLine& other,
                                   bool include_program) {
   // Verify include_program is used correctly.
   // Logic could be shorter but this is clearer.
@@ skipping 10 matching lines @@
   // 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.
   const std::string wrapper = base::SysWideToNativeMB(wrapper_wide);
   std::vector<std::string> wrapper_and_args;
   SplitString(wrapper, ' ', &wrapper_and_args);
   argv_.insert(argv_.begin(), wrapper_and_args.begin(), wrapper_and_args.end());
 }
 
 #endif
 
+void CommandLine::AppendSwitchPath(const std::string& switch_string,
+                                   const FilePath& path) {
+  AppendSwitchNative(switch_string, path.value());
+}
+
 void CommandLine::AppendSwitchWithValue(const std::string& switch_string,
                                         const std::string& value_string) {
   AppendSwitchWithValue(switch_string, ASCIIToWide(value_string));
 }
 
+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() {
 }