Add read-only mode to CommandLine that optimizes HasSwitch(const char*).

base/command_line.cc

 // Copyright (c) 2012 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 <cstring>
 #include <ostream>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 
@@ skipping 68 matching lines @@
                                        switch_value);
 #elif defined(OS_POSIX)
       command_line->AppendSwitchNative(switch_string, switch_value);
 #endif
     } else {
       command_line->AppendArgNative(arg);
     }
   }
 }
 
+bool ContainsUpperASCII(const char* string) {
+  for (; *string; ++string) {
+    if (*string >= 'A' && *string <= 'Z')
+      return true;
+  }
+  return false;
+}
+
 // Lowercase switches for backwards compatiblity *on Windows*.
 #if defined(OS_WIN)
 std::string LowerASCIIOnWindows(const std::string& string) {
   return StringToLowerASCII(string);
 }
 #elif defined(OS_POSIX)
 const std::string& LowerASCIIOnWindows(const std::string& string) {
   return string;
 }
 #endif
 
+// Comparator usable by std::lower_bound().
+bool CompareStringAndCharPtr(const std::string& s, const char* c) {
+  return strcmp(s.c_str(), c) <= 0;
+}
 
 #if defined(OS_WIN)
 // Quote a string as necessary for CommandLineToArgvW compatiblity *on Windows*.
 string16 QuoteForCommandLineToArgvW(const string16& arg,
                                     bool quote_placeholders) {
   // We follow the quoting rules of CommandLineToArgvW.
   // http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
   string16 quotable_chars(L" \\\"");
   // We may also be required to quote '%', which is commonly used in a command
   // line as a placeholder. (It may be substituted for a string with spaces.)
@@ skipping 34 matching lines @@
   }
   out.push_back('"');
 
   return out;
 }
 #endif
 
 }  // namespace
 
 CommandLine::CommandLine(NoProgram no_program)
-    : argv_(1),
-      begin_args_(1) {
+    : argv_(1), begin_args_(1), writeable_(true) {
 }
 
 CommandLine::CommandLine(const FilePath& program)
-    : argv_(1),
-      begin_args_(1) {
+    : argv_(1), begin_args_(1), writeable_(true) {
   SetProgram(program);
 }
 
 CommandLine::CommandLine(int argc, const CommandLine::CharType* const* argv)
-    : argv_(1),
-      begin_args_(1) {
+    : argv_(1), begin_args_(1), writeable_(true) {
   InitFromArgv(argc, argv);
 }
 
 CommandLine::CommandLine(const StringVector& argv)
-    : argv_(1),
-      begin_args_(1) {
+    : argv_(1), begin_args_(1), writeable_(true) {
   InitFromArgv(argv);
 }
 
 CommandLine::~CommandLine() {
 }
 
 #if defined(OS_WIN)
 // static
 void CommandLine::set_slash_is_not_a_switch() {
   // The last switch prefix should be slash, so adjust the size to skip it.
@@ skipping 10 matching lines @@
     // shared libraries.
     return false;
   }
 
   current_process_commandline_ = new CommandLine(NO_PROGRAM);
 #if defined(OS_WIN)
   current_process_commandline_->ParseFromString(::GetCommandLineW());
 #elif defined(OS_POSIX)
   current_process_commandline_->InitFromArgv(argc, argv);
 #endif
+  current_process_commandline_->MakeReadOnly();
 
   return true;
 }
 
 // static
 void CommandLine::Reset() {
   DCHECK(current_process_commandline_);
   delete current_process_commandline_;
   current_process_commandline_ = NULL;
 }
@@ skipping 13 matching lines @@
 // static
 CommandLine CommandLine::FromString(const string16& command_line) {
   CommandLine cmd(NO_PROGRAM);
   cmd.ParseFromString(command_line);
   return cmd;
 }
 #endif
 
 void CommandLine::InitFromArgv(int argc,
                                const CommandLine::CharType* const* argv) {
+  DCHECK(writeable_);
   StringVector new_argv;
   for (int i = 0; i < argc; ++i)
     new_argv.push_back(argv[i]);
   InitFromArgv(new_argv);
 }
 
 void CommandLine::InitFromArgv(const StringVector& argv) {
+  DCHECK(writeable_);
   argv_ = StringVector(1);
   switches_.clear();
   begin_args_ = 1;
   SetProgram(argv.empty() ? FilePath() : FilePath(argv[0]));
   AppendSwitchesAndArguments(this, argv);
 }
 
 FilePath CommandLine::GetProgram() const {
   return FilePath(argv_[0]);
 }
 
 void CommandLine::SetProgram(const FilePath& program) {
+  DCHECK(writeable_);
   TrimWhitespace(program.value(), TRIM_ALL, &argv_[0]);
 }
 
 bool CommandLine::HasSwitch(const std::string& switch_string) const {
-  return switches_.find(LowerASCIIOnWindows(switch_string)) != switches_.end();
+#if defined(OS_WIN)
+  if (ContainsUpperASCII(switch_string.c_str()))
+    return switches_.find(LowerASCIIOnWindows(switch_string)) !=
+           switches_.end();
+#endif
+
+  return switches_.find(switch_string) != switches_.end();
 }
 
 bool CommandLine::HasSwitch(const char string_constant[]) const {
-  return HasSwitch(std::string(string_constant));
+  DCHECK(!ContainsUpperASCII(string_constant));
+  return writeable_ ? HasSwitchLowerCase(string_constant)
+                    : HasSwitchVector(string_constant);
 }
 
 std::string CommandLine::GetSwitchValueASCII(
     const std::string& switch_string) const {
   StringType value = GetSwitchValueNative(switch_string);
   if (!IsStringASCII(value)) {
     DLOG(WARNING) << "Value of switch (" << switch_string << ") must be ASCII.";
     return std::string();
   }
 #if defined(OS_WIN)
   return UTF16ToASCII(value);
 #else
   return value;
 #endif
 }
 
 FilePath CommandLine::GetSwitchValuePath(
     const std::string& switch_string) const {
   return FilePath(GetSwitchValueNative(switch_string));
 }
 
 CommandLine::StringType CommandLine::GetSwitchValueNative(
     const std::string& switch_string) const {
-  SwitchMap::const_iterator result =
-    switches_.find(LowerASCIIOnWindows(switch_string));
+#if defined(OS_WIN)
+  if (ContainsUpperASCII(switch_string.c_str())) {
+    SwitchMap::const_iterator result =
+        switches_.find(LowerASCIIOnWindows(switch_string));
+    return result == switches_.end() ? StringType() : result->second;
+  }
+#endif
+
+  SwitchMap::const_iterator result = switches_.find(switch_string);
   return result == switches_.end() ? StringType() : result->second;
 }
 
 void CommandLine::AppendSwitch(const std::string& switch_string) {
   AppendSwitchNative(switch_string, StringType());
 }
 
 void CommandLine::AppendSwitchPath(const std::string& switch_string,
                                    const FilePath& path) {
   AppendSwitchNative(switch_string, path.value());
 }
 
 void CommandLine::AppendSwitchNative(const std::string& switch_string,
                                      const CommandLine::StringType& value) {
+  DCHECK(writeable_);
   std::string switch_key(LowerASCIIOnWindows(switch_string));
 #if defined(OS_WIN)
   StringType combined_switch_string(ASCIIToUTF16(switch_key));
 #elif defined(OS_POSIX)
   StringType combined_switch_string(switch_string);
 #endif
   size_t prefix_length = GetSwitchPrefixLength(combined_switch_string);
   switches_[switch_key.substr(prefix_length)] = value;
   // Preserve existing switch prefixes in |argv_|; only append one if necessary.
   if (prefix_length == 0)
     combined_switch_string = kSwitchPrefixes[0] + combined_switch_string;
   if (!value.empty())
     combined_switch_string += kSwitchValueSeparator + value;
   // Append the switch and update the switches/arguments divider |begin_args_|.
   argv_.insert(argv_.begin() + begin_args_++, combined_switch_string);
 }
 
 void CommandLine::AppendSwitchASCII(const std::string& switch_string,
                                     const std::string& value_string) {
+  DCHECK(writeable_);
 #if defined(OS_WIN)
   AppendSwitchNative(switch_string, ASCIIToUTF16(value_string));
 #elif defined(OS_POSIX)
   AppendSwitchNative(switch_string, value_string);
 #endif
 }
 
 void CommandLine::CopySwitchesFrom(const CommandLine& source,
                                    const char* const switches[],
                                    size_t count) {
+  DCHECK(writeable_);
   for (size_t i = 0; i < count; ++i) {
     if (source.HasSwitch(switches[i]))
       AppendSwitchNative(switches[i], source.GetSwitchValueNative(switches[i]));
   }
 }
 
 CommandLine::StringVector CommandLine::GetArgs() const {
   // Gather all arguments after the last switch (may include kSwitchTerminator).
   StringVector args(argv_.begin() + begin_args_, argv_.end());
   // Erase only the first kSwitchTerminator (maybe "--" is a legitimate page?)
@@ skipping 11 matching lines @@
 #elif defined(OS_POSIX)
   AppendArgNative(value);
 #endif
 }
 
 void CommandLine::AppendArgPath(const FilePath& path) {
   AppendArgNative(path.value());
 }
 
 void CommandLine::AppendArgNative(const CommandLine::StringType& value) {
+  DCHECK(writeable_);
   argv_.push_back(value);
 }
 
 void CommandLine::AppendArguments(const CommandLine& other,
                                   bool include_program) {
+  DCHECK(writeable_);
   if (include_program)
     SetProgram(other.GetProgram());
   AppendSwitchesAndArguments(this, other.argv());
 }
 
 void CommandLine::PrependWrapper(const CommandLine::StringType& wrapper) {
+  DCHECK(writeable_);
   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.
   StringVector wrapper_argv;
   SplitString(wrapper, FILE_PATH_LITERAL(' '), &wrapper_argv);
   // Prepend the wrapper and update the switches/arguments |begin_args_|.
   argv_.insert(argv_.begin(), wrapper_argv.begin(), wrapper_argv.end());
   begin_args_ += wrapper_argv.size();
 }
 
 #if defined(OS_WIN)
 void CommandLine::ParseFromString(const string16& command_line) {
+  DCHECK(writeable_);
   string16 command_line_string;
   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);
 
   DPLOG_IF(FATAL, !args) << "CommandLineToArgvW failed on command line: "
                          << UTF16ToUTF8(command_line);
   InitFromArgv(num_args, args);
   LocalFree(args);
 }
 #endif
 
+void CommandLine::MakeReadOnly() {
+  for (const auto& i : switches_)
+    switch_vector_.push_back(i.first);
+  std::sort(switch_vector_.begin(), switch_vector_.end());
+}
+
 CommandLine::StringType CommandLine::GetCommandLineStringInternal(
     bool quote_placeholders) const {
   StringType string(argv_[0]);
 #if defined(OS_WIN)
   string = QuoteForCommandLineToArgvW(string, quote_placeholders);
 #endif
   StringType params(GetArgumentsStringInternal(quote_placeholders));
   if (!params.empty()) {
     string.append(StringType(FILE_PATH_LITERAL(" ")));
     string.append(params);
@@ skipping 25 matching lines @@
     } else {
 #if defined(OS_WIN)
       arg = QuoteForCommandLineToArgvW(arg, quote_placeholders);
 #endif
       params.append(arg);
     }
   }
   return params;
 }
 
+bool CommandLine::HasSwitchVector(const char string_constant[]) const {
+  DCHECK(!writeable_);
+  auto lb = std::lower_bound(switch_vector_.begin(), switch_vector_.end(),
+                             string_constant, CompareStringAndCharPtr);
+  return lb != switch_vector_.end() && !strcmp(lb->c_str(), string_constant);
+}
+
+bool CommandLine::HasSwitchLowerCase(const char string_constant[]) const {
+  return switches_.find(std::string(string_constant)) != switches_.end();
+}
+
 }  // namespace base