DevTools: Switch V8ProfilerAgent to use v8::CpuProfiler::New API.

third_party/WebKit/Source/platform/v8_inspector/V8ProfilerAgentImpl.cpp

 // 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 "platform/v8_inspector/V8ProfilerAgentImpl.h"
 
 #include "platform/v8_inspector/Atomics.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
@@ skipping 108 matching lines @@
     ProfileDescriptor(const String16& id, const String16& title)
         : m_id(id)
         , m_title(title) { }
     String16 m_id;
     String16 m_title;
 };
 
 V8ProfilerAgentImpl::V8ProfilerAgentImpl(V8InspectorSessionImpl* session, protocol::FrontendChannel* frontendChannel, protocol::DictionaryValue* state)
     : m_session(session)
     , m_isolate(m_session->debugger()->isolate())
+    , m_profiler(nullptr)
     , m_state(state)
     , m_frontend(frontendChannel)
     , m_enabled(false)
     , m_recordingCPUProfile(false)
 {
 }
 
 V8ProfilerAgentImpl::~V8ProfilerAgentImpl()
 {
+#if V8_MAJOR_VERSION * 100 + V8_MINOR_VERSION >= 504

[pfeldman, 2016/07/08 19:10:08]

I'd rather that we hold off deprecation before v8 inspector is merged into v8.

[alph, 2016/07/08 19:22:10]

It landed today. What's wrong with deprecation?
The plan was to held the old API in v8 for couple releases.

+    if (m_profiler)
+        m_profiler->Dispose();
+#endif
 }
 
 void V8ProfilerAgentImpl::consoleProfile(const String16& title)
 {
     if (!m_enabled)
         return;
     String16 id = nextProfileId();
     m_startedProfiles.push_back(ProfileDescriptor(id, title));
     startProfiling(id);
     m_frontend.consoleProfileStarted(id, currentDebugLocation(m_session->debugger()), title);
@@ skipping 29 matching lines @@
         return;
     std::unique_ptr<protocol::Debugger::Location> location = currentDebugLocation(m_session->debugger());
     m_frontend.consoleProfileFinished(id, std::move(location), std::move(profile), resolvedTitle);
 }
 
 void V8ProfilerAgentImpl::enable(ErrorString*)
 {
     if (m_enabled)
         return;
     m_enabled = true;
+#if V8_MAJOR_VERSION * 100 + V8_MINOR_VERSION >= 504
+    DCHECK(!m_profiler);
+    m_profiler = v8::CpuProfiler::New(m_isolate);
+#endif
     m_state->setBoolean(ProfilerAgentState::profilerEnabled, true);
     m_session->changeInstrumentationCounter(+1);
 }
 
 void V8ProfilerAgentImpl::disable(ErrorString* errorString)
 {
     if (!m_enabled)
         return;
     m_session->changeInstrumentationCounter(-1);
     for (size_t i = m_startedProfiles.size(); i > 0; --i)
         stopProfiling(m_startedProfiles[i - 1].m_id, false);
     m_startedProfiles.clear();
     stop(nullptr, nullptr);
+#if V8_MAJOR_VERSION * 100 + V8_MINOR_VERSION >= 504
+    m_profiler->Dispose();
+    m_profiler = nullptr;
+#endif
     m_enabled = false;
     m_state->setBoolean(ProfilerAgentState::profilerEnabled, false);
 }
 
 void V8ProfilerAgentImpl::setSamplingInterval(ErrorString* error, int interval)
 {
     if (m_recordingCPUProfile) {
         *error = "Cannot change sampling interval when profiling.";
         return;
     }
     m_state->setNumber(ProfilerAgentState::samplingInterval, interval);
-    m_isolate->GetCpuProfiler()->SetSamplingInterval(interval);
+    profiler()->SetSamplingInterval(interval);
 }
 
 void V8ProfilerAgentImpl::restore()
 {
     DCHECK(!m_enabled);
     if (!m_state->booleanProperty(ProfilerAgentState::profilerEnabled, false))
         return;
     m_enabled = true;
     m_session->changeInstrumentationCounter(+1);
     int interval = 0;
     m_state->getNumber(ProfilerAgentState::samplingInterval, &interval);
     if (interval)
-        m_isolate->GetCpuProfiler()->SetSamplingInterval(interval);
+        profiler()->SetSamplingInterval(interval);
     if (m_state->booleanProperty(ProfilerAgentState::userInitiatedProfiling, false)) {
         ErrorString error;
         start(&error);
     }
 }
 
 void V8ProfilerAgentImpl::start(ErrorString* error)
 {
     if (m_recordingCPUProfile)
         return;
@@ skipping 28 matching lines @@
 }
 
 String16 V8ProfilerAgentImpl::nextProfileId()
 {
     return String16::number(atomicIncrement(&s_lastProfileId));
 }
 
 void V8ProfilerAgentImpl::startProfiling(const String16& title)
 {
     v8::HandleScope handleScope(m_isolate);
-    m_isolate->GetCpuProfiler()->StartProfiling(toV8String(m_isolate, title), true);
+    profiler()->StartProfiling(toV8String(m_isolate, title), true);
 }
 
 std::unique_ptr<protocol::Profiler::CPUProfile> V8ProfilerAgentImpl::stopProfiling(const String16& title, bool serialize)
 {
     v8::HandleScope handleScope(m_isolate);
-    v8::CpuProfile* profile = m_isolate->GetCpuProfiler()->StopProfiling(toV8String(m_isolate, title));
+    v8::CpuProfile* profile = profiler()->StopProfiling(toV8String(m_isolate, title));
     if (!profile)
         return nullptr;
     std::unique_ptr<protocol::Profiler::CPUProfile> result;
     if (serialize)
         result = createCPUProfile(m_isolate, profile);
     profile->Delete();
     return result;
 }
 
 bool V8ProfilerAgentImpl::isRecording() const
 {
     return m_recordingCPUProfile || !m_startedProfiles.empty();
 }
 
+v8::CpuProfiler* V8ProfilerAgentImpl::profiler()
+{
+#if V8_MAJOR_VERSION * 100 + V8_MINOR_VERSION >= 504
+    return m_profiler;
+#else
+    return m_isolate->GetCpuProfiler();
+#endif
+}
+
 } // namespace blink