Use StringPiece more in base::Value interfaces.

base/values.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/values.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 233 matching lines @@
       return GetAsDouble(&lhs) && other->GetAsDouble(&rhs) && lhs == rhs;
     }
     default:
       NOTREACHED();
       return false;
   }
 }
 
 ///////////////////// StringValue ////////////////////
 
-StringValue::StringValue(const std::string& in_value)
-    : Value(TYPE_STRING),
-      value_(in_value) {
+StringValue::StringValue(StringPiece in_value)
+    : Value(TYPE_STRING), value_(in_value.as_string()) {
   DCHECK(IsStringUTF8(in_value));
 }
 
 StringValue::StringValue(const string16& in_value)
     : Value(TYPE_STRING),
       value_(UTF16ToUTF8(in_value)) {
 }
 
 StringValue::~StringValue() {
 }
@@ skipping 102 matching lines @@
     *out_value = this;
   return true;
 }
 
 bool DictionaryValue::GetAsDictionary(const DictionaryValue** out_value) const {
   if (out_value)
     *out_value = this;
   return true;
 }
 
-bool DictionaryValue::HasKey(const std::string& key) const {
+bool DictionaryValue::HasKey(StringPiece key) const {
   DCHECK(IsStringUTF8(key));
-  auto current_entry = dictionary_.find(key);
+  auto current_entry = dictionary_.find(key.as_string());
   DCHECK((current_entry == dictionary_.end()) || current_entry->second);
   return current_entry != dictionary_.end();
 }
 
 void DictionaryValue::Clear() {
   dictionary_.clear();
 }
 
-void DictionaryValue::Set(const std::string& path,
-                          std::unique_ptr<Value> in_value) {
+void DictionaryValue::Set(StringPiece path, std::unique_ptr<Value> in_value) {
   DCHECK(IsStringUTF8(path));
   DCHECK(in_value);
 
-  std::string current_path(path);
+  std::string current_path(path.as_string());
   DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
     // Assume that we're indexing into a dictionary.
     std::string key(current_path, 0, delimiter_position);
     DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
       child_dictionary = new DictionaryValue;
       current_dictionary->SetWithoutPathExpansion(key, child_dictionary);
     }
 
     current_dictionary = child_dictionary;
     current_path.erase(0, delimiter_position + 1);
   }
 
   current_dictionary->SetWithoutPathExpansion(current_path,
                                               std::move(in_value));
 }
 
-void DictionaryValue::Set(const std::string& path, Value* in_value) {
+void DictionaryValue::Set(StringPiece path, Value* in_value) {
   Set(path, WrapUnique(in_value));
 }
 
-void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
+void DictionaryValue::SetBoolean(StringPiece path, bool in_value) {
   Set(path, new FundamentalValue(in_value));
 }
 
-void DictionaryValue::SetInteger(const std::string& path, int in_value) {
+void DictionaryValue::SetInteger(StringPiece path, int in_value) {
   Set(path, new FundamentalValue(in_value));
 }
 
-void DictionaryValue::SetDouble(const std::string& path, double in_value) {
+void DictionaryValue::SetDouble(StringPiece path, double in_value) {
   Set(path, new FundamentalValue(in_value));
 }
 
-void DictionaryValue::SetString(const std::string& path,
-                                const std::string& in_value) {
+void DictionaryValue::SetString(StringPiece path, StringPiece in_value) {
+  Set(path, new StringValue(in_value.as_string()));
+}
+
+void DictionaryValue::SetString(StringPiece path, const string16& in_value) {
   Set(path, new StringValue(in_value));
 }
 
-void DictionaryValue::SetString(const std::string& path,
-                                const string16& in_value) {
-  Set(path, new StringValue(in_value));
+void DictionaryValue::SetWithoutPathExpansion(StringPiece key,
+                                              std::unique_ptr<Value> in_value) {
+  dictionary_[key.as_string()] = std::move(in_value);
 }
 
-void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
-                                              std::unique_ptr<Value> in_value) {
-  dictionary_[key] = std::move(in_value);
-}
-
-void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
+void DictionaryValue::SetWithoutPathExpansion(StringPiece key,
                                               Value* in_value) {
   SetWithoutPathExpansion(key, WrapUnique(in_value));
 }
 
-void DictionaryValue::SetBooleanWithoutPathExpansion(
-    const std::string& path, bool in_value) {
+void DictionaryValue::SetBooleanWithoutPathExpansion(StringPiece path,
+                                                     bool in_value) {
   SetWithoutPathExpansion(path, new FundamentalValue(in_value));
 }
 
-void DictionaryValue::SetIntegerWithoutPathExpansion(
-    const std::string& path, int in_value) {
+void DictionaryValue::SetIntegerWithoutPathExpansion(StringPiece path,
+                                                     int in_value) {
   SetWithoutPathExpansion(path, new FundamentalValue(in_value));
 }
 
-void DictionaryValue::SetDoubleWithoutPathExpansion(
-    const std::string& path, double in_value) {
+void DictionaryValue::SetDoubleWithoutPathExpansion(StringPiece path,
+                                                    double in_value) {
   SetWithoutPathExpansion(path, new FundamentalValue(in_value));
 }
 
-void DictionaryValue::SetStringWithoutPathExpansion(
-    const std::string& path, const std::string& in_value) {
+void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
+                                                    StringPiece in_value) {
+  SetWithoutPathExpansion(path, new StringValue(in_value.as_string()));
+}
+
+void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
+                                                    const string16& in_value) {
   SetWithoutPathExpansion(path, new StringValue(in_value));
 }
 
-void DictionaryValue::SetStringWithoutPathExpansion(
-    const std::string& path, const string16& in_value) {
-  SetWithoutPathExpansion(path, new StringValue(in_value));
-}
-
 bool DictionaryValue::Get(StringPiece path,
                           const Value** out_value) const {
   DCHECK(IsStringUTF8(path));
   StringPiece current_path(path);
   const DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
     const DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionaryWithoutPathExpansion(
             current_path.substr(0, delimiter_position).as_string(),
             &child_dictionary)) {
       return false;
     }
 
     current_dictionary = child_dictionary;
     current_path = current_path.substr(delimiter_position + 1);
   }
 
   return current_dictionary->GetWithoutPathExpansion(current_path.as_string(),
                                                      out_value);
 }
 
 bool DictionaryValue::Get(StringPiece path, Value** out_value)  {
   return static_cast<const DictionaryValue&>(*this).Get(
       path,
       const_cast<const Value**>(out_value));
 }
 
-bool DictionaryValue::GetBoolean(const std::string& path,
-                                 bool* bool_value) const {
+bool DictionaryValue::GetBoolean(StringPiece path, bool* bool_value) const {
   const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsBoolean(bool_value);
 }
 
-bool DictionaryValue::GetInteger(const std::string& path,
-                                 int* out_value) const {
+bool DictionaryValue::GetInteger(StringPiece path, int* out_value) const {
   const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
-bool DictionaryValue::GetDouble(const std::string& path,
-                                double* out_value) const {
+bool DictionaryValue::GetDouble(StringPiece path, double* out_value) const {
   const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsDouble(out_value);
 }
 
-bool DictionaryValue::GetString(const std::string& path,
+bool DictionaryValue::GetString(StringPiece path,
                                 std::string* out_value) const {
   const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
-bool DictionaryValue::GetString(const std::string& path,
-                                string16* out_value) const {
+bool DictionaryValue::GetString(StringPiece path, string16* out_value) const {
   const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
-bool DictionaryValue::GetStringASCII(const std::string& path,
+bool DictionaryValue::GetStringASCII(StringPiece path,
                                      std::string* out_value) const {
   std::string out;
   if (!GetString(path, &out))
     return false;
 
   if (!IsStringASCII(out)) {
     NOTREACHED();
     return false;
   }
 
   out_value->assign(out);
   return true;
 }
 
-bool DictionaryValue::GetBinary(const std::string& path,
+bool DictionaryValue::GetBinary(StringPiece path,
                                 const BinaryValue** out_value) const {
   const Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(TYPE_BINARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<const BinaryValue*>(value);
 
   return true;
 }
 
-bool DictionaryValue::GetBinary(const std::string& path,
-                                BinaryValue** out_value) {
+bool DictionaryValue::GetBinary(StringPiece path, BinaryValue** out_value) {
   return static_cast<const DictionaryValue&>(*this).GetBinary(
       path,
       const_cast<const BinaryValue**>(out_value));
 }
 
 bool DictionaryValue::GetDictionary(StringPiece path,
                                     const DictionaryValue** out_value) const {
   const Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(TYPE_DICTIONARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<const DictionaryValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetDictionary(StringPiece path,
                                     DictionaryValue** out_value) {
   return static_cast<const DictionaryValue&>(*this).GetDictionary(
       path,
       const_cast<const DictionaryValue**>(out_value));
 }
 
-bool DictionaryValue::GetList(const std::string& path,
+bool DictionaryValue::GetList(StringPiece path,
                               const ListValue** out_value) const {
   const Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(TYPE_LIST))
     return false;
 
   if (out_value)
     *out_value = static_cast<const ListValue*>(value);
 
   return true;
 }
 
-bool DictionaryValue::GetList(const std::string& path, ListValue** out_value) {
+bool DictionaryValue::GetList(StringPiece path, ListValue** out_value) {
   return static_cast<const DictionaryValue&>(*this).GetList(
       path,
       const_cast<const ListValue**>(out_value));
 }
 
-bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
+bool DictionaryValue::GetWithoutPathExpansion(StringPiece key,
                                               const Value** out_value) const {
   DCHECK(IsStringUTF8(key));
-  auto entry_iterator = dictionary_.find(key);
+  auto entry_iterator = dictionary_.find(key.as_string());
   if (entry_iterator == dictionary_.end())
     return false;
 
   if (out_value)
     *out_value = entry_iterator->second.get();
   return true;
 }
 
-bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
+bool DictionaryValue::GetWithoutPathExpansion(StringPiece key,
                                               Value** out_value) {
   return static_cast<const DictionaryValue&>(*this).GetWithoutPathExpansion(
       key,
       const_cast<const Value**>(out_value));
 }
 
-bool DictionaryValue::GetBooleanWithoutPathExpansion(const std::string& key,
+bool DictionaryValue::GetBooleanWithoutPathExpansion(StringPiece key,
                                                      bool* out_value) const {
   const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsBoolean(out_value);
 }
 
-bool DictionaryValue::GetIntegerWithoutPathExpansion(const std::string& key,
+bool DictionaryValue::GetIntegerWithoutPathExpansion(StringPiece key,
                                                      int* out_value) const {
   const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
-bool DictionaryValue::GetDoubleWithoutPathExpansion(const std::string& key,
+bool DictionaryValue::GetDoubleWithoutPathExpansion(StringPiece key,
                                                     double* out_value) const {
   const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsDouble(out_value);
 }
 
 bool DictionaryValue::GetStringWithoutPathExpansion(
-    const std::string& key,
+    StringPiece key,
     std::string* out_value) const {
   const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
-bool DictionaryValue::GetStringWithoutPathExpansion(const std::string& key,
+bool DictionaryValue::GetStringWithoutPathExpansion(StringPiece key,
                                                     string16* out_value) const {
   const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
-    const std::string& key,
+    StringPiece key,
     const DictionaryValue** out_value) const {
   const Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
   if (!result || !value->IsType(TYPE_DICTIONARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<const DictionaryValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
-    const std::string& key,
+    StringPiece key,
     DictionaryValue** out_value) {
   const DictionaryValue& const_this =
       static_cast<const DictionaryValue&>(*this);
   return const_this.GetDictionaryWithoutPathExpansion(
           key,
           const_cast<const DictionaryValue**>(out_value));
 }
 
 bool DictionaryValue::GetListWithoutPathExpansion(
-    const std::string& key,
+    StringPiece key,
     const ListValue** out_value) const {
   const Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
   if (!result || !value->IsType(TYPE_LIST))
     return false;
 
   if (out_value)
     *out_value = static_cast<const ListValue*>(value);
 
   return true;
 }
 
-bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
+bool DictionaryValue::GetListWithoutPathExpansion(StringPiece key,
                                                   ListValue** out_value) {
   return
       static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
           key,
           const_cast<const ListValue**>(out_value));
 }
 
-bool DictionaryValue::Remove(const std::string& path,
+bool DictionaryValue::Remove(StringPiece path,
                              std::unique_ptr<Value>* out_value) {
   DCHECK(IsStringUTF8(path));
-  std::string current_path(path);
+  std::string current_path(path.as_string());
   DictionaryValue* current_dictionary = this;
   size_t delimiter_position = current_path.rfind('.');
   if (delimiter_position != std::string::npos) {
     if (!GetDictionary(current_path.substr(0, delimiter_position),
                        &current_dictionary))
       return false;
     current_path.erase(0, delimiter_position + 1);
   }
 
   return current_dictionary->RemoveWithoutPathExpansion(current_path,
                                                         out_value);
 }
 
 bool DictionaryValue::RemoveWithoutPathExpansion(
-    const std::string& key,
+    StringPiece key,
     std::unique_ptr<Value>* out_value) {
   DCHECK(IsStringUTF8(key));
-  auto entry_iterator = dictionary_.find(key);
+  auto entry_iterator = dictionary_.find(key.as_string());
   if (entry_iterator == dictionary_.end())
     return false;
 
   if (out_value)
     *out_value = std::move(entry_iterator->second);
   dictionary_.erase(entry_iterator);
   return true;
 }
 
-bool DictionaryValue::RemovePath(const std::string& path,
+bool DictionaryValue::RemovePath(StringPiece path,
                                  std::unique_ptr<Value>* out_value) {
   bool result = false;
   size_t delimiter_position = path.find('.');
 
   if (delimiter_position == std::string::npos)
     return RemoveWithoutPathExpansion(path, out_value);
 
-  const std::string subdict_path = path.substr(0, delimiter_position);
+  StringPiece subdict_path = path.substr(0, delimiter_position);
   DictionaryValue* subdict = NULL;
   if (!GetDictionary(subdict_path, &subdict))
     return false;
   result = subdict->RemovePath(path.substr(delimiter_position + 1),
                                out_value);
   if (result && subdict->empty())
     RemoveWithoutPathExpansion(subdict_path, NULL);
 
   return result;
 }
@@ skipping 275 matching lines @@
 }
 
 void ListValue::AppendInteger(int in_value) {
   Append(new FundamentalValue(in_value));
 }
 
 void ListValue::AppendDouble(double in_value) {
   Append(new FundamentalValue(in_value));
 }
 
-void ListValue::AppendString(const std::string& in_value) {
-  Append(new StringValue(in_value));
+void ListValue::AppendString(StringPiece in_value) {
+  Append(new StringValue(in_value.as_string()));
 }
 
 void ListValue::AppendString(const string16& in_value) {
   Append(new StringValue(in_value));
 }
 
 void ListValue::AppendStrings(const std::vector<std::string>& in_values) {
   for (std::vector<std::string>::const_iterator it = in_values.begin();
        it != in_values.end(); ++it) {
     AppendString(*it);
@@ skipping 89 matching lines @@
 ValueDeserializer::~ValueDeserializer() {
 }
 
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
   JSONWriter::WriteWithOptions(value, JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return out << json;
 }
 
 }  // namespace base