[Telemetry] Add support for capturing V8 object stats to Telemetry.

content/renderer/stats_collection_controller.cc

 // Copyright 2013 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 "content/renderer/stats_collection_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/statistics_recorder.h"
+#include "base/metrics/stats_table.h"
 #include "base/strings/string_util.h"
 #include "content/common/child_process_messages.h"
 #include "content/renderer/render_view_impl.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 using webkit_glue::CppArgumentList;
 using webkit_glue::CppVariant;
 
 namespace content {
@@ skipping 44 matching lines @@
   }
   if (load_start_time.is_null() || load_stop_time.is_null()) {
     item.Set("load_duration_ms", base::Value::CreateNullValue());
   } else {
     item.SetDouble("load_duration_ms",
         (load_stop_time - load_start_time).InMilliseconds());
   }
   base::JSONWriter::Write(&item, result);
 }
 
+
+// Encodes StatsTable as json.
+// - |stats_table| - StatsTable to encode.
+// - |pid| - The process id to get stats for (0 for all processes).
+// - |result| - returned JSON.
+// Example return value:
+// {'c:V8:TotalEvalSize': 102664, 'c:V8:TotalLoadSize': 164356}
+void ConvertStatsTableToJSON(
+    const base::StatsTable* stats_table,
+    const base::ProcessId pid,
+    std::string *result) {
+  base::DictionaryValue counters;
+  // NOTE: Counters start at index 1.
+  for (int index = 1; index <= stats_table->GetMaxCounters(); index++) {
+    std::string name = stats_table->GetRowName(index);
+    if (name.length() == 0)
+      break;
+
+    // JSON doesn't allow '.' in names.
+    size_t pos;
+    while ((pos = name.find(".")) != std::string::npos)
+      name.replace(pos, 1, ":");
+
+    counters.SetInteger(name, stats_table->GetRowValue(index, pid));
+  }
+  base::JSONWriter::Write(&counters, result);
+}
+
 }  // namespace
 
 StatsCollectionController::StatsCollectionController()
     : sender_(NULL) {
   BindCallback("getHistogram",
                base::Bind(&StatsCollectionController::GetHistogram,
                           base::Unretained(this)));
   BindCallback("getBrowserHistogram",
                base::Bind(&StatsCollectionController::GetBrowserHistogram,
                           base::Unretained(this)));
+  BindCallback("getStatsTable",
+               base::Bind(
+                  &StatsCollectionController::GetStatsTable,
+                  base::Unretained(this)));
   BindCallback("tabLoadTiming",
                base::Bind(
                   &StatsCollectionController::GetTabLoadTiming,
                   base::Unretained(this)));
 }
 
 void StatsCollectionController::GetHistogram(const CppArgumentList& args,
-                                            CppVariant* result) {
+                                             CppVariant* result) {
   if (args.size() != 1) {
     result->SetNull();
     return;
   }
   base::HistogramBase* histogram =
       base::StatisticsRecorder::FindHistogram(args[0].ToString());
   std::string output;
   if (!histogram) {
     output = "{}";
   } else {
     histogram->WriteJSON(&output);
   }
   result->Set(output);
 }
 
 void StatsCollectionController::GetBrowserHistogram(const CppArgumentList& args,
-                                                   CppVariant* result) {
+                                                    CppVariant* result) {
   if (args.size() != 1) {
     result->SetNull();
     return;
   }
 
   if (!sender_) {
     NOTREACHED();
     result->SetNull();
     return;
   }
 
   std::string histogram_json;
   sender_->Send(new ChildProcessHostMsg_GetBrowserHistogram(
       args[0].ToString(), &histogram_json));
   result->Set(histogram_json);
 }
 
+void StatsCollectionController::GetStatsTable(const CppArgumentList& args,
+                                              CppVariant* result) {
+  base::StatsTable* stats_table = base::StatsTable::current();
+  std::string output;
+  if (!stats_table) {
+    output = "{}";
+  } else {
+    ConvertStatsTableToJSON(stats_table, base::GetCurrentProcId(), &output);
+  }
+  result->Set(output);
+}
+
 void StatsCollectionController::GetTabLoadTiming(
     const CppArgumentList& args,
     CppVariant* result) {
   if (!sender_) {
     NOTREACHED();
     result->SetNull();
     return;
   }
 
   RenderViewImpl *render_view_impl = NULL;
@@ skipping 12 matching lines @@
   }
 
   std::string tab_timing_json;
   ConvertLoadTimeToJSON(
       observer->load_start_time(), observer->load_stop_time(),
       &tab_timing_json);
   result->Set(tab_timing_json);
 }
 
 }  // namespace content