Make base::trace_event::TracedValue use StringPiece where possible.

base/trace_event/trace_event_argument.cc

 // Copyright (c) 2014 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/trace_event/trace_event_argument.h"
 
 #include "base/bits.h"
 #include "base/json/json_writer.h"
 #include "base/trace_event/trace_event_memory_overhead.h"
 #include "base/values.h"
@@ skipping 24 matching lines @@
 #define DCHECK_CONTAINER_STACK_DEPTH_EQ(x) do {} while (0)
 #define DEBUG_PUSH_CONTAINER(x) do {} while (0)
 #define DEBUG_POP_CONTAINER() do {} while (0)
 #endif
 
 inline void WriteKeyNameAsRawPtr(Pickle& pickle, const char* ptr) {
   pickle.WriteBytes(&kTypeCStr, 1);
   pickle.WriteUInt64(static_cast<uint64>(reinterpret_cast<uintptr_t>(ptr)));
 }
 
-inline void WriteKeyNameAsStdString(Pickle& pickle, const std::string& str) {
+inline void WriteKeyNameWithCopy(Pickle& pickle, base::StringPiece str) {
   pickle.WriteBytes(&kTypeString, 1);
   pickle.WriteString(str);
 }
 
 std::string ReadKeyName(PickleIterator& pickle_iterator) {
   const char* type = nullptr;
   bool res = pickle_iterator.ReadBytes(&type, 1);
   std::string key_name;
   if (res && *type == kTypeCStr) {
     uint64 ptr_value = 0;
@@ skipping 22 matching lines @@
   DCHECK_CONTAINER_STACK_DEPTH_EQ(0u);
 }
 
 void TracedValue::SetInteger(const char* name, int value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeInt, 1);
   pickle_.WriteInt(value);
   WriteKeyNameAsRawPtr(pickle_, name);
 }
 
-void TracedValue::SetIntegerWithCopiedName(const std::string& name, int value) {
+void TracedValue::SetIntegerWithCopiedName(base::StringPiece name, int value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeInt, 1);
   pickle_.WriteInt(value);
-  WriteKeyNameAsStdString(pickle_, name);
+  WriteKeyNameWithCopy(pickle_, name);
 }
 
 void TracedValue::SetDouble(const char* name, double value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeDouble, 1);
   pickle_.WriteDouble(value);
   WriteKeyNameAsRawPtr(pickle_, name);
 }
 
-void TracedValue::SetDoubleWithCopiedName(const std::string& name,
+void TracedValue::SetDoubleWithCopiedName(base::StringPiece name,
                                           double value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeDouble, 1);
   pickle_.WriteDouble(value);
-  WriteKeyNameAsStdString(pickle_, name);
+  WriteKeyNameWithCopy(pickle_, name);
 }
 
 void TracedValue::SetBoolean(const char* name, bool value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeBool, 1);
   pickle_.WriteBool(value);
   WriteKeyNameAsRawPtr(pickle_, name);
 }
 
-void TracedValue::SetBooleanWithCopiedName(const std::string& name,
+void TracedValue::SetBooleanWithCopiedName(base::StringPiece name,
                                            bool value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeBool, 1);
   pickle_.WriteBool(value);
-  WriteKeyNameAsStdString(pickle_, name);
+  WriteKeyNameWithCopy(pickle_, name);
 }
 
-void TracedValue::SetString(const char* name, const std::string& value) {
+void TracedValue::SetString(const char* name, base::StringPiece value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeString, 1);
   pickle_.WriteString(value);
   WriteKeyNameAsRawPtr(pickle_, name);
 }
 
-void TracedValue::SetStringWithCopiedName(const std::string& name,
-                                          const std::string& value) {
+void TracedValue::SetStringWithCopiedName(base::StringPiece name,
+                                          base::StringPiece value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   pickle_.WriteBytes(&kTypeString, 1);
   pickle_.WriteString(value);
-  WriteKeyNameAsStdString(pickle_, name);
+  WriteKeyNameWithCopy(pickle_, name);
 }
 
 void TracedValue::SetValue(const char* name, const TracedValue& value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   BeginDictionary(name);
   pickle_.WriteBytes(value.pickle_.payload(),
                      static_cast<int>(value.pickle_.payload_size()));
   EndDictionary();
 }
 
-void TracedValue::SetValueWithCopiedName(const std::string& name,
+void TracedValue::SetValueWithCopiedName(base::StringPiece name,
                                          const TracedValue& value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   BeginDictionaryWithCopiedName(name);
   pickle_.WriteBytes(value.pickle_.payload(),
                      static_cast<int>(value.pickle_.payload_size()));
   EndDictionary();
 }
 
 void TracedValue::BeginDictionary(const char* name) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   DEBUG_PUSH_CONTAINER(kStackTypeDict);
   pickle_.WriteBytes(&kTypeStartDict, 1);
   WriteKeyNameAsRawPtr(pickle_, name);
 }
 
-void TracedValue::BeginDictionaryWithCopiedName(const std::string& name) {
+void TracedValue::BeginDictionaryWithCopiedName(base::StringPiece name) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   DEBUG_PUSH_CONTAINER(kStackTypeDict);
   pickle_.WriteBytes(&kTypeStartDict, 1);
-  WriteKeyNameAsStdString(pickle_, name);
+  WriteKeyNameWithCopy(pickle_, name);
 }
 
 void TracedValue::BeginArray(const char* name) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   DEBUG_PUSH_CONTAINER(kStackTypeArray);
   pickle_.WriteBytes(&kTypeStartArray, 1);
   WriteKeyNameAsRawPtr(pickle_, name);
 }
 
-void TracedValue::BeginArrayWithCopiedName(const std::string& name) {
+void TracedValue::BeginArrayWithCopiedName(base::StringPiece name) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   DEBUG_PUSH_CONTAINER(kStackTypeArray);
   pickle_.WriteBytes(&kTypeStartArray, 1);
-  WriteKeyNameAsStdString(pickle_, name);
+  WriteKeyNameWithCopy(pickle_, name);
 }
 
 void TracedValue::EndDictionary() {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   DEBUG_POP_CONTAINER();
   pickle_.WriteBytes(&kTypeEndDict, 1);
 }
 
 void TracedValue::AppendInteger(int value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   pickle_.WriteBytes(&kTypeInt, 1);
   pickle_.WriteInt(value);
 }
 
 void TracedValue::AppendDouble(double value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   pickle_.WriteBytes(&kTypeDouble, 1);
   pickle_.WriteDouble(value);
 }
 
 void TracedValue::AppendBoolean(bool value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   pickle_.WriteBytes(&kTypeBool, 1);
   pickle_.WriteBool(value);
 }
 
-void TracedValue::AppendString(const std::string& value) {
+void TracedValue::AppendString(base::StringPiece value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   pickle_.WriteBytes(&kTypeString, 1);
   pickle_.WriteString(value);
 }
 
 void TracedValue::BeginArray() {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   DEBUG_PUSH_CONTAINER(kStackTypeArray);
   pickle_.WriteBytes(&kTypeStartArray, 1);
 }
 
 void TracedValue::BeginDictionary() {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   DEBUG_PUSH_CONTAINER(kStackTypeDict);
   pickle_.WriteBytes(&kTypeStartDict, 1);
 }
 
 void TracedValue::EndArray() {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   DEBUG_POP_CONTAINER();
   pickle_.WriteBytes(&kTypeEndArray, 1);
 }
 
 void TracedValue::SetValue(const char* name, scoped_ptr<base::Value> value) {
   SetBaseValueWithCopiedName(name, *value);
 }
 
-void TracedValue::SetBaseValueWithCopiedName(const std::string& name,
+void TracedValue::SetBaseValueWithCopiedName(base::StringPiece name,
                                              const base::Value& value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   switch (value.GetType()) {
     case base::Value::TYPE_NULL:
     case base::Value::TYPE_BINARY:
       NOTREACHED();
       break;
 
     case base::Value::TYPE_BOOLEAN: {
       bool bool_value;
@@ skipping 213 matching lines @@
 
                 /* allocated size */
                 bits::Align(pickle_.GetTotalAllocatedSize(), kPickleHeapAlign),
 
                 /* resident size */
                 bits::Align(pickle_.size(), kPickleHeapAlign));
 }
 
 }  // namespace trace_event
 }  // namespace base