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"
@@ skipping 562 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()) {
+      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,

[alph, 2016/05/11 22:39:51]

Why do we need to post another task? The async state observer should already be
running on the proper thread.

[lpy, 2016/05/11 23:01:52]

Done.

                          base::Bind(&V8SamplingProfiler::StartSamplingThread,
                                     base::Unretained(this)));
 }
 
 void V8SamplingProfiler::OnTraceLogDisabled() {
   task_runner_->PostTask(FROM_HERE,

[alph, 2016/05/11 22:39:51]

ditto

[lpy, 2016/05/11 23:01:52]

Done.

                          base::Bind(&V8SamplingProfiler::StopSamplingThread,
                                     base::Unretained(this)));
 }
 
 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