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

content/browser/tracing/tracing_controller_impl.cc

 // Copyright (c) 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/browser/tracing/tracing_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/files/file_util.h"
 #include "base/json/string_escape.h"
 #include "base/macros.h"
@@ skipping 144 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StringTraceDataSink);
 };
 
 }  // namespace
 
 TracingController* TracingController::GetInstance() {
   return TracingControllerImpl::GetInstance();
 }
 
-TracingControllerImpl::TracingControllerImpl() :
-    pending_disable_recording_ack_count_(0),
-    pending_capture_monitoring_snapshot_ack_count_(0),
-    pending_trace_buffer_percent_full_ack_count_(0),
-    maximum_trace_buffer_percent_full_(0),
+TracingControllerImpl::TracingControllerImpl()
+    : pending_disable_recording_ack_count_(0),
+      pending_capture_monitoring_snapshot_ack_count_(0),
+      pending_trace_buffer_usage_ack_count_(0),
+      maximum_trace_buffer_usage_(0),
+      approximate_event_count_(0),
     // Tracing may have been enabled by ContentMainRunner if kTraceStartup
     // is specified in command line.
 #if defined(OS_CHROMEOS) || defined(OS_WIN)
-    is_system_tracing_(false),
+      is_system_tracing_(false),
 #endif
-    is_recording_(TraceLog::GetInstance()->IsEnabled()),
-    is_monitoring_(false) {
+      is_recording_(TraceLog::GetInstance()->IsEnabled()),
+      is_monitoring_(false) {
 }
 
 TracingControllerImpl::~TracingControllerImpl() {
   // This is a Leaky instance.
   NOTREACHED();
 }
 
 TracingControllerImpl* TracingControllerImpl::GetInstance() {
   return g_controller.Pointer();
 }
@@ skipping 305 matching lines @@
     it->get()->SendCaptureMonitoringSnapshot();
   }
 
 #if defined(OS_ANDROID)
   TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
   return true;
 }
 
-bool TracingControllerImpl::GetTraceBufferPercentFull(
-    const GetTraceBufferPercentFullCallback& callback) {
+bool TracingControllerImpl::GetTraceBufferUsage(
+    const GetTraceBufferUsageCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!can_get_trace_buffer_percent_full() || callback.is_null())
+  if (!can_get_trace_buffer_usage() || callback.is_null())
     return false;
 
-  pending_trace_buffer_percent_full_callback_ = callback;
+  pending_trace_buffer_usage_callback_ = callback;
 
-  // Count myself in pending_trace_buffer_percent_full_ack_count_, acked below.
-  pending_trace_buffer_percent_full_ack_count_ =
-      trace_message_filters_.size() + 1;
-  pending_trace_buffer_percent_full_filters_ = trace_message_filters_;
-  maximum_trace_buffer_percent_full_ = 0;
+  // Count myself in pending_trace_buffer_usage_ack_count_, acked below.
+  pending_trace_buffer_usage_ack_count_ = trace_message_filters_.size() + 1;
+  pending_trace_buffer_usage_filters_ = trace_message_filters_;
+  maximum_trace_buffer_usage_ = 0;
+  approximate_event_count_ = 0;
 
-  // Call OnTraceBufferPercentFullReply unconditionally for the browser process.
+  TraceLog::BufferUsage buffer_usage =
+      TraceLog::GetInstance()->GetBufferUsage();
+  // Call OnTraceBufferUsageReply unconditionally for the browser process.
   // This will result in immediate execution of the callback if there are no
   // child processes.
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      base::Bind(&TracingControllerImpl::OnTraceBufferPercentFullReply,
-                  base::Unretained(this),
-                  scoped_refptr<TraceMessageFilter>(),
-                  TraceLog::GetInstance()->GetBufferPercentFull()));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&TracingControllerImpl::OnTraceBufferUsageReply,
+                 base::Unretained(this), scoped_refptr<TraceMessageFilter>(),
+                 buffer_usage.event_capacity, buffer_usage.event_count));
 
   // Notify all child processes.
   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
       it != trace_message_filters_.end(); ++it) {
-    it->get()->SendGetTraceBufferPercentFull();
+    it->get()->SendGetTraceBufferUsage();
   }
   return true;
 }
 
 bool TracingControllerImpl::SetWatchEvent(
     const std::string& category_name,
     const std::string& event_name,
     const WatchEventCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 85 matching lines @@
   if (pending_capture_monitoring_snapshot_ack_count_ > 0) {
     TraceMessageFilterSet::const_iterator it =
         pending_capture_monitoring_filters_.find(trace_message_filter);
     if (it != pending_capture_monitoring_filters_.end()) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::Bind(&TracingControllerImpl::OnCaptureMonitoringSnapshotAcked,
                      base::Unretained(this),
                      make_scoped_refptr(trace_message_filter)));
     }
   }
-  if (pending_trace_buffer_percent_full_ack_count_ > 0) {
+  if (pending_trace_buffer_usage_ack_count_ > 0) {
     TraceMessageFilterSet::const_iterator it =
-        pending_trace_buffer_percent_full_filters_.find(trace_message_filter);
-    if (it != pending_trace_buffer_percent_full_filters_.end()) {
-      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-          base::Bind(&TracingControllerImpl::OnTraceBufferPercentFullReply,
+        pending_trace_buffer_usage_filters_.find(trace_message_filter);
+    if (it != pending_trace_buffer_usage_filters_.end()) {
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&TracingControllerImpl::OnTraceBufferUsageReply,
                      base::Unretained(this),
-                     make_scoped_refptr(trace_message_filter),
-                     0));
+                     make_scoped_refptr(trace_message_filter), 0, 0));
     }
   }
 
   trace_message_filters_.erase(trace_message_filter);
 }
 
 void TracingControllerImpl::OnDisableRecordingAcked(
     TraceMessageFilter* trace_message_filter,
     const std::vector<std::string>& known_category_groups) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
@@ skipping 154 matching lines @@
   if (events_str_ptr->data().size())
     OnMonitoringTraceDataCollected(events_str_ptr);
 
   if (has_more_events)
     return;
 
   // Simulate an CaptureMonitoringSnapshotAcked for the local trace.
   OnCaptureMonitoringSnapshotAcked(NULL);
 }
 
-void TracingControllerImpl::OnTraceBufferPercentFullReply(
+void TracingControllerImpl::OnTraceBufferUsageReply(
     TraceMessageFilter* trace_message_filter,
-    float percent_full) {
+    size_t event_capacity,
+    size_t event_count) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&TracingControllerImpl::OnTraceBufferPercentFullReply,
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&TracingControllerImpl::OnTraceBufferUsageReply,
                    base::Unretained(this),
-                   make_scoped_refptr(trace_message_filter),
-                   percent_full));
+                   make_scoped_refptr(trace_message_filter), event_capacity,
+                   event_count));
     return;
   }
 
-  if (pending_trace_buffer_percent_full_ack_count_ == 0)
+  if (pending_trace_buffer_usage_ack_count_ == 0)
     return;
 
   if (trace_message_filter &&
-      !pending_trace_buffer_percent_full_filters_.erase(trace_message_filter)) {
+      !pending_trace_buffer_usage_filters_.erase(trace_message_filter)) {
     // The response from the specified message filter has already been received.
     return;
   }
 
-  maximum_trace_buffer_percent_full_ =
-      std::max(maximum_trace_buffer_percent_full_, percent_full);
+  float percent_full =
+      static_cast<float>(static_cast<double>(event_count) / event_capacity);
+  maximum_trace_buffer_usage_ =
+      std::max(maximum_trace_buffer_usage_, percent_full);
+  approximate_event_count_ += event_count;
 
-  if (--pending_trace_buffer_percent_full_ack_count_ == 0) {
+  if (--pending_trace_buffer_usage_ack_count_ == 0) {
     // Trigger callback if one is set.
-    pending_trace_buffer_percent_full_callback_.Run(
-        maximum_trace_buffer_percent_full_);
-    pending_trace_buffer_percent_full_callback_.Reset();
+    pending_trace_buffer_usage_callback_.Run(maximum_trace_buffer_usage_,
+                                             approximate_event_count_);
+    pending_trace_buffer_usage_callback_.Reset();
   }
 }
 
 void TracingControllerImpl::OnWatchEventMatched() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::OnWatchEventMatched,
                    base::Unretained(this)));
     return;
   }
@@ skipping 20 matching lines @@
   is_monitoring_ = is_monitoring;
 #if !defined(OS_ANDROID)
   for (std::set<TracingUI*>::iterator it = tracing_uis_.begin();
        it != tracing_uis_.end(); it++) {
     (*it)->OnMonitoringStateChanged(is_monitoring);
   }
 #endif
 }
 
 }  // namespace content