[DevTools] Added setBlackboxPatterns method to protocol

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 28 matching lines @@
 using blink::protocol::Runtime::RemoteObject;
 
 namespace blink {
 
 namespace DebuggerAgentState {
 static const char javaScriptBreakpoints[] = "javaScriptBreakopints";
 static const char pauseOnExceptionsState[] = "pauseOnExceptionsState";
 static const char asyncCallStackDepth[] = "asyncCallStackDepth";
 static const char promiseTrackerEnabled[] = "promiseTrackerEnabled";
 static const char promiseTrackerCaptureStacks[] = "promiseTrackerCaptureStacks";
+static const char blackboxState[] = "blackboxState";
 
 // Breakpoint properties.
 static const char url[] = "url";
 static const char isRegex[] = "isRegex";
 static const char lineNumber[] = "lineNumber";
 static const char columnNumber[] = "columnNumber";
 static const char condition[] = "condition";
 static const char skipAllPauses[] = "skipAllPauses";
 
 } // namespace DebuggerAgentState;
 
 static const int maxSkipStepFrameCount = 128;
 
 const char V8DebuggerAgent::backtraceObjectGroup[] = "backtrace";
 
 const int V8DebuggerAgent::unknownAsyncOperationId = 0;
 
+const char hashPrefix[] = "hash:";
+const char urlPrefix[] = "url:";
+
 static String breakpointIdSuffix(V8DebuggerAgentImpl::BreakpointSource source)
 {
     switch (source) {
     case V8DebuggerAgentImpl::UserBreakpointSource:
         break;
     case V8DebuggerAgentImpl::DebugCommandBreakpointSource:
         return ":debug";
     case V8DebuggerAgentImpl::MonitorCommandBreakpointSource:
         return ":monitor";
     }
@@ skipping 15 matching lines @@
 static const LChar hexDigits[17] = "0123456789ABCDEF";
 
 static void appendUnsignedAsHex(unsigned number, String& destination)
 {
     for (size_t i = 0; i < 8; ++i) {
         destination.append(hexDigits[number & 0xF]);
         number >>= 4;
     }
 }
 
+static bool parseBlackboxPositions(ErrorString* error, protocol::Array<protocol::Debugger::ScriptPosition>* inPositions, protocol::Vector<std::pair<int, int>>* outPositions)
+{
+    if (!inPositions) {
+        protocol::Vector<std::pair<int, int>> blackboxed(1);
+        outPositions->swap(blackboxed);
+        return true;
+    }
+    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) {
+            if (error)
+                *error = "Position 'line' < 0.";
+            return false;
+        }
+        if (position->getColumn() < 0) {
+            if (error)
+                *error = "Position 'column' < 0.";
+            return false;
+        }
+        positions[i] = std::make_pair(position->getLine(), position->getColumn());
+    }
+
+    for (size_t i = 1; i < positions.size(); ++i) {
+        if (positions[i - 1].first < positions[i].first)
+            continue;
+        if (positions[i - 1].first == positions[i].first && positions[i - 1].second < positions[i].second)
+            continue;
+        if (error)
+            *error = "Input positions array is not sorted or contains duplicate values.";
+        return false;
+    }
+
+    outPositions->swap(positions);
+    return true;
+}
+
 // 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 };
 
     uint64_t hashes[] = { 0, 0, 0, 0, 0 };
@@ skipping 122 matching lines @@
     m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, protocol::DictionaryValue::create());
     m_state->setNumber(DebuggerAgentState::pauseOnExceptionsState, V8DebuggerImpl::DontPauseOnExceptions);
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, 0);
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
     m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, false);
 
     debugger().removeAgent(m_contextGroupId);
     m_pausedContext.Reset();
     m_currentCallStack.Reset();
     m_scripts.clear();
-    m_blackboxedPositions.clear();
+
+    m_scriptToBlackboxPositions.clear();
+    m_blackboxRegexpPattern = String();
+
     m_breakpointIdToDebuggerBreakpointIds.clear();
     internalSetAsyncCallStackDepth(0);
     m_promiseTracker->setEnabled(false, false);
     m_continueToLocationBreakpointId = String();
     clearBreakDetails();
     m_scheduledDebuggerStep = NoStep;
     m_skipNextDebuggerStepOut = false;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
@@ skipping 40 matching lines @@
     m_state->getNumber(DebuggerAgentState::pauseOnExceptionsState, &pauseState);
     setPauseOnExceptionsImpl(&error, pauseState);
 
     m_skipAllPauses = m_state->booleanProperty(DebuggerAgentState::skipAllPauses, false);
 
     int asyncCallStackDepth = 0;
     m_state->getNumber(DebuggerAgentState::asyncCallStackDepth, &asyncCallStackDepth);
     internalSetAsyncCallStackDepth(asyncCallStackDepth);
 
     m_promiseTracker->setEnabled(m_state->booleanProperty(DebuggerAgentState::promiseTrackerEnabled, false), m_state->booleanProperty(DebuggerAgentState::promiseTrackerCaptureStacks, false));
+
+    restoreBlackboxState();
+}
+
+void V8DebuggerAgentImpl::restoreBlackboxState()
+{
+    protocol::ListValue* patternsState = m_state->getArray(DebuggerAgentState::blackboxState);
+    if (!patternsState)
+        return;
+    protocol::ErrorSupport errors;
+    OwnPtr<protocol::Array<protocol::Debugger::BlackboxPattern>> patterns = protocol::Array<protocol::Debugger::BlackboxPattern>::parse(patternsState, &errors);
+    ASSERT(!errors.hasErrors());
+
+    ErrorString error;
+    addBlackboxPatterns(&error, patterns.release());
+    ASSERT(error.isEmpty());
 }
 
 void V8DebuggerAgentImpl::setBreakpointsActive(ErrorString* errorString, bool active)
 {
     if (!checkEnabled(errorString))
         return;
     debugger().setBreakpointsActivated(active);
 }
 
 void V8DebuggerAgentImpl::setSkipAllPauses(ErrorString*, bool skipped)
@@ skipping 212 matching lines @@
 bool V8DebuggerAgentImpl::isTopCallFrameBlackboxed()
 {
     ASSERT(enabled());
     return isCallFrameWithUnknownScriptOrBlackboxed(debugger().callFrameNoScopes(0).get());
 }
 
 bool V8DebuggerAgentImpl::isCallFrameWithUnknownScriptOrBlackboxed(JavaScriptCallFrame* frame)
 {
     if (!frame)
         return true;
-    ScriptsMap::iterator it = m_scripts.find(String::number(frame->sourceID()));
+    String scriptId = String::number(frame->sourceID());
+    ScriptsMap::iterator it = m_scripts.find(scriptId);
     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())
+
+    const protocol::Vector<std::pair<int, int>>* ranges = nullptr;
+
+    V8DebuggerScript& script = *(it->second);
+    auto itBlackboxHash = m_scriptToBlackboxPositions.find(script.hasSourceURL() ? urlPrefix + script.url() : hashPrefix + script.hash());

[dgozman, 2016/03/08 18:48:12]

I think it's not worth to add strings in this hot function. Let's forget about
collisions.

+    if (itBlackboxHash != m_scriptToBlackboxPositions.end()) {
+        ranges = itBlackboxHash->second;
+    } else {
+        if (!script.sourceURL().isEmpty() && !m_blackboxRegexpPattern.isEmpty() && matches(m_debugger, script.sourceURL(), m_blackboxRegexpPattern, true)) {
+            protocol::Vector<std::pair<int, int>> blackboxedSourcePositions(1);

[dgozman, 2016/03/08 18:48:12]

Explicit.

+            m_scriptToBlackboxPositions.set(urlPrefix + script.sourceURL(), blackboxedSourcePositions);
+            return true;
+        }
         return false;
+    }
 
-    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;
 }
 
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipExceptionPause()
 {
     if (m_steppingFromFramework)
         return RequestNoSkip;
@@ skipping 655 matching lines @@
         *errorString = "Can only perform operation while tracking async call stacks.";
         return;
     }
     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)
+void V8DebuggerAgentImpl::addBlackboxPatterns(ErrorString* error, PassOwnPtr<protocol::Array<protocol::Debugger::BlackboxPattern>> patterns)
 {
-    if (!m_scripts.contains(scriptId)) {
-        *error = "No script with passed id.";
-        return;
+    String blackboxRegexpPattern;
+    protocol::HashMap<String, protocol::Vector<std::pair<int, int>>> scriptToBlackboxPositions;
+
+    for (size_t i = 0; i < patterns->length(); ++i) {
+        protocol::Debugger::BlackboxPattern* pattern = patterns->get(i);
+
+        String url = pattern->getUrl(String());
+        String hash = pattern->getHash(String());
+        String regexp = pattern->getRegexp(String());
+
+        if (!url.isEmpty() + !hash.isEmpty() + !regexp.isEmpty() != 1) {
+            *error = "Only one field should be set in BlackboxPattern: url or hash or regexp.";
+            return;
+        }
+
+        if (pattern->hasPositions() && !regexp.isEmpty()) {
+            *error = "Positions can't be used with regexp BlackboxPattern.";
+            return;
+        }
+
+        protocol::Vector<std::pair<int, int>> positions;
+        if (!parseBlackboxPositions(error, pattern->getPositions(nullptr), &positions))
+            return;
+
+        if (!regexp.isEmpty())
+            blackboxRegexpPattern = blackboxRegexpPattern + (blackboxRegexpPattern.isEmpty() ? "" : "|") +  regexp;
+        else
+            scriptToBlackboxPositions.set(url.isEmpty() ? hashPrefix + hash : urlPrefix + url, positions);
     }
 
-    if (!inPositions->length()) {
-        m_blackboxedPositions.remove(scriptId);
-        return;
-    }
+    m_blackboxRegexpPattern = m_blackboxRegexpPattern + (m_blackboxRegexpPattern.isEmpty() ? "" : "|") + blackboxRegexpPattern;
+    for (const auto& positions : scriptToBlackboxPositions)
+        m_scriptToBlackboxPositions.set(positions.first, *positions.second);
 
-    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;
-        }
-        positions[i] = std::make_pair(position->getLine(), position->getColumn());
-    }
+    if (!m_state->getArray(DebuggerAgentState::blackboxState))
+        m_state->setArray(DebuggerAgentState::blackboxState, protocol::ListValue::create());
+    protocol::ListValue* currentPatterns = m_state->getArray(DebuggerAgentState::blackboxState);
 
-    for (size_t i = 1; i < positions.size(); ++i) {
-        if (positions[i - 1].first < positions[i].first)
-            continue;
-        if (positions[i - 1].first == positions[i].first && positions[i - 1].second < positions[i].second)
-            continue;
-        *error = "Input positions array is not sorted or contains duplicate values.";
-        return;
-    }
+    for (size_t i = 0; i < patterns->length(); ++i)
+        currentPatterns->pushValue(patterns->get(i)->serialize());
+    return;
+}
 
-    m_blackboxedPositions.set(scriptId, positions);
+void V8DebuggerAgentImpl::clearBlackboxPatterns(ErrorString* error)
+{
+    m_blackboxRegexpPattern = String();
+    m_scriptToBlackboxPositions.clear();
+    m_state->setArray(DebuggerAgentState::blackboxState, protocol::ListValue::create());
 }
 
 void V8DebuggerAgentImpl::willExecuteScript(int scriptId)
 {
     changeJavaScriptRecursionLevel(+1);
     // Fast return.
     if (m_scheduledDebuggerStep != StepInto)
         return;
     // Skip unknown scripts (e.g. InjectedScript).
     if (!m_scripts.contains(String::number(scriptId)))
@@ skipping 80 matching lines @@
         script.setSourceURL(V8ContentSearchUtil::findSourceURL(script.source(), false, &isDeprecatedSourceURL));
     else if (script.hasSourceURL())
         V8ContentSearchUtil::findSourceURL(script.source(), false, &isDeprecatedSourceURL);
 
     bool isDeprecatedSourceMappingURL = false;
     if (!parsedScript.success)
         script.setSourceMappingURL(V8ContentSearchUtil::findSourceMapURL(script.source(), false, &isDeprecatedSourceMappingURL));
     else if (!script.sourceMappingURL().isEmpty())
         V8ContentSearchUtil::findSourceMapURL(script.source(), false, &isDeprecatedSourceMappingURL);
 
-    script.setHash(calculateHash(script.source()));
+    if (!script.hasSourceURL())
+        script.setHash(calculateHash(script.source()));
 
     int executionContextId = script.executionContextId();
     bool isContentScript = script.isContentScript();
     bool isInternalScript = script.isInternalScript();
     bool isLiveEdit = script.isLiveEdit();
     bool hasSourceURL = script.hasSourceURL();
     String scriptURL = script.sourceURL();
     String sourceMapURL = script.sourceMappingURL();
+    String hash = script.hash();
     bool deprecatedCommentWasUsed = isDeprecatedSourceURL || isDeprecatedSourceMappingURL;
 
+    const Maybe<String>& hashParam = hash;
     const Maybe<String>& sourceMapURLParam = sourceMapURL;
     const bool* isContentScriptParam = isContentScript ? &isContentScript : nullptr;
     const bool* isInternalScriptParam = isInternalScript ? &isInternalScript : nullptr;
     const bool* isLiveEditParam = isLiveEdit ? &isLiveEdit : nullptr;
     const bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr;
     const bool* deprecatedCommentWasUsedParam = deprecatedCommentWasUsed ? &deprecatedCommentWasUsed : nullptr;
     if (parsedScript.success)
-        m_frontend->scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, script.hash(), isContentScriptParam, isInternalScriptParam, isLiveEditParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
+        m_frontend->scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, isContentScriptParam, isInternalScriptParam, isLiveEditParam, hashParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
     else
-        m_frontend->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, script.hash(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
+        m_frontend->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, isContentScriptParam, isInternalScriptParam, hashParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
 
     m_scripts.set(parsedScript.scriptId, script);
 
     if (scriptURL.isEmpty() || !parsedScript.success)
         return;
 
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie)
         return;
 
@@ skipping 155 matching lines @@
 
 void V8DebuggerAgentImpl::removeBreakpointAt(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source)
 {
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void V8DebuggerAgentImpl::reset()
 {
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
-    m_blackboxedPositions.clear();
+
+    m_scriptToBlackboxPositions.clear();
+    m_blackboxRegexpPattern = String();
+
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink