Category group support/Renamings.

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/string_number_conversions.h"
@@ skipping 36 matching lines @@
 TraceController* TraceController::GetInstance() {
   return TraceControllerImpl::GetInstance();
 }
 
 TraceControllerImpl::TraceControllerImpl() :
     subscriber_(NULL),
     pending_end_ack_count_(0),
     pending_bpf_ack_count_(0),
     maximum_bpf_(0.0f),
     is_tracing_(false),
-    is_get_categories_(false) {
+    is_get_category_groups_(false) {
   TraceLog::GetInstance()->SetNotificationCallback(
       base::Bind(&TraceControllerImpl::OnTraceNotification,
                  base::Unretained(this)));
 }
 
 TraceControllerImpl::~TraceControllerImpl() {
   // No need to SetNotificationCallback(nil) on the TraceLog since this is a
   // Leaky instance.
   NOTREACHED();
 }
@@ skipping 31 matching lines @@
 
   OnTracingBegan(subscriber.get());
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&AutoStopTraceSubscriberStdio::EndStartupTrace,
                  base::Unretained(subscriber.release())),
       base::TimeDelta::FromSeconds(delay_secs));
 }
 
-bool TraceControllerImpl::GetKnownCategoriesAsync(TraceSubscriber* subscriber) {
+bool TraceControllerImpl::GetKnownCategoryGroupsAsync(
+    TraceSubscriber* subscriber) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Known categories come back from child processes with the EndTracingAck
   // message. So to get known categories, just begin and end tracing immediately
   // afterwards. This will ping all the child processes for categories.
-  is_get_categories_ = true;
+  is_get_category_groups_ = true;
   bool success = BeginTracing(subscriber, "*",
                               TraceLog::GetInstance()->trace_options()) &&
                  EndTracingAsync(subscriber);
-  is_get_categories_ = success;
+  is_get_category_groups_ = success;
   return success;
 }
 
-bool TraceControllerImpl::BeginTracing(
-    TraceSubscriber* subscriber,
-    const std::vector<std::string>& included_categories,
-    const std::vector<std::string>& excluded_categories,
-    base::debug::TraceLog::Options options) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!can_begin_tracing(subscriber))
-    return false;
-
-  // Enable tracing
-  TraceLog::GetInstance()->SetEnabled(included_categories, excluded_categories,
-                                      options);
-  OnTracingBegan(subscriber);
-
-  return true;
-}
-
 bool TraceControllerImpl::BeginTracing(TraceSubscriber* subscriber,
-                                       const std::string& categories,
+                                       const std::string& category_patterns,
                                        base::debug::TraceLog::Options options) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_begin_tracing(subscriber))
     return false;
 
   // Enable tracing
-  TraceLog::GetInstance()->SetEnabled(categories, options);
+  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_)
     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> categories;
-    TraceLog::GetInstance()->GetKnownCategories(&categories);
+    std::vector<std::string> category_groups;
+    TraceLog::GetInstance()->GetKnownCategoryGroups(&category_groups);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnEndTracingAck,
-                   base::Unretained(this), categories));
+                   base::Unretained(this), category_groups));
   }
 
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendEndTracing();
   }
 
   return true;
 }
 
@@ skipping 70 matching lines @@
 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()) {
-    filter->SendBeginTracing(included_categories_, excluded_categories_,
-                             trace_options_);
+    std::string cf_str = category_filter_.ToString();
+    filter->SendBeginTracing(cf_str, trace_options_);

[dsinclair, 2013/03/12 21:27:24]

Do you need to store cf_str or can you do
filter->SendBeginTracing(category_filter.ToString(), trace_options_)

[rterrazas, 2013/03/20 08:48:49]

Nope, left it there by mistake. Done.

     if (!watch_category_.empty())
       filter->SendSetWatchEvent(watch_category_, watch_name_);
   }
 }
 
 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;
 
-  TraceLog::GetInstance()->GetEnabledTraceCategories(&included_categories_,
-                                                     &excluded_categories_);
+  category_filter_ = TraceLog::GetInstance()->GetCurrentCategoryFilter();
+  std::string cf_str = category_filter_.ToString();
   trace_options_ = TraceLog::GetInstance()->trace_options();
 
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
-    it->get()->SendBeginTracing(included_categories_, excluded_categories_,
-                                trace_options_);
+    it->get()->SendBeginTracing(cf_str, trace_options_);
   }
 }
 
 void TraceControllerImpl::OnEndTracingAck(
-    const std::vector<std::string>& known_categories) {
+    const std::vector<std::string>& known_category_groups) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnEndTracingAck,
-                   base::Unretained(this), known_categories));
+                   base::Unretained(this), known_category_groups));
     return;
   }
 
-  // Merge known_categories with known_categories_
-  known_categories_.insert(known_categories.begin(), known_categories.end());
+  // Merge known_category_groups with known_category_groups_
+  known_category_groups_.insert(known_category_groups.begin(),
+                                known_category_groups.end());
 
   if (pending_end_ack_count_ == 0)
     return;
 
   if (--pending_end_ack_count_ == 0) {
     // All acks have been received.
     is_tracing_ = false;
 
     // Disable local trace.
     TraceLog::GetInstance()->SetDisabled();
 
     // During this call, our OnTraceDataCollected will be
     // called with the last of the local trace data. Since we are on the UI
     // thread, the call to OnTraceDataCollected will be synchronous, so we can
     // immediately call OnEndTracingComplete below.
     TraceLog::GetInstance()->Flush(
         base::Bind(&TraceControllerImpl::OnTraceDataCollected,
                    base::Unretained(this)));
 
     // Trigger callback if one is set.
     if (subscriber_) {
-      if (is_get_categories_)
-        subscriber_->OnKnownCategoriesCollected(known_categories_);
+      if (is_get_category_groups_)
+        subscriber_->OnKnownCategoriesCollected(known_category_groups_);
       else
         subscriber_->OnEndTracingComplete();
       // Clear subscriber so that others can use TraceController.
       subscriber_ = NULL;
     }
 
-    is_get_categories_ = false;
+    is_get_category_groups_ = false;
   }
 
   if (pending_end_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.
-    std::vector<std::string> categories;
-    TraceLog::GetInstance()->GetKnownCategories(&categories);
+    std::vector<std::string> category_groups;
+    TraceLog::GetInstance()->GetKnownCategoryGroups(&category_groups);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnEndTracingAck,
-                   base::Unretained(this), categories));
+                   base::Unretained(this), category_groups));
   }
 }
 
 void TraceControllerImpl::OnTraceDataCollected(
     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
   // OnTraceDataCollected 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::OnTraceDataCollected,
                    base::Unretained(this), events_str_ptr));
     return;
   }
 
   // Drop trace events if we are just getting categories.
-  if (subscriber_ && !is_get_categories_)
+  if (subscriber_ && !is_get_category_groups_)
     subscriber_->OnTraceDataCollected(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));
@@ skipping 34 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