cross gn

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 455 matching lines @@
       trace_config_.IsCategoryGroupEnabled(category_group)) {
     enabled_flag |= ENABLED_FOR_RECORDING;
   }
 
   if (event_callback_ &&
       event_callback_trace_config_.IsCategoryGroupEnabled(category_group)) {
     enabled_flag |= ENABLED_FOR_EVENT_CALLBACK;
   }
 
 #if defined(OS_WIN)
-  if (base::trace_event::TraceEventETWExport::IsCategoryGroupEnabled(
-          category_group)) {
-    enabled_flag |= ENABLED_FOR_ETW_EXPORT;
-  }
+  //if (base::trace_event::TraceEventETWExport::IsCategoryGroupEnabled(
+          //category_group)) {
+    //enabled_flag |= ENABLED_FOR_ETW_EXPORT;
+  //}
 #endif
 
   // TODO(primiano): this is a temporary workaround for catapult:#2341,
   // to guarantee that metadata events are always added even if the category
   // filter is "-*". See crbug.com/618054 for more details and long-term fix.
   if (mode_ == RECORDING_MODE && !strcmp(category_group, "__metadata"))
     enabled_flag |= ENABLED_FOR_RECORDING;
 
   g_category_group_enabled[category_index] = enabled_flag;
 }
@@ skipping 772 matching lines @@
             existing_name->second.push_back(',');
           existing_name->second.append(new_name);
         }
       }
     }
   }
 
 #if defined(OS_WIN)
   // This is done sooner rather than later, to avoid creating the event and
   // acquiring the lock, which is not needed for ETW as it's already threadsafe.
-  if (*category_group_enabled & ENABLED_FOR_ETW_EXPORT)
-    TraceEventETWExport::AddEvent(phase, category_group_enabled, name, id,
-                                  num_args, arg_names, arg_types, arg_values,
-                                  convertable_values);
+  //if (*category_group_enabled & ENABLED_FOR_ETW_EXPORT)
+    //TraceEventETWExport::AddEvent(phase, category_group_enabled, name, id,
+                                  //num_args, arg_names, arg_types, arg_values,
+                                  //convertable_values);
 #endif  // OS_WIN
 
   std::string console_message;
   if (*category_group_enabled & ENABLED_FOR_RECORDING) {
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = NULL;
     if (thread_local_event_buffer) {
       trace_event = thread_local_event_buffer->AddTraceEvent(&handle);
     } else {
@@ skipping 168 matching lines @@
   if (thread_is_in_trace_event_.Get())
     return;
 
   AutoThreadLocalBoolean thread_is_in_trace_event(&thread_is_in_trace_event_);
 
   ThreadTicks thread_now = ThreadNow();
   TimeTicks now = OffsetNow();
 
 #if defined(OS_WIN)
   // Generate an ETW event that marks the end of a complete event.
-  if (category_group_enabled_local & ENABLED_FOR_ETW_EXPORT)
-    TraceEventETWExport::AddCompleteEndEvent(name);
+  //if (category_group_enabled_local & ENABLED_FOR_ETW_EXPORT)
+    //TraceEventETWExport::AddCompleteEndEvent(name);
 #endif  // OS_WIN
 
   std::string console_message;
   if (category_group_enabled_local & ENABLED_FOR_RECORDING) {
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = GetEventByHandleInternal(handle, &lock);
     if (trace_event) {
       DCHECK(trace_event->phase() == TRACE_EVENT_PHASE_COMPLETE);
       trace_event->UpdateDuration(now, thread_now);
@@ skipping 235 matching lines @@
         kEchoToConsoleTraceEventBufferChunks);
   else if (options & kInternalRecordAsMuchAsPossible)
     return TraceBuffer::CreateTraceBufferVectorOfSize(
         kTraceEventVectorBigBufferChunks);
   return TraceBuffer::CreateTraceBufferVectorOfSize(
       kTraceEventVectorBufferChunks);
 }
 
 #if defined(OS_WIN)
 void TraceLog::UpdateETWCategoryGroupEnabledFlags() {
-  AutoLock lock(lock_);
-  size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
-  // Go through each category and set/clear the ETW bit depending on whether the
-  // category is enabled.
-  for (size_t i = 0; i < category_index; i++) {
-    const char* category_group = g_category_groups[i];
-    DCHECK(category_group);
-    if (base::trace_event::TraceEventETWExport::IsCategoryGroupEnabled(
-            category_group)) {
-      g_category_group_enabled[i] |= ENABLED_FOR_ETW_EXPORT;
-    } else {
-      g_category_group_enabled[i] &= ~ENABLED_FOR_ETW_EXPORT;
-    }
-  }
+  //AutoLock lock(lock_);
+  //size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
+  //// Go through each category and set/clear the ETW bit depending on whether the
+  //// category is enabled.
+  //for (size_t i = 0; i < category_index; i++) {
+  //  const char* category_group = g_category_groups[i];
+  //  DCHECK(category_group);
+  //  if (base::trace_event::TraceEventETWExport::IsCategoryGroupEnabled(
+  //          category_group)) {
+  //    g_category_group_enabled[i] |= ENABLED_FOR_ETW_EXPORT;
+  //  } else {
+  //    g_category_group_enabled[i] &= ~ENABLED_FOR_ETW_EXPORT;
+  //  }
+  //}
 }
 #endif  // defined(OS_WIN)
 
 void ConvertableToTraceFormat::EstimateTraceMemoryOverhead(
     TraceEventMemoryOverhead* overhead) {
   overhead->Add("ConvertableToTraceFormat(Unknown)", sizeof(*this));
 }
 
 void TraceLog::AddAsyncEnabledStateObserver(
     WeakPtr<AsyncEnabledStateObserver> listener) {
@@ skipping 48 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