[inspector] Drop V8_VERSION checks.

src/inspector/V8HeapProfilerAgentImpl.cpp

 // Copyright 2016 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/V8HeapProfilerAgentImpl.h"
 
 #include "src/inspector/InjectedScript.h"
 #include "src/inspector/StringUtil.h"
 #include "src/inspector/V8Debugger.h"
 #include "src/inspector/V8InspectorImpl.h"
 #include "src/inspector/V8InspectorSessionImpl.h"
 #include "src/inspector/protocol/Protocol.h"
 
 #include "include/v8-inspector.h"
 #include "include/v8-profiler.h"
 #include "include/v8-version.h"
 
 namespace v8_inspector {
 
 namespace {
 
 namespace HeapProfilerAgentState {
 static const char heapProfilerEnabled[] = "heapProfilerEnabled";
 static const char heapObjectsTrackingEnabled[] = "heapObjectsTrackingEnabled";
 static const char allocationTrackingEnabled[] = "allocationTrackingEnabled";
-#if V8_MAJOR_VERSION >= 5
 static const char samplingHeapProfilerEnabled[] = "samplingHeapProfilerEnabled";
 static const char samplingHeapProfilerInterval[] =
     "samplingHeapProfilerInterval";
-#endif
 }
 
 class HeapSnapshotProgress final : public v8::ActivityControl {
  public:
   HeapSnapshotProgress(protocol::HeapProfiler::Frontend* frontend)
       : m_frontend(frontend) {}
   ControlOption ReportProgressValue(int done, int total) override {
     m_frontend->reportHeapSnapshotProgress(done, total,
                                            protocol::Maybe<bool>());
     if (done >= total) {
@@ skipping 116 matching lines @@
 V8HeapProfilerAgentImpl::~V8HeapProfilerAgentImpl() {}
 
 void V8HeapProfilerAgentImpl::restore() {
   if (m_state->booleanProperty(HeapProfilerAgentState::heapProfilerEnabled,
                                false))
     m_frontend.resetProfiles();
   if (m_state->booleanProperty(
           HeapProfilerAgentState::heapObjectsTrackingEnabled, false))
     startTrackingHeapObjectsInternal(m_state->booleanProperty(
         HeapProfilerAgentState::allocationTrackingEnabled, false));
-#if V8_MAJOR_VERSION >= 5
   if (m_state->booleanProperty(
           HeapProfilerAgentState::samplingHeapProfilerEnabled, false)) {
     ErrorString error;
     double samplingInterval = m_state->doubleProperty(
         HeapProfilerAgentState::samplingHeapProfilerInterval, -1);
     DCHECK_GE(samplingInterval, 0);
     startSampling(&error, Maybe<double>(samplingInterval));
   }
-#endif
 }
 
 void V8HeapProfilerAgentImpl::collectGarbage(ErrorString*) {
   m_isolate->LowMemoryNotification();
 }
 
 void V8HeapProfilerAgentImpl::startTrackingHeapObjects(
     ErrorString*, const protocol::Maybe<bool>& trackAllocations) {
   m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, true);
   bool allocationTrackingEnabled = trackAllocations.fromMaybe(false);
   m_state->setBoolean(HeapProfilerAgentState::allocationTrackingEnabled,
                       allocationTrackingEnabled);
   startTrackingHeapObjectsInternal(allocationTrackingEnabled);
 }
 
 void V8HeapProfilerAgentImpl::stopTrackingHeapObjects(
     ErrorString* error, const protocol::Maybe<bool>& reportProgress) {
   requestHeapStatsUpdate();
   takeHeapSnapshot(error, reportProgress);
   stopTrackingHeapObjectsInternal();
 }
 
 void V8HeapProfilerAgentImpl::enable(ErrorString*) {
   m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, true);
 }
 
 void V8HeapProfilerAgentImpl::disable(ErrorString* error) {
   stopTrackingHeapObjectsInternal();
-#if V8_MAJOR_VERSION >= 5
   if (m_state->booleanProperty(
           HeapProfilerAgentState::samplingHeapProfilerEnabled, false)) {
     v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
     if (profiler) profiler->StopSamplingHeapProfiler();
   }
-#endif
   m_isolate->GetHeapProfiler()->ClearObjectIds();
   m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, false);
 }
 
 void V8HeapProfilerAgentImpl::takeHeapSnapshot(
     ErrorString* errorString, const protocol::Maybe<bool>& reportProgress) {
   v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
   if (!profiler) {
     *errorString = "Cannot access v8 heap profiler";
     return;
@@ skipping 111 matching lines @@
     m_hasTimer = false;
   }
   m_isolate->GetHeapProfiler()->StopTrackingHeapObjects();
   m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled,
                       false);
   m_state->setBoolean(HeapProfilerAgentState::allocationTrackingEnabled, false);
 }
 
 void V8HeapProfilerAgentImpl::startSampling(
     ErrorString* errorString, const Maybe<double>& samplingInterval) {
-#if V8_MAJOR_VERSION >= 5
   v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
   if (!profiler) {
     *errorString = "Cannot access v8 heap profiler";
     return;
   }
   const unsigned defaultSamplingInterval = 1 << 15;
   double samplingIntervalValue =
       samplingInterval.fromMaybe(defaultSamplingInterval);
   m_state->setDouble(HeapProfilerAgentState::samplingHeapProfilerInterval,
                      samplingIntervalValue);
   m_state->setBoolean(HeapProfilerAgentState::samplingHeapProfilerEnabled,
                       true);
-#if V8_MAJOR_VERSION * 1000 + V8_MINOR_VERSION >= 5002
   profiler->StartSamplingHeapProfiler(
       static_cast<uint64_t>(samplingIntervalValue), 128,
       v8::HeapProfiler::kSamplingForceGC);
-#else
-  profiler->StartSamplingHeapProfiler(
-      static_cast<uint64_t>(samplingIntervalValue), 128);
-#endif
-#endif
 }
 
-#if V8_MAJOR_VERSION >= 5
 namespace {
 std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode>
 buildSampingHeapProfileNode(const v8::AllocationProfile::Node* node) {
   auto children = protocol::Array<
       protocol::HeapProfiler::SamplingHeapProfileNode>::create();
   for (const auto* child : node->children)
     children->addItem(buildSampingHeapProfileNode(child));
   size_t selfSize = 0;
   for (const auto& allocation : node->allocations)
     selfSize += allocation.size * allocation.count;
   std::unique_ptr<protocol::Runtime::CallFrame> callFrame =
       protocol::Runtime::CallFrame::create()
           .setFunctionName(toProtocolString(node->name))
           .setScriptId(String16::fromInteger(node->script_id))
           .setUrl(toProtocolString(node->script_name))
           .setLineNumber(node->line_number - 1)
           .setColumnNumber(node->column_number - 1)
           .build();
   std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode> result =
       protocol::HeapProfiler::SamplingHeapProfileNode::create()
           .setCallFrame(std::move(callFrame))
           .setSelfSize(selfSize)
           .setChildren(std::move(children))
           .build();
   return result;
 }
 }  // namespace
-#endif
 
 void V8HeapProfilerAgentImpl::stopSampling(
     ErrorString* errorString,
     std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>* profile) {
-#if V8_MAJOR_VERSION >= 5
   v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
   if (!profiler) {
     *errorString = "Cannot access v8 heap profiler";
     return;
   }
   v8::HandleScope scope(
       m_isolate);  // Allocation profile contains Local handles.
   std::unique_ptr<v8::AllocationProfile> v8Profile(
       profiler->GetAllocationProfile());
   profiler->StopSamplingHeapProfiler();
   m_state->setBoolean(HeapProfilerAgentState::samplingHeapProfilerEnabled,
                       false);
   if (!v8Profile) {
     *errorString = "Cannot access v8 sampled heap profile.";
     return;
   }
   v8::AllocationProfile::Node* root = v8Profile->GetRootNode();
   *profile = protocol::HeapProfiler::SamplingHeapProfile::create()
                  .setHead(buildSampingHeapProfileNode(root))
                  .build();
-#endif
 }
 
 }  // namespace v8_inspector