implement SetWatchEvent and WaitForEvent for trace-based-tests

content/browser/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/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 33 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) {
-  TraceLog::GetInstance()->SetOutputCallback(
-      base::Bind(&TraceControllerImpl::OnTraceDataCollected,
+    is_get_categories_(false),
+    watch_num_occurrences_(0) {
+  TraceLog::GetInstance()->SetNotificationCallback(
+      base::Bind(&TraceControllerImpl::OnTraceNotification,
                  base::Unretained(this)));
 }
 
 TraceControllerImpl::~TraceControllerImpl() {
   if (TraceLog* trace_log = TraceLog::GetInstance())
-    trace_log->SetOutputCallback(TraceLog::OutputCallback());
+    trace_log->SetNotificationCallback(TraceLog::NotificationCallback());
 }
 
 TraceControllerImpl* TraceControllerImpl::GetInstance() {
   return Singleton<TraceControllerImpl>::get();
 }
 
 void TraceControllerImpl::InitStartupTracing(const CommandLine& command_line) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath trace_file = command_line.GetSwitchValuePath(
       switches::kTraceStartupFile);
@@ skipping 130 matching lines @@
   }
 
   // Message all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendGetTraceBufferPercentFull();
   }
 
   return true;
 }
 
+bool TraceControllerImpl::SetWatchEvent(TraceSubscriber* subscriber,
+                                        const char* category_name,
+                                        const char* event_name,
+                                        int num_occurrences) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (subscriber != subscriber_)
+    return false;
+
+  watch_num_occurrences_ = num_occurrences;
+  watch_category_ = category_name;
+  watch_name_ = event_name;
+
+  TraceLog::GetInstance()->SetWatchEvent(category_name, event_name,
+                                         num_occurrences);
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it)
+    it->get()->SendSetWatchEvent(category_name, event_name, num_occurrences);
+
+  return true;
+}
+
+bool TraceControllerImpl::CancelWatchEvent(TraceSubscriber* subscriber) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (subscriber != subscriber_)
+    return false;
+
+  watch_num_occurrences_ = 0;
+  watch_category_.clear();
+  watch_name_.clear();
+
+  TraceLog::GetInstance()->CancelWatchEvent();
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it)
+    it->get()->SendCancelWatchEvent();
+
+  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)
       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()) {
     filter->SendBeginTracing(included_categories_, excluded_categories_);
+    if (watch_num_occurrences_ > 0) {
+      filter->SendSetWatchEvent(watch_category_, watch_name_,
+                                watch_num_occurrences_);
+    }
   }
 }
 
 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;
   }
@@ skipping 26 matching lines @@
   // Merge known_categories with known_categories_
   known_categories_.insert(known_categories.begin(), known_categories.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. During this call, our OnTraceDataCollected will be
+    // 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()->SetEnabled(false);
+    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_);
       else
         subscriber_->OnEndTracingComplete();
       // Clear subscriber so that others can use TraceController.
       subscriber_ = NULL;
     }
@@ skipping 21 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_categories_)
     subscriber_->OnTraceDataCollected(events_str_ptr);
 }
 
-void TraceControllerImpl::OnTraceBufferFull() {
-  // OnTraceBufferFull may be called from any browser thread, either by the
+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::OnTraceBufferFull,
-                   base::Unretained(this)));
+        base::Bind(&TraceControllerImpl::OnTraceNotification,
+                   base::Unretained(this), notification));
     return;
   }
 
-  // EndTracingAsync may return false if tracing is already in the process of
-  // being ended. That is ok.
-  EndTracingAsync(subscriber_);
+  switch (static_cast<base::debug::TraceLog::Notification>(notification)) {

[ccameron, 2012/08/21 01:06:34]

The definition of ...::Notification says that the incoming int is a bit mask,
but we're treating it as an enum here (probably easier as an enum).

[jbates, 2012/08/23 22:45:28]

Good catch, fixed this code to check for both flags.

+    case base::debug::TraceLog::TRACE_BUFFER_FULL:
+      // EndTracingAsync may return false if tracing is already in the process
+      // of being ended. That is ok.
+      EndTracingAsync(subscriber_);
+      break;
+    case base::debug::TraceLog::EVENT_WATCH_NOTIFICATION:
+      if (subscriber_)
+        subscriber_->OnEventWatchNotification();
+      break;
+  }
 }
 
 void TraceControllerImpl::OnTraceBufferPercentFullReply(float percent_full) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnTraceBufferPercentFullReply,
                    base::Unretained(this), percent_full));
     return;
   }
 
@@ skipping 12 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