tracing: remove WatchEvent feature

base/trace_event/trace_log.cc

 // Copyright 2015 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 "base/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 450 matching lines @@
   return Singleton<TraceLog, LeakySingletonTraits<TraceLog>>::get();
 }
 
 TraceLog::TraceLog()
     : enabled_modes_(0),
       num_traces_recorded_(0),
       dispatching_to_observer_list_(false),
       process_sort_index_(0),
       process_id_hash_(0),
       process_id_(0),
-      watch_category_(0),
       trace_options_(kInternalRecordUntilFull),
       trace_config_(TraceConfig()),
       thread_shared_chunk_index_(0),
       generation_(0),
       use_worker_thread_(false) {
   // Trace is enabled or disabled on one thread while other threads are
   // accessing the enabled flag. We don't care whether edge-case events are
   // traced or not, so we allow races on the enabled flag to keep the trace
   // macros fast.
   // TODO(jbates): ANNOTATE_BENIGN_RACE_SIZED crashes windows TSAN bots:
@@ skipping 395 matching lines @@
 
   bool is_recording_mode_disabled =
       (enabled_modes_ & RECORDING_MODE) && (modes_to_disable & RECORDING_MODE);
   enabled_modes_ &= ~modes_to_disable;
 
   if (modes_to_disable & FILTERING_MODE)
     enabled_event_filters_.clear();
 
   if (modes_to_disable & RECORDING_MODE) {
     trace_config_.Clear();
-
-    subtle::NoBarrier_Store(&watch_category_, 0);
-    watch_event_name_.clear();
   }
 
   UpdateCategoryGroupEnabledFlags();
 
   // Add metadata events and notify observers only if recording mode was
   // disabled now.
   if (!is_recording_mode_disabled)
     return;
 
   AddMetadataEventsWhileLocked();
@@ skipping 574 matching lines @@
     if (trace_options() & kInternalEchoToConsole) {
       console_message = EventToConsoleMessage(
           phase == TRACE_EVENT_PHASE_COMPLETE ? TRACE_EVENT_PHASE_BEGIN : phase,
           timestamp, trace_event);
     }
   }
 
   if (!console_message.empty())
     LOG(ERROR) << console_message;
 
-  if (reinterpret_cast<const unsigned char*>(
-          subtle::NoBarrier_Load(&watch_category_)) == category_group_enabled) {
-    bool event_name_matches;
-    WatchEventCallback watch_event_callback_copy;
-    {
-      AutoLock lock(lock_);
-      event_name_matches = watch_event_name_ == name;
-      watch_event_callback_copy = watch_event_callback_;
-    }
-    if (event_name_matches) {
-      if (!watch_event_callback_copy.is_null())
-        watch_event_callback_copy.Run();
-    }
-  }
-
   return handle;
 }
 
 void TraceLog::AddMetadataEvent(
     const unsigned char* category_group_enabled,
     const char* name,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
@@ skipping 131 matching lines @@
     }
   }
 
   if (!console_message.empty())
     LOG(ERROR) << console_message;
 
   if (category_group_enabled_local & ENABLED_FOR_FILTERING)
     EndFilteredEvent(category_group_enabled, name, handle);
 }
 
-void TraceLog::SetWatchEvent(const std::string& category_name,
-                             const std::string& event_name,
-                             const WatchEventCallback& callback) {
-  const unsigned char* category =
-      GetCategoryGroupEnabled(category_name.c_str());
-  AutoLock lock(lock_);
-  subtle::NoBarrier_Store(&watch_category_,
-                          reinterpret_cast<subtle::AtomicWord>(category));
-  watch_event_name_ = event_name;
-  watch_event_callback_ = callback;
-}
-
-void TraceLog::CancelWatchEvent() {
-  AutoLock lock(lock_);
-  subtle::NoBarrier_Store(&watch_category_, 0);
-  watch_event_name_.clear();
-  watch_event_callback_.Reset();
-}
-
 uint64_t TraceLog::MangleEventId(uint64_t id) {
   return id ^ process_id_hash_;
 }
 
 void TraceLog::AddMetadataEventsWhileLocked() {
   lock_.AssertAcquired();
 
   // Move metadata added by |AddMetadataEvent| into the trace log.
   while (!metadata_events_.empty()) {
     TraceEvent* event = AddEventToThreadSharedChunkWhileLocked(nullptr, false);
@@ skipping 249 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal