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

third_party/WebKit/Source/platform/v8_inspector/V8DebuggerAgentImpl.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/V8DebuggerAgentImpl.h"
 
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
@@ skipping 74 matching lines @@
 {
     if (a.first != b.first)
         return a.first < b.first;
     return a.second < b.second;
 }
 
 static const LChar hexDigits[17] = "0123456789ABCDEF";
 
 static void appendUnsignedAsHex(unsigned number, String& destination)
 {
-    Vector<LChar, 8> result;
-    do {
-        result.prepend(hexDigits[number % 16]);
-        number >>= 4;
-    } while (number > 0);
-
-    destination.append(result.data(), result.size());
+    for (; number; number >>= 4)

[dgozman, 2016/03/04 02:44:05]

Let's make it fixed length.

+        destination.append(hexDigits[number & 0xF]);
 }
 
 // Hash algorithm for substrings is described in "Über die Komplexität der Multiplikation in
 // eingeschränkten Branchingprogrammmodellen" by Woelfe.
 // http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000
 static String calculateHash(const String& str)
 {
     static uint64_t prime[] = { 0x3FB75161, 0xAB1F4E4F, 0x82675BC5, 0xCD924D35, 0x81ABE279 };
     static uint64_t random[] = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
     static uint32_t randomOdd[] = { 0xB4663807, 0xCC322BF5, 0xD4F91BBD, 0xA7BEA11D, 0x8F462907 };
@@ skipping 268 matching lines @@
     }
     if (breakpointsCookie->get(breakpointId)) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
 
     breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex));
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     for (auto& script : m_scripts) {
-        if (!matches(m_debugger, script.value.sourceURL(), url, isRegex))
+        if (!matches(m_debugger, script.second->sourceURL(), url, isRegex))
             continue;
-        OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(breakpointId, script.key, breakpoint, UserBreakpointSource);
+        OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(breakpointId, script.first, breakpoint, UserBreakpointSource);
         if (location)
             (*locations)->addItem(location.release());
     }
 
     *outBreakpointId = breakpointId;
 }
 
 static bool parseLocation(ErrorString* errorString, PassOwnPtr<protocol::Debugger::Location> location, String* scriptId, int* lineNumber, int* columnNumber)
 {
     *scriptId = location->getScriptId();
@@ skipping 11 matching lines @@
     String scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
         return;
 
     String condition = optionalCondition.fromMaybe("");
 
     String breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, UserBreakpointSource);
-    if (m_breakpointIdToDebuggerBreakpointIds.find(breakpointId) != m_breakpointIdToDebuggerBreakpointIds.end()) {
+    if (m_breakpointIdToDebuggerBreakpointIds.contains(breakpointId)) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     *actualLocation = resolveBreakpoint(breakpointId, scriptId, breakpoint, UserBreakpointSource);
     if (*actualLocation)
         *outBreakpointId = breakpointId;
     else
         *errorString = "Could not resolve breakpoint";
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(ErrorString* errorString, const String& breakpointId)
 {
     if (!checkEnabled(errorString))
         return;
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (breakpointsCookie)
         breakpointsCookie->remove(breakpointId);
     removeBreakpoint(breakpointId);
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(const String& breakpointId)
 {
     ASSERT(enabled());
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     if (debuggerBreakpointIdsIterator == m_breakpointIdToDebuggerBreakpointIds.end())
         return;
-    for (size_t i = 0; i < debuggerBreakpointIdsIterator->value.size(); ++i) {
-        const String& debuggerBreakpointId = debuggerBreakpointIdsIterator->value[i];
+    protocol::Vector<String>* ids = debuggerBreakpointIdsIterator->second;
+    for (size_t i = 0; i < ids->size(); ++i) {
+        const String& debuggerBreakpointId = ids->at(i);
+
         debugger().removeBreakpoint(debuggerBreakpointId);
         m_serverBreakpoints.remove(debuggerBreakpointId);
-        m_muteBreakpoints.remove(debuggerBreakpointId);
     }
-    m_breakpointIdToDebuggerBreakpointIds.remove(debuggerBreakpointIdsIterator);
+    m_breakpointIdToDebuggerBreakpointIds.remove(breakpointId);
 }
 
 void V8DebuggerAgentImpl::continueToLocation(ErrorString* errorString,
     PassOwnPtr<protocol::Debugger::Location> location,
     const protocol::Maybe<bool>& interstateLocationOpt)
 {
     if (!checkEnabled(errorString))
         return;
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
@@ skipping 68 matching lines @@
         return true;
     ScriptsMap::iterator it = m_scripts.find(String::number(frame->sourceID()));
     if (it == m_scripts.end()) {
         // Unknown scripts are blackboxed.
         return true;
     }
     auto itBlackboxedPositions = m_blackboxedPositions.find(String::number(frame->sourceID()));
     if (itBlackboxedPositions == m_blackboxedPositions.end())
         return false;
 
-    const Vector<std::pair<int, int>>& ranges = itBlackboxedPositions->value;
-    auto itRange = std::lower_bound(ranges.begin(), ranges.end(), std::make_pair(frame->line(), frame->column()), positionComparator);
+    protocol::Vector<std::pair<int, int>>* ranges = itBlackboxedPositions->second;
+    auto itRange = std::lower_bound(ranges->begin(), ranges->end(), std::make_pair(frame->line(), frame->column()), positionComparator);
     // Ranges array contains positions in script where blackbox state is changed.
     // [(0,0) ... ranges[0]) isn't blackboxed, [ranges[0] ... ranges[1]) is blackboxed...
-    return std::distance(ranges.begin(), itRange) % 2;
+    return std::distance(ranges->begin(), itRange) % 2;
 }
 
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipExceptionPause()
 {
     if (m_steppingFromFramework)
         return RequestNoSkip;
     if (isTopCallFrameBlackboxed())
         return RequestContinue;
     return RequestNoSkip;
 }
 
-bool V8DebuggerAgentImpl::isMuteBreakpointInstalled()
-{
-    if (!m_muteBreakpoints.size())
-        return false;
-    OwnPtr<JavaScriptCallFrame> frame = debugger().callFrameNoScopes(0);
-    if (!frame)
-        return false;
-    String sourceID = String::number(frame->sourceID());
-    int line = frame->line();
-    for (auto it : m_muteBreakpoints.values()) {
-        if (it.first == sourceID && it.second == line)
-            return true;
-    }
-    return false;
-}
-
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipStepPause()
 {
     if (m_steppingFromFramework)
         return RequestNoSkip;
 
     if (m_skipNextDebuggerStepOut) {
         m_skipNextDebuggerStepOut = false;
         if (m_scheduledDebuggerStep == StepOut)
             return RequestStepOut;
     }
@@ skipping 13 matching lines @@
 
 PassOwnPtr<protocol::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String& breakpointId, const String& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
 {
     ASSERT(enabled());
     // FIXME: remove these checks once crbug.com/520702 is resolved.
     RELEASE_ASSERT(!breakpointId.isEmpty());
     RELEASE_ASSERT(!scriptId.isEmpty());
     ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
     if (scriptIterator == m_scripts.end())
         return nullptr;
-    V8DebuggerScript& script = scriptIterator->value;
-    if (breakpoint.lineNumber < script.startLine() || script.endLine() < breakpoint.lineNumber)
+    V8DebuggerScript* script = scriptIterator->second;
+    if (breakpoint.lineNumber < script->startLine() || script->endLine() < breakpoint.lineNumber)
         return nullptr;
 
     int actualLineNumber;
     int actualColumnNumber;
     String debuggerBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
     if (debuggerBreakpointId.isEmpty())
         return nullptr;
 
     m_serverBreakpoints.set(debuggerBreakpointId, std::make_pair(breakpointId, source));
-    if (breakpoint.condition == "false")
-        m_muteBreakpoints.set(debuggerBreakpointId, std::make_pair(scriptId, breakpoint.lineNumber));
+    RELEASE_ASSERT(!breakpointId.isEmpty());
+    if (!m_breakpointIdToDebuggerBreakpointIds.contains(breakpointId))
+        m_breakpointIdToDebuggerBreakpointIds.set(breakpointId, protocol::Vector<String>());
 
-    RELEASE_ASSERT(!breakpointId.isEmpty());
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
-    if (debuggerBreakpointIdsIterator == m_breakpointIdToDebuggerBreakpointIds.end())
-        m_breakpointIdToDebuggerBreakpointIds.set(breakpointId, Vector<String>()).storedValue->value.append(debuggerBreakpointId);
-    else
-        debuggerBreakpointIdsIterator->value.append(debuggerBreakpointId);
+    debuggerBreakpointIdsIterator->second->append(debuggerBreakpointId);
 
     OwnPtr<protocol::Debugger::Location> location = protocol::Debugger::Location::create()
         .setScriptId(scriptId)
         .setLineNumber(actualLineNumber)
         .setColumnNumber(actualColumnNumber).build();
     return location.release();
 }
 
 void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String& scriptId, const String& query,
     const Maybe<bool>& optionalCaseSensitive,
     const Maybe<bool>& optionalIsRegex,
     OwnPtr<Array<protocol::Debugger::SearchMatch>>* results)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
-        *results = V8ContentSearchUtil::searchInTextByLines(m_debugger, it->value.source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
+        *results = V8ContentSearchUtil::searchInTextByLines(m_debugger, it->second->source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
     else
         *error = "No script for id: " + scriptId;
 }
 
 void V8DebuggerAgentImpl::setScriptSource(ErrorString* error,
     const String& scriptId,
     const String& newContent,
     const Maybe<bool>& preview,
     Maybe<protocol::Array<protocol::Debugger::CallFrame>>* newCallFrames,
     Maybe<bool>* stackChanged,
     Maybe<StackTrace>* asyncStackTrace,
     Maybe<protocol::Debugger::SetScriptSourceError>* optOutCompileError)
 {
     if (!checkEnabled(error))
         return;
     if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), error, optOutCompileError, &m_currentCallStack, stackChanged))
         return;
 
     *newCallFrames = currentCallFrames();
     *asyncStackTrace = currentAsyncStackTrace();
 
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end())
         return;
-    it->value.setSource(newContent);
+    it->second->setSource(newContent);
 }
 
 void V8DebuggerAgentImpl::restartFrame(ErrorString* errorString,
     const String& callFrameId,
     OwnPtr<Array<CallFrame>>* newCallFrames,
     Maybe<StackTrace>* asyncStackTrace)
 {
     if (!isPaused() || m_currentCallStack.IsEmpty()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
@@ skipping 19 matching lines @@
 
 void V8DebuggerAgentImpl::getScriptSource(ErrorString* error, const String& scriptId, String* scriptSource)
 {
     if (!checkEnabled(error))
         return;
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end()) {
         *error = "No script for id: " + scriptId;
         return;
     }
-    *scriptSource = it->value.source();
+    *scriptSource = it->second->source();
 }
 
 void V8DebuggerAgentImpl::getFunctionDetails(ErrorString* errorString, const String& functionId, OwnPtr<FunctionDetails>* details)
 {
     if (!checkEnabled(errorString))
         return;
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(functionId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         return;
@@ skipping 444 matching lines @@
     }
     if (m_frontend && shouldNotify)
         m_frontend->asyncOperationCompleted(operationId);
 }
 
 void V8DebuggerAgentImpl::flushAsyncOperationEvents(ErrorString*)
 {
     if (!m_frontend)
         return;
 
-    for (int operationId : m_asyncOperationNotifications) {
-        V8StackTraceImpl* chain = m_asyncOperations.get(operationId);
+    for (auto& operationId : m_asyncOperationNotifications) {
+        V8StackTraceImpl* chain = m_asyncOperations.get(operationId.first);
         ASSERT(chain);
         if (!chain->isEmpty()) {
             OwnPtr<AsyncOperation> operation = AsyncOperation::create()
-                .setId(operationId)
+                .setId(operationId.first)
                 .setStack(chain->buildInspectorObject()).build();
             m_frontend->asyncOperationStarted(operation.release());
         }
     }
 
     m_asyncOperationNotifications.clear();
 }
 
 void V8DebuggerAgentImpl::clearCurrentAsyncOperation()
 {
@@ skipping 41 matching lines @@
     }
     if (operationId <= 0) {
         *errorString = "Wrong async operation id.";
         return;
     }
     m_asyncOperationBreakpoints.remove(operationId);
 }
 
 void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String& scriptId, PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
 {
-    ScriptsMap::iterator it = m_scripts.find(scriptId);
-    if (it == m_scripts.end()) {
+    if (!m_scripts.contains(scriptId)) {
         *error = "No script with passed id.";
         return;
     }
 
     if (!inPositions->length()) {
         m_blackboxedPositions.remove(scriptId);
         return;
     }
 
-    Vector<std::pair<int, int>> positions(inPositions->length());
+    protocol::Vector<std::pair<int, int>> positions(inPositions->length());
     for (size_t i = 0; i < positions.size(); ++i) {
         protocol::Debugger::ScriptPosition* position = inPositions->get(i);
         if (position->getLine() < 0) {
             *error = "Position missing 'line' or 'line' < 0.";
             return;
         }
         if (position->getColumn() < 0) {
             *error = "Position missing 'column' or 'column' < 0.";
             return;
         }
@@ skipping 153 matching lines @@
         ScriptBreakpoint breakpoint;
         breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber);
         breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber);
         breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
         OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(cookie.first, parsedScript.scriptId, breakpoint, UserBreakpointSource);
         if (location)
             m_frontend->breakpointResolved(cookie.first, location.release());
     }
 }
 
-V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Object> callFrames, v8::Local<v8::Value> exception, const Vector<String>& hitBreakpoints, bool isPromiseRejection)
+V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Object> callFrames, v8::Local<v8::Value> exception, const protocol::Vector<String>& hitBreakpoints, bool isPromiseRejection)
 {
-    if (isMuteBreakpointInstalled())
-        return RequestContinue;
-
     V8DebuggerAgentImpl::SkipPauseRequest result;
     if (m_skipAllPauses)
         result = RequestContinue;
     else if (!hitBreakpoints.isEmpty())
         result = RequestNoSkip; // Don't skip explicit breakpoints even if set in frameworks.
     else if (!exception.IsEmpty())
         result = shouldSkipExceptionPause();
     else if (m_scheduledDebuggerStep != NoStep || m_javaScriptPauseScheduled || m_pausingOnNativeEvent)
         result = shouldSkipStepPause();
     else
@@ skipping 24 matching lines @@
         m_breakReason = protocol::Debugger::Paused::ReasonEnum::AsyncOperation;
         m_breakAuxData = protocol::DictionaryValue::create();
         m_breakAuxData->setNumber("operationId", m_currentAsyncOperationId);
     }
 
     OwnPtr<Array<String>> hitBreakpointIds = Array<String>::create();
 
     for (const auto& point : hitBreakpoints) {
         DebugServerBreakpointToBreakpointIdAndSourceMap::iterator breakpointIterator = m_serverBreakpoints.find(point);
         if (breakpointIterator != m_serverBreakpoints.end()) {
-            const String& localId = breakpointIterator->value.first;
+            const String& localId = breakpointIterator->second->first;
             hitBreakpointIds->addItem(localId);
 
-            BreakpointSource source = breakpointIterator->value.second;
+            BreakpointSource source = breakpointIterator->second->second;
             if (m_breakReason == protocol::Debugger::Paused::ReasonEnum::Other && source == DebugCommandBreakpointSource)
                 m_breakReason = protocol::Debugger::Paused::ReasonEnum::DebugCommand;
         }
     }
 
     if (!m_asyncOperationNotifications.isEmpty())
         flushAsyncOperationEvents(nullptr);
 
     m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData.release(), hitBreakpointIds.release(), currentAsyncStackTrace());
     m_scheduledDebuggerStep = NoStep;
@@ skipping 85 matching lines @@
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink