[inspector] change implementation file extension from cpp to cc

src/inspector/V8ProfilerAgentImpl.cpp

Index: src/inspector/V8ProfilerAgentImpl.cpp
diff --git a/src/inspector/V8ProfilerAgentImpl.cpp b/src/inspector/V8ProfilerAgentImpl.cpp
deleted file mode 100644
index dcf4418c65b3e0224318815fd5fdde54830c8d73..0000000000000000000000000000000000000000
--- a/src/inspector/V8ProfilerAgentImpl.cpp
+++ /dev/null
@@ -1,321 +0,0 @@
-// 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/base/atomicops.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>
-
-namespace v8_inspector {
-
-namespace ProfilerAgentState {
-static const char samplingInterval[] = "samplingInterval";
-static const char userInitiatedProfiling[] = "userInitiatedProfiling";
-static const char profilerEnabled[] = "profilerEnabled";
-}
-
-namespace {
-
-std::unique_ptr<protocol::Array<protocol::Profiler::PositionTickInfo>>
-buildInspectorObjectForPositionTicks(const v8::CpuProfileNode* node) {
-  unsigned lineCount = node->GetHitLineCount();
-  if (!lineCount) return nullptr;
-  auto array = protocol::Array<protocol::Profiler::PositionTickInfo>::create();
-  std::vector<v8::CpuProfileNode::LineTick> entries(lineCount);
-  if (node->GetLineTicks(&entries[0], lineCount)) {
-    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::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::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));
-  }
-
-  const char* deoptReason = node->GetBailoutReason();
-  if (deoptReason && deoptReason[0] && strcmp(deoptReason, "no reason"))
-    result->setDeoptReason(deoptReason);
-
-  auto positionTicks = buildInspectorObjectForPositionTicks(node);
-  if (positionTicks) result->setPositionTicks(std::move(positionTicks));
-
-  return result;
-}
-
-std::unique_ptr<protocol::Array<int>> buildInspectorObjectForSamples(
-    v8::CpuProfile* v8profile) {
-  auto array = protocol::Array<int>::create();
-  int count = v8profile->GetSamplesCount();
-  for (int i = 0; i < count; i++)
-    array->addItem(v8profile->GetSample(i)->GetNodeId());
-  return array;
-}
-
-std::unique_ptr<protocol::Array<int>> buildInspectorObjectForTimestamps(
-    v8::CpuProfile* v8profile) {
-  auto array = protocol::Array<int>::create();
-  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::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::Profile> createCPUProfile(
-    v8::Isolate* isolate, v8::CpuProfile* v8profile) {
-  auto nodes = protocol::Array<protocol::Profiler::ProfileNode>::create();
-  flattenNodesTree(isolate, v8profile->GetTopDownRoot(), nodes.get());
-  return protocol::Profiler::Profile::create()
-      .setNodes(std::move(nodes))
-      .setStartTime(static_cast<double>(v8profile->GetStartTime()))
-      .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<V8StackTraceImpl> callStack =
-      inspector->debugger()->captureStackTrace(false /* fullStack */);
-  auto location = protocol::Debugger::Location::create()
-                      .setScriptId(toString16(callStack->topScriptId()))
-                      .setLineNumber(callStack->topLineNumber())
-                      .build();
-  location->setColumnNumber(callStack->topColumnNumber());
-  return location;
-}
-
-volatile int s_lastProfileId = 0;
-
-}  // namespace
-
-class V8ProfilerAgentImpl::ProfileDescriptor {
- public:
-  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->inspector()->isolate()),
-      m_profiler(nullptr),
-      m_state(state),
-      m_frontend(frontendChannel),
-      m_enabled(false),
-      m_recordingCPUProfile(false) {}
-
-V8ProfilerAgentImpl::~V8ProfilerAgentImpl() {
-  if (m_profiler) m_profiler->Dispose();
-}
-
-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);
-}
-
-void V8ProfilerAgentImpl::consoleProfileEnd(const String16& title) {
-  if (!m_enabled) return;
-  String16 id;
-  String16 resolvedTitle;
-  // Take last started profile if no title was passed.
-  if (title.isEmpty()) {
-    if (m_startedProfiles.empty()) return;
-    id = m_startedProfiles.back().m_id;
-    resolvedTitle = m_startedProfiles.back().m_title;
-    m_startedProfiles.pop_back();
-  } else {
-    for (size_t i = 0; i < m_startedProfiles.size(); i++) {
-      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::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;
-  m_enabled = true;
-  DCHECK(!m_profiler);
-  m_profiler = v8::CpuProfiler::New(m_isolate);
-  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);
-  m_profiler->Dispose();
-  m_profiler = nullptr;
-  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);
-  m_profiler->SetSamplingInterval(interval);
-}
-
-void V8ProfilerAgentImpl::restore() {
-  DCHECK(!m_enabled);
-  if (!m_state->booleanProperty(ProfilerAgentState::profilerEnabled, false))
-    return;
-  m_enabled = true;
-  DCHECK(!m_profiler);
-  m_profiler = v8::CpuProfiler::New(m_isolate);
-  int interval = 0;
-  m_state->getInteger(ProfilerAgentState::samplingInterval, &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) {
-    *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::Profile>* profile) {
-  if (!m_recordingCPUProfile) {
-    if (errorString) *errorString = "No recording profiles found";
-    return;
-  }
-  m_recordingCPUProfile = false;
-  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(
-      v8::base::NoBarrier_AtomicIncrement(&s_lastProfileId, 1));
-}
-
-void V8ProfilerAgentImpl::startProfiling(const String16& title) {
-  v8::HandleScope handleScope(m_isolate);
-  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 =
-      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();
-}
-
-bool V8ProfilerAgentImpl::idleStarted() {
-  if (m_profiler) m_profiler->SetIdle(true);
-  return m_profiler;
-}
-
-bool V8ProfilerAgentImpl::idleFinished() {
-  if (m_profiler) m_profiler->SetIdle(false);
-  return m_profiler;
-}
-
-void V8ProfilerAgentImpl::collectSample() {
-  if (m_profiler) m_profiler->CollectSample();
-}
-
-}  // namespace v8_inspector