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..1fc4a1efb886f391086358e845635ef8be565687 100644
--- a/base/test/trace_event_analyzer.cc
+++ b/base/test/trace_event_analyzer.cc
@@ -26,11 +26,29 @@ TraceEvent::TraceEvent()
       other_event(NULL) {
 }
 
-TraceEvent::TraceEvent(const TraceEvent& other) = default;
+TraceEvent::TraceEvent(const TraceEvent& other) {
+  *this = other;
+}
 
 TraceEvent::~TraceEvent() {
 }
 
+void 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 (auto it = rhs.arg_values.cbegin(); it != rhs.arg_values.cend(); ++it) {

[danakj, 2016/03/16 18:29:49]

for (const auto& pair: rhs.arg_values)
  arg_values[pair.first] = pair.second->CreateDeepCopy();

?

[Sami, 2016/03/17 12:27:13]

Much neater, thanks.

+    arg_values[it->first] = it->second->CreateDeepCopy();
+  }
+  other_event = rhs.other_event;
+}
+
 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 +72,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 +127,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;
@@ -137,6 +159,17 @@ bool TraceEvent::GetArgAsNumber(const std::string& name,
   return false;
 }
 
+bool TraceEvent::GetArgAsValue(const std::string& name,
+                               scoped_ptr<base::Value>* arg) const {
+  std::map<std::string, scoped_ptr<base::Value>>::const_iterator i =

[danakj, 2016/03/16 18:29:49]

auto please.

|it| instead of |i|

[Sami, 2016/03/17 12:27:13]

Done. Fixed the others too.

+      arg_values.find(name);
+  if (i != arg_values.end()) {
+    *arg = i->second->CreateDeepCopy();
+    return true;
+  }
+  return false;
+}
+
 bool TraceEvent::HasStringArg(const std::string& name) const {
   return (arg_strings.find(name) != arg_strings.end());
 }
@@ -145,6 +178,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 +210,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) {