base: Add blame context

base/test/trace_event_analyzer.cc

Index: base/test/trace_event_analyzer.cc
diff --git a/base/test/trace_event_analyzer.cc b/base/test/trace_event_analyzer.cc
index fc775f27b14d26dfef8c660d0e1c543c41879b1f..22cf373fe2e2d45b96449cf570171d8d7d234e68 100644
--- a/base/test/trace_event_analyzer.cc
+++ b/base/test/trace_event_analyzer.cc
@@ -26,11 +26,48 @@ TraceEvent::TraceEvent()
       other_event(NULL) {
 }
 
-TraceEvent::TraceEvent(const TraceEvent& other) = default;
+TraceEvent::TraceEvent(const TraceEvent& other) {
+  *this = other;
+}
+
+TraceEvent::TraceEvent(TraceEvent&& other) {

[danakj, 2016/03/18 21:34:56]

does = default work for this?

[Sami, 2016/03/21 11:34:15]

Looks like it does -- done.

+  *this = std::move(other);
+}
 
 TraceEvent::~TraceEvent() {
 }
 
+TraceEvent& TraceEvent::operator=(const TraceEvent& rhs) {
+  thread = rhs.thread;
+  timestamp = rhs.timestamp;
+  duration = rhs.duration;
+  phase = rhs.phase;
+  category = rhs.category;
+  name = rhs.name;
+  id = rhs.id;
+  arg_numbers = rhs.arg_numbers;
+  arg_strings = rhs.arg_strings;
+  for (const auto& pair : rhs.arg_values)
+    arg_values[pair.first] = pair.second->CreateDeepCopy();
+  other_event = rhs.other_event;
+  return *this;
+}
+
+TraceEvent& TraceEvent::operator=(TraceEvent&& rhs) {

[danakj, 2016/03/18 21:34:56]

does = default work for this?

[vmpstr, 2016/03/18 21:36:18]

iirc msvc2013 might not like it

[danakj, 2016/03/18 21:39:10]

Well, we're on 2015 now :)

[Sami, 2016/03/21 11:34:15]

Let's see if the trybots agree :)

+  thread = rhs.thread;
+  timestamp = rhs.timestamp;
+  duration = rhs.duration;
+  phase = rhs.phase;
+  category = rhs.category;
+  name = rhs.name;
+  id = rhs.id;
+  arg_numbers.swap(rhs.arg_numbers);
+  arg_strings.swap(rhs.arg_strings);
+  arg_values.swap(rhs.arg_values);
+  other_event = rhs.other_event;
+  return *this;
+}
+
 bool TraceEvent::SetFromJSON(const base::Value* event_value) {
   if (event_value->GetType() != base::Value::TYPE_DICTIONARY) {
     LOG(ERROR) << "Value must be TYPE_DICTIONARY";
@@ -54,6 +91,12 @@ bool TraceEvent::SetFromJSON(const base::Value* event_value) {
   bool require_id = (phase == TRACE_EVENT_PHASE_ASYNC_BEGIN ||
                      phase == TRACE_EVENT_PHASE_ASYNC_STEP_INTO ||
                      phase == TRACE_EVENT_PHASE_ASYNC_STEP_PAST ||
+                     phase == TRACE_EVENT_PHASE_MEMORY_DUMP ||
+                     phase == TRACE_EVENT_PHASE_ENTER_CONTEXT ||
+                     phase == TRACE_EVENT_PHASE_LEAVE_CONTEXT ||
+                     phase == TRACE_EVENT_PHASE_CREATE_OBJECT ||
+                     phase == TRACE_EVENT_PHASE_DELETE_OBJECT ||
+                     phase == TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ||
                      phase == TRACE_EVENT_PHASE_ASYNC_END);
 
   if (require_origin && !dictionary->GetInteger("pid", &thread.process_id)) {
@@ -103,11 +146,9 @@ bool TraceEvent::SetFromJSON(const base::Value* event_value) {
       arg_numbers[it.key()] = static_cast<double>(boolean ? 1 : 0);
     } else if (it.value().GetAsDouble(&double_num)) {
       arg_numbers[it.key()] = double_num;
-    } else {
-      LOG(WARNING) << "Value type of argument is not supported: " <<
-          static_cast<int>(it.value().GetType());
-      continue;  // Skip non-supported arguments.
     }
+    // Record all arguments as values.
+    arg_values[it.key()] = it.value().CreateDeepCopy();
   }
 
   return true;
@@ -119,9 +160,9 @@ double TraceEvent::GetAbsTimeToOtherEvent() const {
 
 bool TraceEvent::GetArgAsString(const std::string& name,
                                 std::string* arg) const {
-  std::map<std::string, std::string>::const_iterator i = arg_strings.find(name);
-  if (i != arg_strings.end()) {
-    *arg = i->second;
+  const auto it = arg_strings.find(name);
+  if (it != arg_strings.end()) {
+    *arg = it->second;
     return true;
   }
   return false;
@@ -129,9 +170,19 @@ bool TraceEvent::GetArgAsString(const std::string& name,
 
 bool TraceEvent::GetArgAsNumber(const std::string& name,
                                 double* arg) const {
-  std::map<std::string, double>::const_iterator i = arg_numbers.find(name);
-  if (i != arg_numbers.end()) {
-    *arg = i->second;
+  const auto it = arg_numbers.find(name);
+  if (it != arg_numbers.end()) {
+    *arg = it->second;
+    return true;
+  }
+  return false;
+}
+
+bool TraceEvent::GetArgAsValue(const std::string& name,
+                               scoped_ptr<base::Value>* arg) const {
+  const auto it = arg_values.find(name);
+  if (it != arg_values.end()) {
+    *arg = it->second->CreateDeepCopy();
     return true;
   }
   return false;
@@ -145,6 +196,10 @@ bool TraceEvent::HasNumberArg(const std::string& name) const {
   return (arg_numbers.find(name) != arg_numbers.end());
 }
 
+bool TraceEvent::HasArg(const std::string& name) const {
+  return (arg_values.find(name) != arg_values.end());
+}
+
 std::string TraceEvent::GetKnownArgAsString(const std::string& name) const {
   std::string arg_string;
   bool result = GetArgAsString(name, &arg_string);
@@ -173,6 +228,14 @@ bool TraceEvent::GetKnownArgAsBool(const std::string& name) const {
   return (arg_double != 0.0);
 }
 
+scoped_ptr<base::Value> TraceEvent::GetKnownArgAsValue(
+    const std::string& name) const {
+  scoped_ptr<base::Value> arg_value;
+  bool result = GetArgAsValue(name, &arg_value);
+  DCHECK(result);
+  return arg_value;
+}
+
 // QueryNode
 
 QueryNode::QueryNode(const Query& query) : query_(query) {