DevTools: make hitCount optional & experimental in Profiler domain.

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/V8InspectorImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
@@ skipping 26 matching lines @@
         for (unsigned i = 0; i < lineCount; i++) {
             std::unique_ptr<protocol::Profiler::PositionTickInfo> line = protocol::Profiler::PositionTickInfo::create()
                 .setLine(entries[i].line)
                 .setTicks(entries[i].hit_count).build();
             array->addItem(std::move(line));
         }
     }
     return array;
 }
 
-std::unique_ptr<protocol::Profiler::CPUProfileNode> buildInspectorObjectFor(v8::Isolate* isolate, const v8::CpuProfileNode* node)
+std::unique_ptr<protocol::Profiler::ProfileNode> buildInspectorObjectFor(v8::Isolate* isolate, const v8::CpuProfileNode* node)
 {
     v8::HandleScope handleScope(isolate);
     auto callFrame = protocol::Runtime::CallFrame::create()
         .setFunctionName(toProtocolString(node->GetFunctionName()))
         .setScriptId(String16::fromInteger(node->GetScriptId()))
         .setUrl(toProtocolString(node->GetScriptResourceName()))
         .setLineNumber(node->GetLineNumber() - 1)
         .setColumnNumber(node->GetColumnNumber() - 1)
         .build();
-    auto result = protocol::Profiler::CPUProfileNode::create()
+    auto result = protocol::Profiler::ProfileNode::create()
         .setCallFrame(std::move(callFrame))
         .setHitCount(node->GetHitCount())
         .setId(node->GetNodeId()).build();
 
     const int childrenCount = node->GetChildrenCount();
     if (childrenCount) {
         auto children = protocol::Array<int>::create();
         for (int i = 0; i < childrenCount; i++)
             children->addItem(node->GetChild(i)->GetNodeId());
         result->setChildren(std::move(children));
@@ skipping 25 matching lines @@
     int count = v8profile->GetSamplesCount();
     uint64_t lastTime = v8profile->GetStartTime();
     for (int i = 0; i < count; i++) {
         uint64_t ts = v8profile->GetSampleTimestamp(i);
         array->addItem(static_cast<int>(ts - lastTime));
         lastTime = ts;
     }
     return array;
 }
 
-void flattenNodesTree(v8::Isolate* isolate, const v8::CpuProfileNode* node, protocol::Array<protocol::Profiler::CPUProfileNode>* list)
+void flattenNodesTree(v8::Isolate* isolate, const v8::CpuProfileNode* node, protocol::Array<protocol::Profiler::ProfileNode>* list)
 {
     list->addItem(buildInspectorObjectFor(isolate, node));
     const int childrenCount = node->GetChildrenCount();
     for (int i = 0; i < childrenCount; i++)
         flattenNodesTree(isolate, node->GetChild(i), list);
 }
 
-std::unique_ptr<protocol::Profiler::CPUProfile> createCPUProfile(v8::Isolate* isolate, v8::CpuProfile* v8profile)
+std::unique_ptr<protocol::Profiler::Profile> createCPUProfile(v8::Isolate* isolate, v8::CpuProfile* v8profile)
 {
-    auto nodes = protocol::Array<protocol::Profiler::CPUProfileNode>::create();
+    auto nodes = protocol::Array<protocol::Profiler::ProfileNode>::create();
     flattenNodesTree(isolate, v8profile->GetTopDownRoot(), nodes.get());
-
-    auto profile = protocol::Profiler::CPUProfile::create()
+    return protocol::Profiler::Profile::create()
         .setNodes(std::move(nodes))
         .setStartTime(static_cast<double>(v8profile->GetStartTime()))
-        .setEndTime(static_cast<double>(v8profile->GetEndTime())).build();
-    profile->setSamples(buildInspectorObjectForSamples(v8profile));
-    profile->setTimestampDeltas(buildInspectorObjectForTimestamps(v8profile));
-    return profile;
+        .setEndTime(static_cast<double>(v8profile->GetEndTime()))
+        .setSamples(buildInspectorObjectForSamples(v8profile))
+        .setTimeDeltas(buildInspectorObjectForTimestamps(v8profile)).build();
 }
 
 std::unique_ptr<protocol::Debugger::Location> currentDebugLocation(V8InspectorImpl* inspector)
 {
     std::unique_ptr<V8StackTrace> callStack = inspector->captureStackTrace(1);
     auto location = protocol::Debugger::Location::create()
         .setScriptId(callStack->topScriptId())
         .setLineNumber(callStack->topLineNumber()).build();
     location->setColumnNumber(callStack->topColumnNumber());
     return location;
@@ skipping 59 matching lines @@
             if (m_startedProfiles[i].m_title == title) {
                 resolvedTitle = title;
                 id = m_startedProfiles[i].m_id;
                 m_startedProfiles.erase(m_startedProfiles.begin() + i);
                 break;
             }
         }
         if (id.isEmpty())
             return;
     }
-    std::unique_ptr<protocol::Profiler::CPUProfile> profile = stopProfiling(id, true);
+    std::unique_ptr<protocol::Profiler::Profile> profile = stopProfiling(id, true);
     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;
@@ skipping 58 matching lines @@
     if (!m_enabled) {
         *error = "Profiler is not enabled";
         return;
     }
     m_recordingCPUProfile = true;
     m_frontendInitiatedProfileId = nextProfileId();
     startProfiling(m_frontendInitiatedProfileId);
     m_state->setBoolean(ProfilerAgentState::userInitiatedProfiling, true);
 }
 
-void V8ProfilerAgentImpl::stop(ErrorString* errorString, std::unique_ptr<protocol::Profiler::CPUProfile>* profile)
+void V8ProfilerAgentImpl::stop(ErrorString* errorString, std::unique_ptr<protocol::Profiler::Profile>* profile)
 {
     if (!m_recordingCPUProfile) {
         if (errorString)
             *errorString = "No recording profiles found";
         return;
     }
     m_recordingCPUProfile = false;
-    std::unique_ptr<protocol::Profiler::CPUProfile> cpuProfile = stopProfiling(m_frontendInitiatedProfileId, !!profile);
+    std::unique_ptr<protocol::Profiler::Profile> cpuProfile = stopProfiling(m_frontendInitiatedProfileId, !!profile);
     if (profile) {
         *profile = std::move(cpuProfile);
         if (!profile->get() && errorString)
             *errorString = "Profile is not found";
     }
     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);
 }
 
-std::unique_ptr<protocol::Profiler::CPUProfile> V8ProfilerAgentImpl::stopProfiling(const String16& title, bool serialize)
+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));
     if (!profile)
         return nullptr;
-    std::unique_ptr<protocol::Profiler::CPUProfile> result;
+    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