Change base class of V8SamplingProfiler to AsyncEnabledStateObserver.

content/renderer/devtools/v8_sampling_profiler.cc

 // Copyright 2014 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/renderer/devtools/v8_sampling_profiler.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/threading/platform_thread.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 #include "content/renderer/devtools/lock_free_circular_queue.h"
 #include "content/renderer/render_thread_impl.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #define USE_SIGNALS
@@ skipping 546 matching lines @@
 }
 
 void V8SamplingThread::Stop() {
   cancellation_flag_.Set();
   base::PlatformThread::Join(sampling_thread_handle_);
 }
 
 V8SamplingProfiler::V8SamplingProfiler(bool underTest)
     : sampling_thread_(nullptr),
       render_thread_sampler_(Sampler::CreateForCurrentThread()),
-      task_runner_(base::ThreadTaskRunnerHandle::Get()) {
+      weak_factory_(this) {
   DCHECK(underTest || RenderThreadImpl::current());
   // Force the "v8.cpu_profile*" categories to show up in the trace viewer.
   TraceLog::GetCategoryGroupEnabled(
       TRACE_DISABLED_BY_DEFAULT("v8.cpu_profile"));
   TraceLog::GetCategoryGroupEnabled(
       TRACE_DISABLED_BY_DEFAULT("v8.cpu_profile.hires"));
-  TraceLog::GetInstance()->AddEnabledStateObserver(this);
+  TraceLog::GetInstance()->AddAsyncEnabledStateObserver(
+      weak_factory_.GetWeakPtr());
 }
 
 V8SamplingProfiler::~V8SamplingProfiler() {
-  TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
+  TraceLog::GetInstance()->RemoveAsyncEnabledStateObserver(this);
   DCHECK(!sampling_thread_.get());
 }
 
 void V8SamplingProfiler::StartSamplingThread() {
   DCHECK(!sampling_thread_.get());
   sampling_thread_.reset(new V8SamplingThread(
       render_thread_sampler_.get(), waitable_event_for_testing_.get()));
   sampling_thread_->Start();
 }
 
@@ skipping 12 matching lines @@
     return;
 
   // Do not enable sampling profiler in continuous mode, as losing
   // Jit code events may not be afforded.
   // TODO(alph): add support of infinite recording of meta trace events.
   base::trace_event::TraceRecordMode record_mode =
       TraceLog::GetInstance()->GetCurrentTraceConfig().GetTraceRecordMode();
   if (record_mode == base::trace_event::TraceRecordMode::RECORD_CONTINUOUSLY)
     return;
 
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&V8SamplingProfiler::StartSamplingThread,
-                                    base::Unretained(this)));
+  StartSamplingThread();
 }
 
 void V8SamplingProfiler::OnTraceLogDisabled() {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&V8SamplingProfiler::StopSamplingThread,
-                                    base::Unretained(this)));
+  StopSamplingThread();
 }
 
 void V8SamplingProfiler::EnableSamplingEventForTesting(int code_added_events,
                                                        int sample_events) {
   render_thread_sampler_->SetEventsToCollectForTest(code_added_events,
                                                     sample_events);
   waitable_event_for_testing_.reset(new base::WaitableEvent(false, false));
 }
 
 void V8SamplingProfiler::WaitSamplingEventForTesting() {
   waitable_event_for_testing_->Wait();
 }
 
 }  // namespace content