Implement about:tracing UI for the sampling profiler (Chromium part)

content/browser/tracing/trace_controller_impl.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/trace_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 35 matching lines @@
 
 }  // namespace
 
 TraceController* TraceController::GetInstance() {
   return TraceControllerImpl::GetInstance();
 }
 
 TraceControllerImpl::TraceControllerImpl() :
     subscriber_(NULL),
     pending_end_ack_count_(0),
+    pending_show_continuous_sampling_ack_count_(0),
     pending_bpf_ack_count_(0),
     maximum_bpf_(0.0f),
     is_tracing_(false),
+    is_continuous_sampling_tracing_(false),
     is_get_category_groups_(false),
     category_filter_(
         base::debug::CategoryFilter::kDefaultCategoryFilterString) {
   TraceLog::GetInstance()->SetNotificationCallback(
       base::Bind(&TraceControllerImpl::OnTraceNotification,
                  base::Unretained(this)));
 }
 
 TraceControllerImpl::~TraceControllerImpl() {
   // No need to SetNotificationCallback(nil) on the TraceLog since this is a
@@ skipping 62 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_begin_tracing(subscriber))
     return false;
 
   // Enable tracing
   TraceLog::GetInstance()->SetEnabled(
       base::debug::CategoryFilter(category_patterns), options);
 
   OnTracingBegan(subscriber);
-
   return true;
 }
 
 bool TraceControllerImpl::EndTracingAsync(TraceSubscriber* subscriber) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!can_end_tracing() || subscriber != subscriber_)
+  if (!can_end_tracing(subscriber))
     return false;
 
   // There could be a case where there are no child processes and filters_
   // is empty. In that case we can immediately tell the subscriber that tracing
   // has ended. To avoid recursive calls back to the subscriber, we will just
   // use the existing asynchronous OnEndTracingAck code.
   // Count myself (local trace) in pending_end_ack_count_, acked below.
   pending_end_ack_count_ = filters_.size() + 1;
 
   // Handle special case of zero child processes.
   if (pending_end_ack_count_ == 1) {
     // Ack asynchronously now, because we don't have any children to wait for.
     std::vector<std::string> category_groups;
     TraceLog::GetInstance()->GetKnownCategoryGroups(&category_groups);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnEndTracingAck,
                    base::Unretained(this), category_groups));
   }
 
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendEndTracing();
   }
 
   return true;
 }
 
+bool TraceControllerImpl::BeginContinuousSamplingTracing(
+    TraceSubscriber* subscriber) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (!can_begin_continuous_sampling_tracing(subscriber))
+    return false;
+
+  is_continuous_sampling_tracing_ = true;
+  continuous_sampling_subscriber_ = subscriber;
+
+  // Notify all child processes.
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
+    it->get()->SendBeginContinuousSamplingTracing();
+  }
+  return true;
+}
+
+bool TraceControllerImpl::EndContinuousSamplingTracing(
+    TraceSubscriber* subscriber) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (!can_end_continuous_sampling_tracing(subscriber))
+    return false;
+
+  is_continuous_sampling_tracing_ = false;
+  continuous_sampling_subscriber_ = NULL;
+
+  // Notify all child processes.
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
+    it->get()->SendEndContinuousSamplingTracing();
+  }
+  return true;
+}
+
+bool TraceControllerImpl::ShowContinuousSamplingTracingAsync(
+    TraceSubscriber* subscriber) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (!can_end_continuous_sampling_tracing(subscriber))
+    return false;
+
+  // There could be a case where there are no child processes and filters_
+  // is empty. In that case we can immediately tell the subscriber that tracing
+  // has ended. To avoid recursive calls back to the subscriber, we will just
+  // use the existing asynchronous OnShowContinuousSamplingTracingAck code.
+  // Count myself (local trace) in pending_show_continuous_sampling_ack_count_,
+  // acked below.
+  pending_show_continuous_sampling_ack_count_ = filters_.size() + 1;
+
+  // Handle special case of zero child processes.
+  if (pending_show_continuous_sampling_ack_count_ == 1) {
+    // Ack asynchronously now, because we don't have any children to wait for.
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(&TraceControllerImpl::OnShowContinuousSamplingTracingAck,
+                   base::Unretained(this)));
+  }
+
+  // Notify all child processes.
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
+    it->get()->SendShowContinuousSamplingTracing();
+  }
+  return true;
+}
+
 bool TraceControllerImpl::GetTraceBufferPercentFullAsync(
     TraceSubscriber* subscriber) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_get_buffer_percent_full() || subscriber != subscriber_)
     return false;
 
   maximum_bpf_ = 0.0f;
   pending_bpf_ack_count_ = filters_.size() + 1;
 
@@ skipping 45 matching lines @@
 
   return true;
 }
 
 void TraceControllerImpl::CancelSubscriber(TraceSubscriber* subscriber) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (subscriber == subscriber_) {
     subscriber_ = NULL;
     // End tracing if necessary.
-    if (is_tracing_ && pending_end_ack_count_ == 0)
+    if (is_tracing_enabled())
       EndTracingAsync(NULL);
   }
 }
 
 void TraceControllerImpl::AddFilter(TraceMessageFilter* filter) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::AddFilter, base::Unretained(this),
                    make_scoped_refptr(filter)));
     return;
   }
 
   filters_.insert(filter);
   if (is_tracing_enabled()) {
     std::string cf_str = category_filter_.ToString();
     filter->SendBeginTracing(cf_str, trace_options_);
     if (!watch_category_.empty())
       filter->SendSetWatchEvent(watch_category_, watch_name_);
   }
+  if (is_continuous_sampling_tracing_enabled()) {
+    filter->SendBeginContinuousSamplingTracing();
+  }
 }
 
 void TraceControllerImpl::RemoveFilter(TraceMessageFilter* filter) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::RemoveFilter, base::Unretained(this),
                    make_scoped_refptr(filter)));
     return;
   }
 
   filters_.erase(filter);
 }
 
 void TraceControllerImpl::OnTracingBegan(TraceSubscriber* subscriber) {
   is_tracing_ = true;
-
   subscriber_ = subscriber;
 
   category_filter_ = TraceLog::GetInstance()->GetCurrentCategoryFilter();
   trace_options_ = TraceLog::GetInstance()->trace_options();
 
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendBeginTracing(category_filter_.ToString(), trace_options_);
   }
 }
@@ skipping 62 matching lines @@
         base::Bind(&TraceControllerImpl::OnTraceDataCollected,
                    base::Unretained(this), events_str_ptr));
     return;
   }
 
   // Drop trace events if we are just getting categories.
   if (subscriber_ && !is_get_category_groups_)
     subscriber_->OnTraceDataCollected(events_str_ptr);
 }
 
+void TraceControllerImpl::OnShowContinuousSamplingTracingAck() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(&TraceControllerImpl::OnShowContinuousSamplingTracingAck,
+                   base::Unretained(this)));
+    return;
+  }
+
+  if (pending_show_continuous_sampling_ack_count_ == 0)
+    return;
+
+  if (--pending_show_continuous_sampling_ack_count_ == 0) {
+    // During this call, our OnContinuousSamplingTraceDataCollected will be
+    // called with the last of the local trace data. Since we are on the UI
+    // thread, the call to OnContinuousSamplingTraceDataCollected will be
+    // synchronous, so we can immediately call
+    // OnShowContinuousSamplingTracingComplete below.
+    TraceLog::GetInstance()->FlushContinuousSamplingTracing(
+        base::Bind(&TraceControllerImpl::OnContinuousSamplingTraceDataCollected,
+                   base::Unretained(this)));
+
+    if (continuous_sampling_subscriber_)
+      continuous_sampling_subscriber_->
+          OnShowContinuousSamplingTracingComplete();
+  }
+
+  if (pending_show_continuous_sampling_ack_count_ == 1) {
+    // The last ack represents local trace, so we need to ack it now. Note that
+    // this code only executes if there were child processes.
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(&TraceControllerImpl::OnShowContinuousSamplingTracingAck,
+                   base::Unretained(this)));
+  }
+}
+
+void TraceControllerImpl::OnContinuousSamplingTraceDataCollected(
+    const scoped_refptr<base::RefCountedString>& events_str_ptr) {
+  // OnContinuousSamplingTraceDataCollected may be called from
+  // any browser thread, either by the local event trace system or
+  // from child processes via TraceMessageFilter.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(&TraceControllerImpl::
+                   OnContinuousSamplingTraceDataCollected,
+                   base::Unretained(this), events_str_ptr));
+    return;
+  }
+
+  // Drop trace events if we are just getting categories.
+  if (continuous_sampling_subscriber_)
+    continuous_sampling_subscriber_->
+        OnContinuousSamplingTraceDataCollected(events_str_ptr);
+}
+
 void TraceControllerImpl::OnTraceNotification(int notification) {
   // OnTraceNotification may be called from any browser thread, either by the
   // local event trace system or from child processes via TraceMessageFilter.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnTraceNotification,
                    base::Unretained(this), notification));
     return;
   }
 
@@ skipping 31 matching lines @@
     // The last ack represents local trace, so we need to ack it now. Note that
     // this code only executes if there were child processes.
     float bpf = TraceLog::GetInstance()->GetBufferPercentFull();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnTraceBufferPercentFullReply,
                    base::Unretained(this), bpf));
   }
 }
 
 }  // namespace content