DevTools: introduce collections shim to be backed by non-wtf in v8_inspector.

third_party/WebKit/Source/platform/v8_inspector/V8DebuggerImpl.cpp

 /*
  * Copyright (c) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/Atomics.h"
 #include "platform/v8_inspector/DebuggerScript.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
 #include "platform/v8_inspector/ScriptBreakpoint.h"
 #include "platform/v8_inspector/V8DebuggerAgentImpl.h"
 #include "platform/v8_inspector/V8JavaScriptCallFrame.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
-#include "wtf/Vector.h"
 
 namespace blink {
 
 namespace {
 const char stepIntoV8MethodName[] = "stepIntoStatement";
 const char stepOutV8MethodName[] = "stepOutOfFunction";
 volatile int s_lastContextId = 0;
 
 inline v8::Local<v8::Boolean> v8Boolean(bool value, v8::Isolate* isolate)
 {
@@ skipping 95 matching lines @@
 }
 
 void V8DebuggerImpl::addAgent(int contextGroupId, V8DebuggerAgentImpl* agent)
 {
     ASSERT(contextGroupId);
     ASSERT(!m_agentsMap.contains(contextGroupId));
     if (m_agentsMap.isEmpty())
         enable();
     m_agentsMap.set(contextGroupId, agent);
 
-    Vector<V8DebuggerParsedScript> compiledScripts;
+    protocol::Vector<V8DebuggerParsedScript> compiledScripts;
     getCompiledScripts(contextGroupId, compiledScripts);
     for (size_t i = 0; i < compiledScripts.size(); i++)
         agent->didParseSource(compiledScripts[i]);
 }
 
 void V8DebuggerImpl::removeAgent(int contextGroupId)
 {
     ASSERT(contextGroupId);
     if (!m_agentsMap.contains(contextGroupId))
         return;
 
     if (!m_pausedContext.IsEmpty() && getGroupId(m_pausedContext) == contextGroupId)
         continueProgram();
 
     m_agentsMap.remove(contextGroupId);
 
     if (m_agentsMap.isEmpty())
         disable();
 }
 
 V8DebuggerAgentImpl* V8DebuggerImpl::getAgentForContext(v8::Local<v8::Context> context)
 {
     int groupId = getGroupId(context);
     if (!groupId)
         return nullptr;
     return m_agentsMap.get(groupId);
 }
 
-void V8DebuggerImpl::getCompiledScripts(int contextGroupId, Vector<V8DebuggerParsedScript>& result)
+void V8DebuggerImpl::getCompiledScripts(int contextGroupId, protocol::Vector<V8DebuggerParsedScript>& result)
 {
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
     ASSERT(!debuggerScript->IsUndefined());
     v8::Local<v8::Function> getScriptsFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8InternalizedString("getScripts")));
     v8::Local<v8::Value> argv[] = { v8::Integer::New(m_isolate, contextGroupId) };
     v8::Local<v8::Value> value;
     if (!m_client->callInternalFunction(getScriptsFunction, debuggerScript, WTF_ARRAY_LENGTH(argv), argv).ToLocal(&value))
         return;
     ASSERT(value->IsArray());
     v8::Local<v8::Array> scriptsArray = v8::Local<v8::Array>::Cast(value);
-    result.reserveCapacity(scriptsArray->Length());
+    result.resize(scriptsArray->Length());
     for (unsigned i = 0; i < scriptsArray->Length(); ++i)
-        result.append(createParsedScript(v8::Local<v8::Object>::Cast(scriptsArray->Get(v8::Integer::New(m_isolate, i))), true));
+        result[i] = createParsedScript(v8::Local<v8::Object>::Cast(scriptsArray->Get(v8::Integer::New(m_isolate, i))), true);
 }
 
 String V8DebuggerImpl::setBreakpoint(const String& sourceID, const ScriptBreakpoint& scriptBreakpoint, int* actualLineNumber, int* actualColumnNumber, bool interstatementLocation)
 {
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Object> info = v8::Object::New(m_isolate);
     info->Set(v8InternalizedString("sourceID"), toV8String(m_isolate, sourceID));
     info->Set(v8InternalizedString("lineNumber"), v8::Integer::New(m_isolate, scriptBreakpoint.lineNumber));
@@ skipping 318 matching lines @@
 void V8DebuggerImpl::handleProgramBreak(v8::Local<v8::Context> pausedContext, v8::Local<v8::Object> executionState, v8::Local<v8::Value> exception, v8::Local<v8::Array> hitBreakpointNumbers, bool isPromiseRejection)
 {
     // Don't allow nested breaks.
     if (m_runningNestedMessageLoop)
         return;
 
     V8DebuggerAgentImpl* agent = getAgentForContext(pausedContext);
     if (!agent)
         return;
 
-    Vector<String> breakpointIds;
+    protocol::Vector<String> breakpointIds;
     if (!hitBreakpointNumbers.IsEmpty()) {
         breakpointIds.resize(hitBreakpointNumbers->Length());
         for (size_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
             v8::Local<v8::Value> hitBreakpointNumber = hitBreakpointNumbers->Get(i);
             ASSERT(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
             breakpointIds[i] = String::number(hitBreakpointNumber->Int32Value());
         }
     }
 
     m_pausedContext = pausedContext;
@@ skipping 247 matching lines @@
 }
 
 v8::Local<v8::Context> V8DebuggerImpl::regexContext()
 {
     if (m_regexContext.IsEmpty())
         m_regexContext.Reset(m_isolate, v8::Context::New(m_isolate));
     return m_regexContext.Get(m_isolate);
 }
 
 } // namespace blink