[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/AsyncCallChain.h"
 #include "platform/v8_inspector/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
@@ skipping 31 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 blackboxPatterns[] = "blackboxPatterns";
+static const char blackboxHashes[] = "blackboxHashes";
 
 // 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";
 
+// Blackbox hash object properties.
+static const char hashValue[] = "hashValue";
+static const char hashPositions[] = "hashPositions";
+
 } // namespace DebuggerAgentState;
 
 static const int maxSkipStepFrameCount = 128;
 
 const char V8DebuggerAgent::backtraceObjectGroup[] = "backtrace";
 
 const int V8DebuggerAgent::unknownAsyncOperationId = 0;
 
 static String breakpointIdSuffix(V8DebuggerAgentImpl::BreakpointSource source)
 {
@@ skipping 35 matching lines @@
     return V8JavaScriptCallFrame::unwrap(context, value);
 }
 
 static bool positionComparator(const std::pair<int, int>& a, const std::pair<int, int>& b)
 {
     if (a.first != b.first)
         return a.first < b.first;
     return a.second < b.second;
 }
 
+static bool parseBlackboxPositions(ErrorString* error, protocol::Array<protocol::Debugger::ScriptPosition>* inPositions, Vector<std::pair<int, int>>* outPositions)
+{
+    if (!inPositions) {
+        Vector<std::pair<int, int>> blackboxed(1);
+        outPositions->swap(blackboxed);
+        return true;
+    }
+    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 missing 'line' or 'line' < 0.";
+            return false;
+        }
+        if (position->getColumn() < 0) {
+            if (error)
+                *error = "Position missing 'column' or '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_loadedScriptHashes.clear();
+
+    m_hashToBlackboxPositions.clear();
+    m_blackboxPattern = 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()
+{
+    String error;
+    protocol::ErrorSupport errors;
+
+    protocol::ListValue* savedPatterns = m_state->getArray(DebuggerAgentState::blackboxPatterns);
+    if (savedPatterns) {
+        OwnPtr<protocol::Array<protocol::Debugger::BlackboxPattern>> patterns = protocol::Array<protocol::Debugger::BlackboxPattern>::parse(savedPatterns, &errors);
+        ASSERT(!errors.hasErrors());
+        setBlackboxPatterns(&error, patterns.release());
+        ASSERT(!error.length());
+    }
+
+    protocol::ListValue* savedHashes = m_state->getArray(DebuggerAgentState::blackboxHashes);
+    if (!savedHashes)
+        return;
+    for (size_t i = 0; i < savedHashes->length(); ++i) {
+        protocol::DictionaryValue* savedHash = protocol::DictionaryValue::cast(savedHashes->get(i));
+
+        String hash;
+        OwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> positions;
+
+        bool hadError = savedHash->getString(DebuggerAgentState::hashValue, &hash);
+        ASSERT_UNUSED(hadError, !hadError);
+        positions = protocol::Array<protocol::Debugger::ScriptPosition>::parse(savedHash->getArray(DebuggerAgentState::hashPositions), &errors);
+        ASSERT(!errors.hasErrors());
+        setBlackboxRanges(&error, hash, positions.release());
+        ASSERT(!error.length());
+    }
 }
 
 void V8DebuggerAgentImpl::setBreakpointsActive(ErrorString* errorString, bool active)
 {
     if (!checkEnabled(errorString))
         return;
     debugger().setBreakpointsActivated(active);
 }
 
 void V8DebuggerAgentImpl::setSkipAllPauses(ErrorString*, bool skipped)
@@ skipping 212 matching lines @@
 {
     ASSERT(enabled());
     return isCallFrameWithUnknownScriptOrBlackboxed(debugger().callFrameNoScopes(0));
 }
 
 bool V8DebuggerAgentImpl::isCallFrameWithUnknownScriptOrBlackboxed(PassRefPtr<JavaScriptCallFrame> pFrame)
 {
     RefPtr<JavaScriptCallFrame> frame = pFrame;
     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())
+
+    Vector<std::pair<int, int>> emptyPositions;
+    const Vector<std::pair<int, int>>* ranges = nullptr;
+
+    V8DebuggerScript& script = it->value;
+    auto itBlackboxHash = m_hashToBlackboxPositions.find(script.hash());
+    if (itBlackboxHash != m_hashToBlackboxPositions.end()) {
+        ranges = &itBlackboxHash->value;
+    } else {
+        if (!m_blackboxPattern.isEmpty() && matches(m_debugger, script.sourceURL(), m_blackboxPattern, true)) {
+            Vector<std::pair<int, int>> positions(1);
+            positions[0].first = 0;
+            positions[0].second = 0;
+            m_hashToBlackboxPositions.set(script.hash(), positions);
+            return true;
+        }
         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);
+    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;
 }
@@ skipping 697 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::setBlackboxRanges(ErrorString* error, const String& hash, PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
 {
-    ScriptsMap::iterator it = m_scripts.find(scriptId);
-    if (it == m_scripts.end()) {
-        *error = "No script with passed id.";
+    if (!m_loadedScriptHashes.contains(hash)) {
+        *error = "No script with passed hash.";
         return;
     }
 
     if (!inPositions->length()) {
-        m_blackboxedPositions.remove(scriptId);
+        m_hashToBlackboxPositions.remove(hash);
         return;
     }
 
-    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.";
+    Vector<std::pair<int, int>> positions;
+    if (parseBlackboxPositions(error, inPositions.get(), &positions))
+        m_hashToBlackboxPositions.set(hash, positions);
+
+    if (!m_state->getArray(DebuggerAgentState::blackboxHashes))
+        m_state->setArray(DebuggerAgentState::blackboxHashes, protocol::ListValue::create());
+    protocol::ListValue* hashes = m_state->getArray(DebuggerAgentState::blackboxHashes);
+    OwnPtr<protocol::DictionaryValue> value = protocol::DictionaryValue::create();
+    value->setString(DebuggerAgentState::hashValue, hash);
+    value->setArray(DebuggerAgentState::hashPositions, inPositions->serialize());
+    hashes->pushValue(value.release());
+}
+
+void V8DebuggerAgentImpl::setBlackboxPatterns(ErrorString* error, PassOwnPtr<protocol::Array<protocol::Debugger::BlackboxPattern>> patterns)
+{
+    HashSet<String> hashes;
+    String blackboxPattern;
+
+    for (size_t i = 0; i < patterns->length(); ++i) {
+        protocol::Debugger::BlackboxPattern* pattern = patterns->get(i);
+        String type = pattern->getType();
+        if (type == protocol::Debugger::BlackboxPatternTypeEnum::RegExp) {
+            blackboxPattern = blackboxPattern.isEmpty() ? pattern->getValue() : (blackboxPattern + "|" + pattern->getValue());
+        } else if (type== protocol::Debugger::BlackboxPatternTypeEnum::Hash) {
+            hashes.add(pattern->getValue());
+        } else {
+            *error = "Unknown blackbox pattern type.";
             return;
         }
-        if (position->getColumn() < 0) {
-            *error = "Position missing 'column' or 'column' < 0.";
-            return;
-        }
-        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;
-        *error = "Input positions array is not sorted or contains duplicate values.";
-        return;
-    }
+    m_state->setArray(DebuggerAgentState::blackboxPatterns, patterns->serialize());
 
-    m_blackboxedPositions.set(scriptId, positions);
+    Vector<std::pair<int, int>> positions(1);
+    for (auto& hash : hashes)
+        m_hashToBlackboxPositions.set(hash, positions);
+    m_blackboxPattern = blackboxPattern;
 }
 
 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 139 matching lines @@
     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);
     else
         m_frontend->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, script.hash(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
 
     m_scripts.set(parsedScript.scriptId, script);
+    m_loadedScriptHashes.add(script.hash());
 
     if (scriptURL.isEmpty() || !parsedScript.success)
         return;
 
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie)
         return;
 
     for (auto& cookie : *breakpointsCookie) {
         protocol::DictionaryValue* breakpointObject = protocol::DictionaryValue::cast(cookie.value.get());
@@ 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_loadedScriptHashes.clear();
+
+    m_hashToBlackboxPositions.clear();
+
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink