Switch v8 inspector to stl collections

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"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include <v8-profiler.h>
 
+#include <vector>
+
 namespace blink {
 
 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)
 {
     std::unique_ptr<protocol::Array<protocol::Profiler::PositionTickInfo>> array = protocol::Array<protocol::Profiler::PositionTickInfo>::create();
     unsigned lineCount = node->GetHitLineCount();
     if (!lineCount)
         return array;
 
-    protocol::Vector<v8::CpuProfileNode::LineTick> entries(lineCount);
+    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;
@@ skipping 91 matching lines @@
 
 V8ProfilerAgentImpl::~V8ProfilerAgentImpl()
 {
 }
 
 void V8ProfilerAgentImpl::consoleProfile(const String16& title)
 {
     if (!m_enabled)
         return;
     String16 id = nextProfileId();
-    m_startedProfiles.append(ProfileDescriptor(id, title));
+    m_startedProfiles.push_back(ProfileDescriptor(id, title));
     startProfiling(id);
     m_frontend.consoleProfileStarted(id, currentDebugLocation(m_session->debugger()), 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.isEmpty())
+        if (m_startedProfiles.empty())
             return;
-        id = m_startedProfiles.last().m_id;
-        resolvedTitle = m_startedProfiles.last().m_title;
-        m_startedProfiles.removeLast();
+        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.remove(i);
+                m_startedProfiles.erase(m_startedProfiles.begin() + i);
                 break;
             }
         }
         if (id.isEmpty())
             return;
     }
     std::unique_ptr<protocol::Profiler::CPUProfile> profile = stopProfiling(id, true);
     if (!profile)
         return;
     std::unique_ptr<protocol::Debugger::Location> location = currentDebugLocation(m_session->debugger());
@@ skipping 102 matching lines @@
         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.isEmpty();
+    return m_recordingCPUProfile || !m_startedProfiles.empty();
 }
 
 } // namespace blink