Report trace buffer usage as number of events, not only percentage

content/browser/tracing/tracing_ui.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 "content/browser/tracing/tracing_ui.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 111 matching lines @@
       category_filter,
       tracing_options,
       base::Bind(&OnRecordingEnabledAck, callback));
 }
 
 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback) {
   base::RefCountedString* res = new base::RefCountedString();
   callback.Run(res);
 }
 
-void OnTraceBufferPercentFullResult(
-    const WebUIDataSource::GotDataCallback& callback, float result) {
-  std::string str = base::DoubleToString(result);
+void OnTraceBufferUsageResult(const WebUIDataSource::GotDataCallback& callback,
+                              float percent_full,
+                              size_t approximate_event_count) {
+  std::string str = base::DoubleToString(percent_full);
   callback.Run(base::RefCountedString::TakeString(&str));
 }
 
+void OnTraceBufferStatusResult(const WebUIDataSource::GotDataCallback& callback,
+                               float percent_full,
+                               size_t approximate_event_count) {
+  scoped_ptr<base::DictionaryValue> status(new base::DictionaryValue());
+  status->SetDouble("percentFull", percent_full);
+  status->SetInteger("approximateEventCount", approximate_event_count);
+
+  std::string status_json;
+  base::JSONWriter::Write(status.get(), &status_json);
+
+  base::RefCountedString* status_base64 = new base::RefCountedString();
+  base::Base64Encode(status_json, &status_base64->data());
+  callback.Run(status_base64);
+}
+
 void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 
 bool EnableMonitoring(const std::string& data64,
                       const WebUIDataSource::GotDataCallback& callback) {
   base::debug::TraceOptions tracing_options;
   base::debug::CategoryFilter category_filter("");
   if (!GetTracingOptions(data64, &category_filter, &tracing_options))
     return false;
 
   return TracingController::GetInstance()->EnableMonitoring(
@@ skipping 50 matching lines @@
     return TracingController::GetInstance()->GetCategories(
         base::Bind(OnGotCategories, callback));
   }
 
   const char* beginRecordingPath = "json/begin_recording?";
   if (StartsWithASCII(path, beginRecordingPath, true)) {
     std::string data = path.substr(strlen(beginRecordingPath));
     return BeginRecording(data, callback);
   }
   if (path == "json/get_buffer_percent_full") {
-    return TracingController::GetInstance()->GetTraceBufferPercentFull(
-        base::Bind(OnTraceBufferPercentFullResult, callback));
+    return TracingController::GetInstance()->GetTraceBufferUsage(
+        base::Bind(OnTraceBufferUsageResult, callback));
+  }
+  if (path == "json/get_buffer_status") {
+    return TracingController::GetInstance()->GetTraceBufferUsage(
+        base::Bind(OnTraceBufferStatusResult, callback));
   }
   if (path == "json/end_recording") {
     return TracingController::GetInstance()->DisableRecording(
         TracingControllerImpl::CreateStringSink(
             base::Bind(TracingCallbackWrapper, callback)));
   }
 
   const char* enableMonitoringPath = "json/begin_monitoring?";
   if (path.find(enableMonitoringPath) == 0) {
     std::string data = path.substr(strlen(enableMonitoringPath));
@@ skipping 157 matching lines @@
   if (success) {
     web_ui()->CallJavascriptFunction("onUploadComplete",
                                      base::StringValue(report_id));
   } else {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue(error_message));
   }
 }
 
 }  // namespace content