tracing: Make ConvertableToTraceFormat move-only scoped_ptr

base/trace_event/trace_event_impl.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/trace_event/trace_event_impl.h"
 
 #include <stddef.h>
 
 #include "base/format_macros.h"
 #include "base/json/string_escape.h"
@@ skipping 38 matching lines @@
       flags_(0),
       phase_(TRACE_EVENT_PHASE_BEGIN) {
   for (int i = 0; i < kTraceMaxNumArgs; ++i)
     arg_names_[i] = NULL;
   memset(arg_values_, 0, sizeof(arg_values_));
 }
 
 TraceEvent::~TraceEvent() {
 }
 
-void TraceEvent::CopyFrom(const TraceEvent& other) {
-  timestamp_ = other.timestamp_;
-  thread_timestamp_ = other.thread_timestamp_;
-  duration_ = other.duration_;
-  scope_ = other.scope_;
-  id_ = other.id_;
-  category_group_enabled_ = other.category_group_enabled_;
-  name_ = other.name_;
-  if (other.flags_ & TRACE_EVENT_FLAG_HAS_PROCESS_ID)
-    process_id_ = other.process_id_;
+void TraceEvent::MoveFrom(scoped_ptr<TraceEvent> other) {
+  timestamp_ = other->timestamp_;
+  thread_timestamp_ = other->thread_timestamp_;
+  duration_ = other->duration_;
+  scope_ = other->scope_;
+  id_ = other->id_;
+  category_group_enabled_ = other->category_group_enabled_;
+  name_ = other->name_;
+  if (other->flags_ & TRACE_EVENT_FLAG_HAS_PROCESS_ID)
+    process_id_ = other->process_id_;
   else
-    thread_id_ = other.thread_id_;
-  phase_ = other.phase_;
-  flags_ = other.flags_;
-  parameter_copy_storage_ = other.parameter_copy_storage_;
+    thread_id_ = other->thread_id_;
+  phase_ = other->phase_;
+  flags_ = other->flags_;
+  parameter_copy_storage_ = std::move(other->parameter_copy_storage_);
 
   for (int i = 0; i < kTraceMaxNumArgs; ++i) {
-    arg_names_[i] = other.arg_names_[i];
-    arg_types_[i] = other.arg_types_[i];
-    arg_values_[i] = other.arg_values_[i];
-    convertable_values_[i] = other.convertable_values_[i];
+    arg_names_[i] = other->arg_names_[i];
+    arg_types_[i] = other->arg_types_[i];
+    arg_values_[i] = other->arg_values_[i];
+    convertable_values_[i] = std::move(other->convertable_values_[i]);
   }
 }
 
 void TraceEvent::Initialize(
     int thread_id,
     TimeTicks timestamp,
     ThreadTicks thread_timestamp,
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     const char* scope,
     unsigned long long id,
     unsigned long long bind_id,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
-    const scoped_refptr<ConvertableToTraceFormat>* convertable_values,
+    scoped_ptr<ConvertableToTraceFormat>* convertable_values,
     unsigned int flags) {
   timestamp_ = timestamp;
   thread_timestamp_ = thread_timestamp;
   duration_ = TimeDelta::FromInternalValue(-1);
   scope_ = scope;
   id_ = id;
   category_group_enabled_ = category_group_enabled;
   name_ = name;
   thread_id_ = thread_id;
   phase_ = phase;
   flags_ = flags;
   bind_id_ = bind_id;
 
   // Clamp num_args since it may have been set by a third_party library.
   num_args = (num_args > kTraceMaxNumArgs) ? kTraceMaxNumArgs : num_args;
   int i = 0;
   for (; i < num_args; ++i) {
     arg_names_[i] = arg_names[i];
     arg_types_[i] = arg_types[i];
 
-    if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE)
-      convertable_values_[i] = convertable_values[i];
-    else
+    if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
+      convertable_values_[i] = std::move(convertable_values[i]);
+    } else {
       arg_values_[i].as_uint = arg_values[i];
+      convertable_values_[i].reset();
+    }
   }
   for (; i < kTraceMaxNumArgs; ++i) {
     arg_names_[i] = NULL;
     arg_values_[i].as_uint = 0u;
-    convertable_values_[i] = NULL;
+    convertable_values_[i].reset();
     arg_types_[i] = TRACE_VALUE_TYPE_UINT;
   }
 
   bool copy = !!(flags & TRACE_EVENT_FLAG_COPY);
   size_t alloc_size = 0;
   if (copy) {
     alloc_size += GetAllocLength(name) + GetAllocLength(scope);
     for (i = 0; i < num_args; ++i) {
       alloc_size += GetAllocLength(arg_names_[i]);
       if (arg_types_[i] == TRACE_VALUE_TYPE_STRING)
         arg_types_[i] = TRACE_VALUE_TYPE_COPY_STRING;
     }
   }
 
   bool arg_is_copy[kTraceMaxNumArgs];
   for (i = 0; i < num_args; ++i) {
     // No copying of convertable types, we retain ownership.
     if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
       continue;
 
     // We only take a copy of arg_vals if they are of type COPY_STRING.
     arg_is_copy[i] = (arg_types_[i] == TRACE_VALUE_TYPE_COPY_STRING);
     if (arg_is_copy[i])
       alloc_size += GetAllocLength(arg_values_[i].as_string);
   }
 
   if (alloc_size) {
-    parameter_copy_storage_ = new RefCountedString;
-    parameter_copy_storage_->data().resize(alloc_size);
-    char* ptr = string_as_array(&parameter_copy_storage_->data());
+    parameter_copy_storage_.reset(new std::string);
+    parameter_copy_storage_->resize(alloc_size);
+    char* ptr = string_as_array(parameter_copy_storage_.get());
     const char* end = ptr + alloc_size;
     if (copy) {
       CopyTraceEventParameter(&ptr, &name_, end);
       CopyTraceEventParameter(&ptr, &scope_, end);
       for (i = 0; i < num_args; ++i) {
         CopyTraceEventParameter(&ptr, &arg_names_[i], end);
       }
     }
     for (i = 0; i < num_args; ++i) {
       if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
         continue;
       if (arg_is_copy[i])
         CopyTraceEventParameter(&ptr, &arg_values_[i].as_string, end);
     }
     DCHECK_EQ(end, ptr) << "Overrun by " << ptr - end;
   }
 }
 
 void TraceEvent::Reset() {
   // Only reset fields that won't be initialized in Initialize(), or that may
   // hold references to other objects.
   duration_ = TimeDelta::FromInternalValue(-1);
-  parameter_copy_storage_ = NULL;
+  parameter_copy_storage_.reset();
   for (int i = 0; i < kTraceMaxNumArgs; ++i)
-    convertable_values_[i] = NULL;
+    convertable_values_[i].reset();
 }
 
 void TraceEvent::UpdateDuration(const TimeTicks& now,
                                 const ThreadTicks& thread_now) {
   DCHECK_EQ(duration_.ToInternalValue(), -1);
   duration_ = now - timestamp_;
 
   // |thread_timestamp_| can be empty if the thread ticks clock wasn't
   // initialized when it was recorded.
   if (thread_timestamp_ != ThreadTicks())
     thread_duration_ = thread_now - thread_timestamp_;
 }
 
 void TraceEvent::EstimateTraceMemoryOverhead(
     TraceEventMemoryOverhead* overhead) {
   overhead->Add("TraceEvent", sizeof(*this));
 
-  // TODO(primiano): parameter_copy_storage_ is refcounted and, in theory,
-  // could be shared by several events and we might overcount. In practice
-  // this is unlikely but it's worth checking.
   if (parameter_copy_storage_)
-    overhead->AddRefCountedString(*parameter_copy_storage_.get());
+    overhead->AddString(*parameter_copy_storage_);
 
   for (size_t i = 0; i < kTraceMaxNumArgs; ++i) {
     if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
       convertable_values_[i]->EstimateTraceMemoryOverhead(overhead);
   }
 }
 
 // static
 void TraceEvent::AppendValueAsJSON(unsigned char type,
                                    TraceEvent::TraceValue value,
@@ skipping 204 matching lines @@
         AppendValueAsJSON(arg_types_[i], arg_values_[i], &value_as_text);
 
       *out << value_as_text;
     }
     *out << "}";
   }
 }
 
 }  // namespace trace_event
 }  // namespace base