[inspector] Drop V8_VERSION checks.

src/inspector/V8ProfilerAgentImpl.cpp

 // Copyright 2015 the V8 project 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 "src/inspector/V8ProfilerAgentImpl.h"
 
 #include "src/inspector/Atomics.h"
 #include "src/inspector/StringUtil.h"
 #include "src/inspector/V8Debugger.h"
 #include "src/inspector/V8InspectorImpl.h"
 #include "src/inspector/V8InspectorSessionImpl.h"
 #include "src/inspector/V8StackTraceImpl.h"
 #include "src/inspector/protocol/Protocol.h"
 
 #include "include/v8-profiler.h"
 
 #include <vector>
 
-#define ENSURE_V8_VERSION(major, minor) \
-  (V8_MAJOR_VERSION * 1000 + V8_MINOR_VERSION >= (major)*1000 + (minor))
-
 namespace v8_inspector {
 
 namespace ProfilerAgentState {
 static const char samplingInterval[] = "samplingInterval";
 static const char userInitiatedProfiling[] = "userInitiatedProfiling";
 static const char profilerEnabled[] = "profilerEnabled";
 }
 
 namespace {
 
@@ skipping 123 matching lines @@
     protocol::DictionaryValue* state)
     : m_session(session),
       m_isolate(m_session->inspector()->isolate()),
       m_profiler(nullptr),
       m_state(state),
       m_frontend(frontendChannel),
       m_enabled(false),
       m_recordingCPUProfile(false) {}
 
 V8ProfilerAgentImpl::~V8ProfilerAgentImpl() {
-#if ENSURE_V8_VERSION(5, 4)
   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->inspector()), title);
 }
@@ skipping 24 matching lines @@
   if (!profile) return;
   std::unique_ptr<protocol::Debugger::Location> location =
       currentDebugLocation(m_session->inspector());
   m_frontend.consoleProfileFinished(id, std::move(location), std::move(profile),
                                     resolvedTitle);
 }
 
 void V8ProfilerAgentImpl::enable(ErrorString*) {
   if (m_enabled) return;
   m_enabled = true;
-#if ENSURE_V8_VERSION(5, 4)
   DCHECK(!m_profiler);
   m_profiler = v8::CpuProfiler::New(m_isolate);
-#endif
   m_state->setBoolean(ProfilerAgentState::profilerEnabled, true);
 }
 
 void V8ProfilerAgentImpl::disable(ErrorString* errorString) {
   if (!m_enabled) return;
   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 ENSURE_V8_VERSION(5, 4)
   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->setInteger(ProfilerAgentState::samplingInterval, interval);
-  profiler()->SetSamplingInterval(interval);
+  m_profiler->SetSamplingInterval(interval);
 }
 
 void V8ProfilerAgentImpl::restore() {
   DCHECK(!m_enabled);
   if (!m_state->booleanProperty(ProfilerAgentState::profilerEnabled, false))
     return;
   m_enabled = true;
-#if ENSURE_V8_VERSION(5, 4)
   DCHECK(!m_profiler);
   m_profiler = v8::CpuProfiler::New(m_isolate);
-#endif
   int interval = 0;
   m_state->getInteger(ProfilerAgentState::samplingInterval, &interval);
-  if (interval) profiler()->SetSamplingInterval(interval);
+  if (interval) m_profiler->SetSamplingInterval(interval);
   if (m_state->booleanProperty(ProfilerAgentState::userInitiatedProfiling,
                                false)) {
     ErrorString error;
     start(&error);
   }
 }
 
 void V8ProfilerAgentImpl::start(ErrorString* error) {
   if (m_recordingCPUProfile) return;
   if (!m_enabled) {
@@ skipping 23 matching lines @@
   m_frontendInitiatedProfileId = String16();
   m_state->setBoolean(ProfilerAgentState::userInitiatedProfiling, false);
 }
 
 String16 V8ProfilerAgentImpl::nextProfileId() {
   return String16::fromInteger(atomicIncrement(&s_lastProfileId));
 }
 
 void V8ProfilerAgentImpl::startProfiling(const String16& title) {
   v8::HandleScope handleScope(m_isolate);
-  profiler()->StartProfiling(toV8String(m_isolate, title), true);
+  m_profiler->StartProfiling(toV8String(m_isolate, title), true);
 }
 
 std::unique_ptr<protocol::Profiler::Profile> V8ProfilerAgentImpl::stopProfiling(
     const String16& title, bool serialize) {
   v8::HandleScope handleScope(m_isolate);
   v8::CpuProfile* profile =
-      profiler()->StopProfiling(toV8String(m_isolate, title));
+      m_profiler->StopProfiling(toV8String(m_isolate, title));
   if (!profile) return nullptr;
   std::unique_ptr<protocol::Profiler::Profile> 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 ENSURE_V8_VERSION(5, 4)
-  return m_profiler;
-#else
-  return m_isolate->GetCpuProfiler();
-#endif
-}
-
 }  // namespace v8_inspector