Implement frame attribution (FrameBlamer)

base/test/trace_event_analyzer.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/test/trace_event_analyzer.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <set>
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/pattern.h"
 #include "base/values.h"
 
 namespace trace_analyzer {
 
 // TraceEvent
 
 TraceEvent::TraceEvent()
     : thread(0, 0),
       timestamp(0),
       duration(0),
       phase(TRACE_EVENT_PHASE_BEGIN),
       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;
+  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) {
+    arg_values[it->first] = it->second->CreateDeepCopy();
+  }
+}
+
 bool TraceEvent::SetFromJSON(const base::Value* event_value) {
   if (event_value->GetType() != base::Value::TYPE_DICTIONARY) {
     LOG(ERROR) << "Value must be TYPE_DICTIONARY";
     return false;
   }
   const base::DictionaryValue* dictionary =
       static_cast<const base::DictionaryValue*>(event_value);
 
   std::string phase_str;
   const base::DictionaryValue* args = NULL;
 
   if (!dictionary->GetString("ph", &phase_str)) {
     LOG(ERROR) << "ph is missing from TraceEvent JSON";
     return false;
   }
 
   phase = *phase_str.data();
 
   bool may_have_duration = (phase == TRACE_EVENT_PHASE_COMPLETE);
   bool require_origin = (phase != TRACE_EVENT_PHASE_METADATA);
   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)) {
     LOG(ERROR) << "pid is missing from TraceEvent JSON";
     return false;
   }
   if (require_origin && !dictionary->GetInteger("tid", &thread.thread_id)) {
     LOG(ERROR) << "tid is missing from TraceEvent JSON";
     return false;
   }
   if (require_origin && !dictionary->GetDouble("ts", &timestamp)) {
     LOG(ERROR) << "ts is missing from TraceEvent JSON";
     return false;
   }
   if (may_have_duration) {
     dictionary->GetDouble("dur", &duration);
   }
   if (!dictionary->GetString("cat", &category)) {
     LOG(ERROR) << "cat is missing from TraceEvent JSON";
     return false;
   }
   if (!dictionary->GetString("name", &name)) {
     LOG(ERROR) << "name is missing from TraceEvent JSON";
     return false;
   }
   if (!dictionary->GetDictionary("args", &args)) {
     LOG(ERROR) << "args is missing from TraceEvent JSON";
     return false;
   }
+
   if (require_id && !dictionary->GetString("id", &id)) {
     LOG(ERROR) << "id is missing from ASYNC_BEGIN/ASYNC_END TraceEvent JSON";
     return false;
   }
 
   // For each argument, copy the type and create a trace_analyzer::TraceValue.
   for (base::DictionaryValue::Iterator it(*args); !it.IsAtEnd();
        it.Advance()) {
     std::string str;
     bool boolean = false;
     int int_num = 0;
     double double_num = 0.0;
     if (it.value().GetAsString(&str)) {
       arg_strings[it.key()] = str;
     } else if (it.value().GetAsInteger(&int_num)) {
       arg_numbers[it.key()] = static_cast<double>(int_num);
     } else if (it.value().GetAsBoolean(&boolean)) {
       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;
 }
 
 double TraceEvent::GetAbsTimeToOtherEvent() const {
   return fabs(other_event->timestamp - timestamp);
 }
 
 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;
     return true;
   }
   return false;
 }
 
 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;
     return true;
   }
   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 =
+      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());
 }
 
 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);
   DCHECK(result);
   return arg_string;
 }
 
 double TraceEvent::GetKnownArgAsDouble(const std::string& name) const {
   double arg_double = 0;
   bool result = GetArgAsNumber(name, &arg_double);
   DCHECK(result);
   return arg_double;
 }
 
 int TraceEvent::GetKnownArgAsInt(const std::string& name) const {
   double arg_double = 0;
   bool result = GetArgAsNumber(name, &arg_double);
   DCHECK(result);
   return static_cast<int>(arg_double);
 }
 
 bool TraceEvent::GetKnownArgAsBool(const std::string& name) const {
   double arg_double = 0;
   bool result = GetArgAsNumber(name, &arg_double);
   DCHECK(result);
   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) {
 }
 
 QueryNode::~QueryNode() {
 }
 
 // Query
 
@@ skipping 776 matching lines @@
   end_position = (end_position < events.size()) ? end_position : events.size();
   size_t count = 0u;
   for (size_t i = begin_position; i < end_position; ++i) {
     if (query.Evaluate(*events.at(i)))
       ++count;
   }
   return count;
 }
 
 }  // namespace trace_analyzer