tracing: remove sampling state profiler

third_party/WebKit/Source/platform/heap/ThreadState.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 90 matching lines @@
 
 class ParkThreadsScope final {
   STACK_ALLOCATED();
 
  public:
   explicit ParkThreadsScope(ThreadState* state)
       : m_state(state), m_shouldResumeThreads(false) {}
 
   bool parkThreads() {
     TRACE_EVENT0("blink_gc", "ThreadHeap::ParkThreadsScope");
-    const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
-    if (m_state->isMainThread())
-      TRACE_EVENT_SET_SAMPLING_STATE("blink_gc", "BlinkGCWaiting");
 
     // TODO(haraken): In an unlikely coincidence that two threads decide
     // to collect garbage at the same time, avoid doing two GCs in
     // a row and return false.
     double startTime = WTF::currentTimeMS();
 
     m_shouldResumeThreads = m_state->heap().park();
 
     double timeForStoppingThreads = WTF::currentTimeMS() - startTime;
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         CustomCountHistogram, timeToStopThreadsHistogram,
         new CustomCountHistogram("BlinkGC.TimeForStoppingThreads", 1, 1000,
                                  50));
     timeToStopThreadsHistogram.count(timeForStoppingThreads);
 
-    if (m_state->isMainThread())
-      TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
     return m_shouldResumeThreads;
   }
 
   ~ParkThreadsScope() {
     // Only cleanup if we parked all threads in which case the GC happened
     // and we need to resume the other threads.
     if (m_shouldResumeThreads)
       m_state->heap().resume();
   }
 
@@ skipping 1534 matching lines @@
 
   // Try to park the other threads. If we're unable to, bail out of the GC.
   if (!parkThreadsScope.parkThreads())
     return;
 
   ScriptForbiddenIfMainThreadScope scriptForbidden;
 
   TRACE_EVENT2("blink_gc,devtools.timeline", "BlinkGCMarking", "lazySweeping",
                gcType == BlinkGC::GCWithoutSweep, "gcReason",
                gcReasonString(reason));
-  TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
   double startTime = WTF::currentTimeMS();
 
   if (gcType == BlinkGC::TakeSnapshot)
     BlinkGCMemoryDumpProvider::instance()->clearProcessDumpForCurrentGC();
 
   // Disallow allocation during garbage collection (but not during the
   // finalization that happens when the visitorScope is torn down).
   ThreadState::NoAllocationScope noAllocationScope(this);
 
   heap().commitCallbackStacks();
@@ skipping 122 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink