Revert of [Tracing] Use TracingCategoryObserver in runtime statistics

src/compiler-dispatcher/compiler-dispatcher-tracer.cc

 // Copyright 2016 the V8 project 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 "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
 
 #include "src/isolate.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 double MonotonicallyIncreasingTimeInMs() {
   return V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() *
          static_cast<double>(base::Time::kMillisecondsPerSecond);
 }
 
 }  // namespace
 
 CompilerDispatcherTracer::Scope::Scope(CompilerDispatcherTracer* tracer,
                                        ScopeID scope_id, size_t num)
     : tracer_(tracer), scope_id_(scope_id), num_(num) {
   start_time_ = MonotonicallyIncreasingTimeInMs();
   // TODO(cbruni): remove once we fully moved to a trace-based system.
-  if (V8_UNLIKELY(FLAG_runtime_stats)) {
+  if (TRACE_EVENT_RUNTIME_CALL_STATS_TRACING_ENABLED() ||
+      FLAG_runtime_call_stats) {
     RuntimeCallStats::Enter(tracer_->runtime_call_stats_, &timer_,
                             &RuntimeCallStats::CompilerDispatcher);
   }
 }
 
 CompilerDispatcherTracer::Scope::~Scope() {
   double elapsed = MonotonicallyIncreasingTimeInMs() - start_time_;
   switch (scope_id_) {
     case ScopeID::kPrepareToParse:
       tracer_->RecordPrepareToParse(elapsed);
       break;
     case ScopeID::kParse:
       tracer_->RecordParse(elapsed, num_);
       break;
     case ScopeID::kFinalizeParsing:
       tracer_->RecordFinalizeParsing(elapsed);
       break;
     case ScopeID::kPrepareToCompile:
       tracer_->RecordPrepareToCompile(elapsed);
       break;
     case ScopeID::kCompile:
       tracer_->RecordCompile(elapsed, num_);
       break;
     case ScopeID::kFinalizeCompiling:
       tracer_->RecordFinalizeCompiling(elapsed);
       break;
   }
   // TODO(cbruni): remove once we fully moved to a trace-based system.
-  if (V8_UNLIKELY(FLAG_runtime_stats)) {
+  if (TRACE_EVENT_RUNTIME_CALL_STATS_TRACING_ENABLED() ||
+      FLAG_runtime_call_stats) {
     RuntimeCallStats::Leave(tracer_->runtime_call_stats_, &timer_);
   }
 }
 
 // static
 const char* CompilerDispatcherTracer::Scope::Name(ScopeID scope_id) {
   switch (scope_id) {
     case ScopeID::kPrepareToParse:
       return "V8.BackgroundCompile_PrepareToParse";
     case ScopeID::kParse:
@@ skipping 96 matching lines @@
   std::pair<size_t, double> sum = buffer.Sum(
       [](std::pair<size_t, double> a, std::pair<size_t, double> b) {
         return std::make_pair(a.first + b.first, a.second + b.second);
       },
       std::make_pair(0, 0.0));
   return num * (sum.second / sum.first);
 }
 
 }  // namespace internal
 }  // namespace v8