The Tor Browser: ipc/chromium/src/base/command_line.cc@6474c204b198 (annotated)

ipc/chromium/src/base/command_line.cc@6474c204b198 (annotated)

ipc/chromium/src/base/command_line.cc

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // 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 "base/command_line.h"
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif
 #include <algorithm>
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 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.
 #if defined(OS_WIN)
 const wchar_t* const kSwitchPrefixes[] = {L"--", L"-", L"/"};
 const wchar_t kSwitchTerminator[] = L"--";
 const wchar_t kSwitchValueSeparator[] = L"=";
 #elif defined(OS_POSIX)
 // Unixes don't use slash as a switch.
 const char* const kSwitchPrefixes[] = {"--", "-"};
 const char kSwitchTerminator[] = "--";
 const char kSwitchValueSeparator[] = "=";
 #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::wstring* parameter) {
   transform(parameter->begin(), parameter->end(), parameter->begin(),
             tolower);
 }
 #endif
 #if defined(OS_WIN)
 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) {
       loose_values_.push_back(arg);
       continue;
     }
     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 {
       loose_values_.push_back(arg);
     }
   }
   if (args)
     LocalFree(args);
 }
 CommandLine::CommandLine(const std::wstring& program) {
   if (!program.empty()) {
     program_ = program;
     command_line_string_ = L'"' + program + L'"';
   }
 }
 #elif defined(OS_POSIX)
 CommandLine::CommandLine(int argc, const char* const* argv) {
   for (int i = 0; i < argc; ++i)
     argv_.push_back(argv[i]);
   InitFromArgv();
 }
 CommandLine::CommandLine(const std::vector<std::string>& argv) {
   argv_ = argv;
   InitFromArgv();
 }
 void CommandLine::InitFromArgv() {
   bool parse_switches = true;
   for (size_t i = 1; i < argv_.size(); ++i) {
     const std::string& arg = argv_[i];
     if (!parse_switches) {
       loose_values_.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 {
       loose_values_.push_back(arg);
     }
   }
 }
 CommandLine::CommandLine(const std::wstring& program) {
   argv_.push_back(WideToASCII(program));
 }
 #endif
 // static
 bool CommandLine::IsSwitch(const StringType& parameter_string,
                            std::string* switch_string,
                            StringType* switch_value) {
   switch_string->clear();
   switch_value->clear();
   for (size_t i = 0; i < arraysize(kSwitchPrefixes); ++i) {
     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) {
       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)
     Lowercase(&switch_native);
     *switch_string = WideToASCII(switch_native);
 #else
     *switch_string = switch_native;
 #endif
     return true;
   }
   return false;
 }
 // static
 void CommandLine::Init(int argc, const char* const* argv) {
   DCHECK(current_process_commandline_ == NULL);
 #if defined(OS_WIN)
   current_process_commandline_ = new CommandLine;
   current_process_commandline_->ParseFromString(::GetCommandLineW());
 #elif defined(OS_POSIX)
   current_process_commandline_ = new CommandLine(argc, argv);
 #endif
 }
 void CommandLine::Terminate() {
   DCHECK(current_process_commandline_ != NULL);
   delete current_process_commandline_;
   current_process_commandline_ = NULL;
 }
 bool CommandLine::HasSwitch(const std::wstring& switch_string) const {
   std::wstring lowercased_switch(switch_string);
 #if defined(OS_WIN)
   Lowercase(&lowercased_switch);
 #endif
   return switches_.find(WideToASCII(lowercased_switch)) != switches_.end();
 }
 std::wstring CommandLine::GetSwitchValue(
     const std::wstring& switch_string) const {
   std::wstring lowercased_switch(switch_string);
 #if defined(OS_WIN)
   Lowercase(&lowercased_switch);
 #endif
   std::map<std::string, StringType>::const_iterator result =
       switches_.find(WideToASCII(lowercased_switch));
   if (result == switches_.end()) {
     return L"";
   } else {
 #if defined(OS_WIN)
     return result->second;
 #else
     return ASCIIToWide(result->second);
 #endif
   }
 }
 #if defined(OS_WIN)
 std::vector<std::wstring> CommandLine::GetLooseValues() const {
   return loose_values_;
 }
 std::wstring CommandLine::program() const {
   return program_;
 }
 #else
 std::vector<std::wstring> CommandLine::GetLooseValues() const {
   std::vector<std::wstring> values;
   for (size_t i = 0; i < loose_values_.size(); ++i)
     values.push_back(ASCIIToWide(loose_values_[i]));
   return values;
 }
 std::wstring CommandLine::program() const {
   DCHECK(argv_.size() > 0);
   return ASCIIToWide(argv_[0]);
 }
 #endif
 // static
 std::wstring CommandLine::PrefixedSwitchString(
     const std::wstring& switch_string) {
   return StringPrintf(L"%ls%ls",
                       kSwitchPrefixes[0],
                       switch_string.c_str());
 }
 // static
 std::wstring CommandLine::PrefixedSwitchStringWithValue(
     const std::wstring& switch_string, const std::wstring& value_string) {
   if (value_string.empty()) {
     return PrefixedSwitchString(switch_string);
   }
   return StringPrintf(L"%ls%ls%ls%ls",
                       kSwitchPrefixes[0],
                       switch_string.c_str(),
                       kSwitchValueSeparator,
                       value_string.c_str());
 }
 #if defined(OS_WIN)
 void CommandLine::AppendSwitch(const std::wstring& switch_string) {
   std::wstring prefixed_switch_string = PrefixedSwitchString(switch_string);
   command_line_string_.append(L" ");
   command_line_string_.append(prefixed_switch_string);
   switches_[WideToASCII(switch_string)] = L"";
 }
 // 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" \\\"\t") == 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::AppendSwitchWithValue(const std::wstring& switch_string,
                                         const std::wstring& value_string) {
   std::wstring quoted_value_string = WindowsStyleQuote(value_string);
   std::wstring combined_switch_string =
     PrefixedSwitchStringWithValue(switch_string, quoted_value_string);
   command_line_string_.append(L" ");
   command_line_string_.append(combined_switch_string);
   switches_[WideToASCII(switch_string)] = value_string;
 }
 void CommandLine::AppendLooseValue(const std::wstring& value) {
   command_line_string_.append(L" ");
   command_line_string_.append(WindowsStyleQuote(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(include_program ? !other.program().empty() : other.program().empty());
   command_line_string_ += L" " + 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;
 }
 void CommandLine::PrependWrapper(const std::wstring& 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::wstring> wrapper_and_args;
   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::wstring& switch_string) {
   std::string ascii_switch = WideToASCII(switch_string);
   argv_.push_back(kSwitchPrefixes[0] + ascii_switch);
   switches_[ascii_switch] = "";
 }
 void CommandLine::AppendSwitchWithValue(const std::wstring& switch_string,
                                         const std::wstring& value_string) {
   std::string ascii_switch = WideToASCII(switch_string);
   std::string ascii_value = WideToASCII(value_string);
   argv_.push_back(kSwitchPrefixes[0] + ascii_switch +
                   kSwitchValueSeparator + ascii_value);
   switches_[ascii_switch] = ascii_value;
 }
 void CommandLine::AppendLooseValue(const std::wstring& value) {
   argv_.push_back(WideToASCII(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(include_program ? !other.program().empty() : other.program().empty());
   size_t first_arg = include_program ? 0 : 1;
   for (size_t i = first_arg; 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::wstring& wrapper_wide) {
   // 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 = WideToASCII(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

The Tor Browser / annotate

ipc/chromium/src/base/command_line.cc@6474c204b198 (annotated)

ipc/chromium/src/base/command_line.cc