Plumb trace event to WebKit inspector

- add callback that get invoked upon each trace event;
- dispatch trace events to all DevTools agents that have subscribed.

See also https://bugs.webkit.org/show_bug.cgi?id=105796

BUG=none

Review URL: https://codereview.chromium.org/11682007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@184911 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 80 insertions, 0 deletions

diff --git a/base/debug/trace_event_impl.cc b/base/debug/trace_event_impl.cc
index 81687ab..88ac529 100644
--- a/base/debug/trace_event_impl.cc
+++ b/base/debug/trace_event_impl.cc
@@ -820,6 +820,11 @@ void TraceLog::SetNotificationCallback(
   notification_callback_ = cb;
 }
 
+void TraceLog::SetEventCallback(EventCallback cb) {
+  AutoLock lock(lock_);
+  event_callback_ = cb;
+};
+
 void TraceLog::Flush(const TraceLog::OutputCallback& cb) {
   std::vector<TraceEvent> previous_logged_events;
   {
@@ -876,6 +881,8 @@ void TraceLog::AddTraceEventWithThreadIdAndTimestamp(
 #endif
 
   TimeTicks now = timestamp - time_offset_;
+  EventCallback event_callback_copy;
+
   NotificationHelper notifier(this);
 
   {
@@ -929,9 +936,16 @@ void TraceLog::AddTraceEventWithThreadIdAndTimestamp(
 
     if (watch_category_ == category_enabled && watch_event_name_ == name)
       notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
+
+    event_callback_copy = event_callback_;
   }  // release lock
 
   notifier.SendNotificationIfAny();
+  if (event_callback_copy != NULL) {
+    event_callback_copy(phase, category_enabled, name, id,
+        num_args, arg_names, arg_types, arg_values,
+        flags);
+  }
 }
 
 void TraceLog::AddTraceEventEtw(char phase,
diff --git a/base/debug/trace_event_impl.h b/base/debug/trace_event_impl.h
index 193e6b4..42c11dc 100644
--- a/base/debug/trace_event_impl.h
+++ b/base/debug/trace_event_impl.h
@@ -258,6 +258,22 @@ class BASE_EXPORT TraceLog {
   typedef base::Callback<void(int)> NotificationCallback;
   void SetNotificationCallback(const NotificationCallback& cb);
 
+  // Not using base::Callback because of its limited by 7 parameteters.
+  // Also, using primitive type allows directly passsing callback from WebCore.
+  // WARNING: It is possible for the previously set callback to be called
+  // after a call to SetEventCallback() that replaces or clears the callback.
+  // This callback may be invoked on any thread.
+  typedef void (*EventCallback)(char phase,
+                                const unsigned char* category_enabled,
+                                const char* name,
+                                unsigned long long id,
+                                int num_args,
+                                const char* const arg_names[],
+                                const unsigned char arg_types[],
+                                const unsigned long long arg_values[],
+                                unsigned char flags);
+  void SetEventCallback(EventCallback cb);
+
   // Flush all collected events to the given output callback. The callback will
   // be called one or more times with IPC-bite-size chunks. The string format is
   // undefined. Use TraceResultBuffer to convert one or more trace strings to
@@ -399,6 +415,7 @@ class BASE_EXPORT TraceLog {
   Lock lock_;
   int enable_count_;
   NotificationCallback notification_callback_;
+  EventCallback event_callback_;
   std::vector<TraceEvent> logged_events_;
   std::vector<std::string> included_categories_;
   std::vector<std::string> excluded_categories_;
diff --git a/base/debug/trace_event_unittest.cc b/base/debug/trace_event_unittest.cc
index f081f2d..0e3be87 100644
--- a/base/debug/trace_event_unittest.cc
+++ b/base/debug/trace_event_unittest.cc
@@ -1557,5 +1557,54 @@ TEST_F(TraceEventTestFixture, TraceSampling) {
   EXPECT_TRUE(FindNamePhase("Things", "P"));
 }
 
+class TraceEventCallbackTest : public TraceEventTestFixture {
+ public:
+  virtual void SetUp() OVERRIDE {
+    TraceEventTestFixture::SetUp();
+    ManualTestSetUp();
+    ASSERT_EQ(NULL, s_instance);
+    s_instance = this;
+  }
+  virtual void TearDown() OVERRIDE {
+    while (TraceLog::GetInstance()->IsEnabled())
+      TraceLog::GetInstance()->SetDisabled();
+    ASSERT_TRUE(!!s_instance);
+    s_instance = NULL;
+    TraceEventTestFixture::TearDown();
+  }
+
+ protected:
+  std::vector<std::string> collected_events_;
+
+  static TraceEventCallbackTest* s_instance;
+  static void Callback(char phase,
+                       const unsigned char* category_enabled,
+                       const char* name,
+                       unsigned long long id,
+                       int num_args,
+                       const char* const arg_names[],
+                       const unsigned char arg_types[],
+                       const unsigned long long arg_values[],
+                       unsigned char flags) {
+    s_instance->collected_events_.push_back(name);
+  }
+};
+
+TraceEventCallbackTest* TraceEventCallbackTest::s_instance;
+
+TEST_F(TraceEventCallbackTest, TraceEventCallback) {
+  TRACE_EVENT_INSTANT0("all", "before enable");
+  TraceLog::GetInstance()->SetEnabled(true, TraceLog::RECORD_UNTIL_FULL);
+  TRACE_EVENT_INSTANT0("all", "before callback set");
+  TraceLog::GetInstance()->SetEventCallback(Callback);
+  TRACE_EVENT_INSTANT0("all", "event1");
+  TRACE_EVENT_INSTANT0("all", "event2");
+  TraceLog::GetInstance()->SetEventCallback(NULL);
+  TRACE_EVENT_INSTANT0("all", "after callback removed");
+  EXPECT_EQ(2u, collected_events_.size());
+  EXPECT_EQ("event1", collected_events_[0]);
+  EXPECT_EQ("event2", collected_events_[1]);
+}
+
 }  // namespace debug
 }  // namespace base