Revert of Revert "Revert 237280 "Remove TraceController""

content/browser/tracing/tracing_controller_impl.cc

 // Copyright 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/file_util.h"
 #include "base/json/string_escape.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/tracing/trace_message_filter.h"
 #include "content/common/child_process_messages.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/common/content_switches.h"
 
 using base::debug::TraceLog;
 
@@ skipping 93 matching lines @@
 
 
 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),
     // Tracing may have been enabled by ContentMainRunner if kTraceStartup
     // is specified in command line.
     is_recording_(TraceLog::GetInstance()->IsEnabled()),
-    is_monitoring_(false) {
+    is_monitoring_(false),
+    category_filter_(
+        base::debug::CategoryFilter::kDefaultCategoryFilterString) {
 }
 
 TracingControllerImpl::~TracingControllerImpl() {
   // This is a Leaky instance.
   NOTREACHED();
 }
 
 TracingControllerImpl* TracingControllerImpl::GetInstance() {
   return g_controller.Pointer();
 }
 
-bool TracingControllerImpl::GetCategories(
+void TracingControllerImpl::GetCategories(
     const GetCategoriesDoneCallback& callback) {
   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.
   pending_get_categories_done_callback_ = callback;
-  if (!EnableRecording("*", TracingController::Options(),
-                       EnableRecordingDoneCallback())) {
-    pending_get_categories_done_callback_.Reset();
-    return false;
-  }
-
-  bool ok = DisableRecording(base::FilePath(), TracingFileResultCallback());
-  DCHECK(ok);
-  return true;
+  EnableRecording(base::debug::CategoryFilter("*"),
+                  TracingController::Options(),
+                  EnableRecordingDoneCallback());
+  DisableRecording(base::FilePath(), TracingFileResultCallback());
 }
 
 bool TracingControllerImpl::EnableRecording(
-    const std::string& category_filter,
+    const base::debug::CategoryFilter& filter,
     TracingController::Options options,
     const EnableRecordingDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_enable_recording())
     return false;
 
 #if defined(OS_ANDROID)
   if (pending_get_categories_done_callback_.is_null())
     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
   TraceLog::Options trace_options = (options & RECORD_CONTINUOUSLY) ?
       TraceLog::RECORD_CONTINUOUSLY : TraceLog::RECORD_UNTIL_FULL;
   if (options & ENABLE_SAMPLING) {
     trace_options = static_cast<TraceLog::Options>(
         trace_options | TraceLog::ENABLE_SAMPLING);
   }
   // TODO(haraken): How to handle ENABLE_SYSTRACE?
 
-  TraceLog::GetInstance()->SetEnabled(
-      base::debug::CategoryFilter(category_filter), trace_options);
+  TraceLog::GetInstance()->SetEnabled(filter, trace_options);
   is_recording_ = true;
+  category_filter_ = TraceLog::GetInstance()->GetCurrentCategoryFilter();
 
   // Notify all child processes.
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
-    it->get()->SendBeginTracing(category_filter, trace_options);
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
+    it->get()->SendBeginTracing(category_filter_.ToString(), trace_options);
   }
 
   if (!callback.is_null())
     callback.Run();
   return true;
 }
 
 bool TracingControllerImpl::DisableRecording(
     const base::FilePath& result_file_path,
     const TracingFileResultCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_disable_recording())
     return false;
 
   pending_disable_recording_done_callback_ = callback;
 
   // Disable local trace early to avoid traces during end-tracing process from
   // interfering with the process.
   TraceLog::GetInstance()->SetDisabled();
 
 #if defined(OS_ANDROID)
   if (pending_get_categories_done_callback_.is_null())
     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
   if (!callback.is_null() || !result_file_path.empty())
     result_file_.reset(new ResultFile(result_file_path));
 
+  // 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 OnDisableRecordingAcked code.
   // Count myself (local trace) in pending_disable_recording_ack_count_,
   // acked below.
-  pending_disable_recording_ack_count_ = trace_message_filters_.size() + 1;
+  pending_disable_recording_ack_count_ = filters_.size() + 1;
 
-  // Handle special case of zero child processes by immediately telling the
-  // caller that tracing has ended. Use asynchronous OnDisableRecordingAcked
-  // to avoid recursive call back to the caller.
+  // Handle special case of zero child processes.
   if (pending_disable_recording_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(&TracingControllerImpl::OnDisableRecordingAcked,
                    base::Unretained(this), category_groups));
   }
 
   // Notify all child processes.
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendEndTracing();
   }
   return true;
 }
 
 bool TracingControllerImpl::EnableMonitoring(
-    const std::string& category_filter,
+    const base::debug::CategoryFilter& filter,
     TracingController::Options options,
     const EnableMonitoringDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_enable_monitoring())
     return false;
   is_monitoring_ = true;
 
 #if defined(OS_ANDROID)
   TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
   int monitoring_tracing_options = 0;
   if (options & ENABLE_SAMPLING)
     monitoring_tracing_options |= base::debug::TraceLog::MONITOR_SAMPLING;
 
   TraceLog::GetInstance()->SetEnabled(
-      base::debug::CategoryFilter(category_filter),
-      static_cast<TraceLog::Options>(monitoring_tracing_options));
+      filter, base::debug::TraceLog::Options(monitoring_tracing_options));
 
   // Notify all child processes.
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
-    it->get()->SendEnableMonitoring(category_filter,
-        static_cast<TraceLog::Options>(monitoring_tracing_options));
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
+    it->get()->SendEnableMonitoring(filter.ToString(),
+        base::debug::TraceLog::Options(monitoring_tracing_options));
   }
 
   if (!callback.is_null())
     callback.Run();
   return true;
 }
 
 bool TracingControllerImpl::DisableMonitoring(
     const DisableMonitoringDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_disable_monitoring())
     return false;
   is_monitoring_ = false;
 
   TraceLog::GetInstance()->SetDisabled();
 
   // Notify all child processes.
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendDisableMonitoring();
   }
 
   if (!callback.is_null())
     callback.Run();
   return true;
 }
 
 void TracingControllerImpl::GetMonitoringStatus(
     bool* out_enabled,
-    std::string* out_category_filter,
+    base::debug::CategoryFilter* out_filter,
     TracingController::Options* out_options) {
   NOTIMPLEMENTED();
 }
 
-bool TracingControllerImpl::CaptureMonitoringSnapshot(
+void TracingControllerImpl::CaptureMonitoringSnapshot(
     const base::FilePath& result_file_path,
     const TracingFileResultCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_disable_monitoring())
-    return false;
+    return;
 
   if (callback.is_null() && result_file_path.empty())
-    return false;
+    return;
 
   pending_capture_monitoring_snapshot_done_callback_ = callback;
   monitoring_snapshot_file_.reset(new ResultFile(result_file_path));
 
+  // 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 OnCaptureMonitoringSnapshotAcked code.
   // Count myself in pending_capture_monitoring_snapshot_ack_count_,
   // acked below.
-  pending_capture_monitoring_snapshot_ack_count_ =
-      trace_message_filters_.size() + 1;
+  pending_capture_monitoring_snapshot_ack_count_ = filters_.size() + 1;
 
-  // Handle special case of zero child processes by immediately telling the
-  // caller that capturing snapshot has ended. Use asynchronous
-  // OnCaptureMonitoringSnapshotAcked to avoid recursive call back to the
-  // caller.
+  // Handle special case of zero child processes.
   if (pending_capture_monitoring_snapshot_ack_count_ == 1) {
     // Ack asynchronously now, because we don't have any children to wait for.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::OnCaptureMonitoringSnapshotAcked,
                    base::Unretained(this)));
   }
 
   // Notify all child processes.
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendCaptureMonitoringSnapshot();
   }
 
 #if defined(OS_ANDROID)
   TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
-
-  return true;
 }
 
 bool TracingControllerImpl::GetTraceBufferPercentFull(
     const GetTraceBufferPercentFullCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_get_trace_buffer_percent_full() || callback.is_null())
     return false;
 
   pending_trace_buffer_percent_full_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_ack_count_ = filters_.size() + 1;
   maximum_trace_buffer_percent_full_ = 0;
 
   // Handle special case of zero child processes.
   if (pending_trace_buffer_percent_full_ack_count_ == 1) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::OnTraceBufferPercentFullReply,
                    base::Unretained(this),
                    TraceLog::GetInstance()->GetBufferPercentFull()));
   }
 
   // Notify all child processes.
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
+  for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendGetTraceBufferPercentFull();
   }
   return true;
 }
 
-bool TracingControllerImpl::SetWatchEvent(
-    const std::string& category_name,
-    const std::string& event_name,
-    const WatchEventCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (callback.is_null())
-    return false;
-
-  watch_category_name_ = category_name;
-  watch_event_name_ = event_name;
-  watch_event_callback_ = callback;
-
-  TraceLog::GetInstance()->SetWatchEvent(
-      category_name, event_name,
-      base::Bind(&TracingControllerImpl::OnWatchEventMatched,
-                 base::Unretained(this)));
-
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
-    it->get()->SendSetWatchEvent(category_name, event_name);
-  }
-  return true;
-}
-
-bool TracingControllerImpl::CancelWatchEvent() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!can_cancel_watch_event())
-    return false;
-
-  for (TraceMessageFilterMap::iterator it = trace_message_filters_.begin();
-      it != trace_message_filters_.end(); ++it) {
-    it->get()->SendCancelWatchEvent();
-  }
-
-  watch_event_callback_.Reset();
-  return true;
-}
-
-void TracingControllerImpl::AddTraceMessageFilter(
-    TraceMessageFilter* trace_message_filter) {
+void TracingControllerImpl::AddFilter(TraceMessageFilter* filter) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&TracingControllerImpl::AddTraceMessageFilter,
-                   base::Unretained(this),
-                   make_scoped_refptr(trace_message_filter)));
+        base::Bind(&TracingControllerImpl::AddFilter, base::Unretained(this),
+                   make_scoped_refptr(filter)));
     return;
   }
 
-  trace_message_filters_.insert(trace_message_filter);
-  if (can_cancel_watch_event()) {
-    trace_message_filter->SendSetWatchEvent(watch_category_name_,
-                                            watch_event_name_);
-  }
+  filters_.insert(filter);
   if (can_disable_recording()) {
-    trace_message_filter->SendBeginTracing(
-        TraceLog::GetInstance()->GetCurrentCategoryFilter().ToString(),
-        TraceLog::GetInstance()->trace_options());
+    std::string cf_str = category_filter_.ToString();
+    filter->SendBeginTracing(cf_str, TraceLog::GetInstance()->trace_options());
   }
 }
 
-void TracingControllerImpl::RemoveTraceMessageFilter(
-    TraceMessageFilter* trace_message_filter) {
+void TracingControllerImpl::RemoveFilter(TraceMessageFilter* filter) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&TracingControllerImpl::RemoveTraceMessageFilter,
-                   base::Unretained(this),
-                   make_scoped_refptr(trace_message_filter)));
+        base::Bind(&TracingControllerImpl::RemoveFilter, base::Unretained(this),
+                   make_scoped_refptr(filter)));
     return;
   }
 
-  trace_message_filters_.erase(trace_message_filter);
+  filters_.erase(filter);
 }
 
 void TracingControllerImpl::OnDisableRecordingAcked(
     const std::vector<std::string>& known_category_groups) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::OnDisableRecordingAcked,
                    base::Unretained(this), known_category_groups));
     return;
   }
 
   // Merge known_category_groups with known_category_groups_
   known_category_groups_.insert(known_category_groups.begin(),
                                 known_category_groups.end());
 
   if (pending_disable_recording_ack_count_ == 0)
     return;
 
   if (--pending_disable_recording_ack_count_ == 1) {
     // All acks from subprocesses have been received. Now flush the local trace.
     // During or after this call, our OnLocalTraceDataCollected will be
     // called with the last of the local trace data.
     TraceLog::GetInstance()->Flush(
         base::Bind(&TracingControllerImpl::OnLocalTraceDataCollected,
                    base::Unretained(this)));
-    return;
   }
 
   if (pending_disable_recording_ack_count_ != 0)
     return;
 
   // All acks (including from the subprocesses and the local trace) have been
   // received.
   is_recording_ = false;
 
   // Trigger callback if one is set.
@@ skipping 31 matching lines @@
   if (pending_capture_monitoring_snapshot_ack_count_ == 0)
     return;
 
   if (--pending_capture_monitoring_snapshot_ack_count_ == 1) {
     // All acks from subprocesses have been received. Now flush the local trace.
     // During or after this call, our OnLocalMonitoringTraceDataCollected
     // will be called with the last of the local trace data.
     TraceLog::GetInstance()->FlushButLeaveBufferIntact(
         base::Bind(&TracingControllerImpl::OnLocalMonitoringTraceDataCollected,
                    base::Unretained(this)));
-    return;
   }
 
   if (pending_capture_monitoring_snapshot_ack_count_ != 0)
     return;
 
   if (monitoring_snapshot_file_) {
     monitoring_snapshot_file_->Close(
         base::Bind(&TracingControllerImpl::OnMonitoringSnapshotFileClosed,
                    base::Unretained(this)));
   }
@@ skipping 93 matching lines @@
   if (pending_trace_buffer_percent_full_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(&TracingControllerImpl::OnTraceBufferPercentFullReply,
                    base::Unretained(this),
                    TraceLog::GetInstance()->GetBufferPercentFull()));
   }
 }
 
-void TracingControllerImpl::OnWatchEventMatched() {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&TracingControllerImpl::OnWatchEventMatched,
-                   base::Unretained(this)));
-  }
-
-  if (!watch_event_callback_.is_null())
-    watch_event_callback_.Run();
-}
-
 }  // namespace content