base/ header cleanup. Forward declaration instead of including.

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 86 matching lines @@
       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();
     command_line_string_ = L'"' + program.value() + L'"';
   }
 }
 
 #elif defined(OS_POSIX)
 CommandLine::CommandLine(ArgumentsOnly args_only) {
   // 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) {
@@ skipping 128 matching lines @@
 }
 
 bool CommandLine::HasSwitch(const std::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();
 }
 
+bool CommandLine::HasSwitch(const std::wstring& switch_string) const {
+  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));
+}
+
 std::wstring CommandLine::GetSwitchValue(
     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"";
   } else {
 #if defined(OS_WIN)
     return result->second;
 #else
     return base::SysNativeMBToWide(result->second);
 #endif
   }
 }
 
+std::wstring CommandLine::GetSwitchValue(
+    const std::wstring& switch_string) const {
+  return GetSwitchValue(WideToASCII(switch_string));
+}
+
+FilePath CommandLine::GetProgram() const {
+  return FilePath::FromWStringHack(program());
+}
+
 #if defined(OS_WIN)
 std::wstring CommandLine::program() const {
   return program_;
 }
 #else
 std::wstring CommandLine::program() const {
   DCHECK_GT(argv_.size(), 0U);
   return base::SysNativeMBToWide(argv_[0]);
 }
 #endif
@@ skipping 126 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::AppendSwitchWithValue(const std::string& switch_string,
+                                        const std::string& value_string) {
+  AppendSwitchWithValue(switch_string, ASCIIToWide(value_string));
+}
+
 // private
 CommandLine::CommandLine() {
 }