[DevTools] Introduce provisional blackboxing

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/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
@@ skipping 27 matching lines @@
 static const char v8AsyncTaskEventWillHandle[] = "willHandle";
 static const char v8AsyncTaskEventDidHandle[] = "didHandle";
 }
 
 namespace blink {
 
 namespace DebuggerAgentState {
 static const char javaScriptBreakpoints[] = "javaScriptBreakopints";
 static const char pauseOnExceptionsState[] = "pauseOnExceptionsState";
 static const char asyncCallStackDepth[] = "asyncCallStackDepth";
+static const char blackboxPatterns[] = "blackboxPatterns";
+static const char blackboxRangesByURL[] = "blackboxRangesByURL";
+static const char blackboxRangesByHash[] = "blackboxRangesByHash";
+static const char blackboxScriptsByURL[] = "blackboxScriptsByURL";
+static const char blackboxScriptsByHash[] = "blackboxScriptsByHash";
 
 // 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;
@@ skipping 171 matching lines @@
     m_state->setNumber(DebuggerAgentState::pauseOnExceptionsState, V8DebuggerImpl::DontPauseOnExceptions);
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, 0);
 
     if (!m_pausedContext.IsEmpty())
         debugger().continueProgram();
     debugger().debuggerAgentDisabled();
     m_pausedContext.Reset();
     JavaScriptCallFrames emptyCallFrames;
     m_pausedCallFrames.swap(emptyCallFrames);
     m_scripts.clear();
-    m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     internalSetAsyncCallStackDepth(0);
     m_continueToLocationBreakpointId = String16();
     clearBreakDetails();
     m_scheduledDebuggerStep = NoStep;
     m_skipNextDebuggerStepOut = false;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     m_skipAllPauses = false;
     m_enabled = false;
+
+    m_blackboxPattern = nullptr;
+    m_blackboxRangesByHash.clear();
+    m_blackboxRangesByURL.clear();
 }
 
 void V8DebuggerAgentImpl::internalSetAsyncCallStackDepth(int depth)
 {
     if (depth <= 0) {
         m_maxAsyncCallStackDepth = 0;
         allAsyncTasksCanceled();
     } else {
         m_maxAsyncCallStackDepth = depth;
     }
@@ skipping 14 matching lines @@
 
 void V8DebuggerAgentImpl::restore()
 {
     ASSERT(!m_enabled);
     enable();
     ErrorString error;
 
     int pauseState = V8DebuggerImpl::DontPauseOnExceptions;
     m_state->getNumber(DebuggerAgentState::pauseOnExceptionsState, &pauseState);
     setPauseOnExceptionsImpl(&error, pauseState);
+    ASSERT(error.isEmpty());
 
     m_skipAllPauses = m_state->booleanProperty(DebuggerAgentState::skipAllPauses, false);
 
     int asyncCallStackDepth = 0;
     m_state->getNumber(DebuggerAgentState::asyncCallStackDepth, &asyncCallStackDepth);
     internalSetAsyncCallStackDepth(asyncCallStackDepth);
+
+    protocol::ListValue* blackboxPatternsValue = m_state->getArray(DebuggerAgentState::blackboxPatterns);
+    if (blackboxPatternsValue) {
+        protocol::ErrorSupport errors;
+        OwnPtr<protocol::Array<String16>> blackboxPatterns = protocol::Array<String16>::parse(blackboxPatternsValue, &errors);
+        if (blackboxPatterns)
+            setBlackboxPatterns(&error, blackboxPatterns.release());
+        ASSERT(!errors.hasErrors() && error.isEmpty());
+    }
+    restoreBlackboxScripts(DebuggerAgentState::blackboxScriptsByHash, m_blackboxRangesByHash);

[dgozman, 2016/04/20 02:06:40]

Can we use empty ranges as a meaning for "fully blackboxed"?

+    restoreBlackboxScripts(DebuggerAgentState::blackboxScriptsByURL, m_blackboxRangesByURL);
+    restoreBlackboxRanges(DebuggerAgentState::blackboxRangesByHash, m_blackboxRangesByHash);
+    restoreBlackboxRanges(DebuggerAgentState::blackboxRangesByURL, m_blackboxRangesByURL);
+}
+
+void V8DebuggerAgentImpl::restoreBlackboxScripts(const String16& key, BlackboxRangesByString& map)
+{
+    protocol::ListValue* list = m_state->getArray(key);
+    if (!list)
+        return;
+    Vector<std::pair<int, int>> blackboxedRanges(1);
+    for (size_t i = 0; i < list->size(); ++i) {
+        protocol::Value* val = list->at(i);
+        String16 id;
+        bool success = val->asString(&id);
+        ASSERT_UNUSED(success, success);
+        map.set(id, blackboxedRanges);
+    }
+}
+
+void V8DebuggerAgentImpl::restoreBlackboxRanges(const String16& key, BlackboxRangesByString& map)
+{
+    using protocol::Runtime::SourceRange;
+
+    protocol::DictionaryValue* storedMap = m_state->getObject(key);
+    if (!storedMap)
+        return;
+    protocol::ErrorSupport errorSupport;
+    for (size_t i = 0; i < storedMap->size(); ++i) {
+        auto value = storedMap->at(i);
+        OwnPtr<protocol::Array<SourceRange>> ranges = protocol::Array<SourceRange>::parse(value.second, &errorSupport);
+        ASSERT(!errorSupport.hasErrors());
+        Vector<std::pair<int, int>> blackboxedRanges(ranges->length() * 2);
+        for (size_t i = 0; i < ranges->length(); ++i) {
+            SourceRange* range = ranges->get(i);
+            blackboxedRanges[i * 2] = std::make_pair(range->getStartLine(), range->getStartColumn());
+            blackboxedRanges[i * 2 + 1] = std::make_pair(range->getEndLine(), range->getEndColumn());
+        }
+        map.set(value.first, blackboxedRanges);
+    }
 }
 
 void V8DebuggerAgentImpl::setBreakpointsActive(ErrorString* errorString, bool active)
 {
     if (!checkEnabled(errorString))
         return;
     debugger().setBreakpointsActivated(active);
 }
 
 void V8DebuggerAgentImpl::setSkipAllPauses(ErrorString*, bool skipped)
@@ skipping 195 matching lines @@
 
 bool V8DebuggerAgentImpl::isCallFrameWithUnknownScriptOrBlackboxed(JavaScriptCallFrame* frame)
 {
     if (!frame)
         return true;
     ScriptsMap::iterator it = m_scripts.find(String16::number(frame->sourceID()));
     if (it == m_scripts.end()) {
         // Unknown scripts are blackboxed.
         return true;
     }
-    auto itBlackboxedPositions = m_blackboxedPositions.find(String16::number(frame->sourceID()));
-    if (itBlackboxedPositions == m_blackboxedPositions.end())
+    V8DebuggerScript* script = it->second;
+    if (m_blackboxPattern) {
+        String16 scriptSourceURL = script->sourceURL();
+        if (!scriptSourceURL.isEmpty() && m_blackboxPattern->match(scriptSourceURL) != -1)
+            return true;
+    }
+    auto itBlackboxedRangesByHash = m_blackboxRangesByHash.find(script->hash());
+    const Vector<std::pair<int, int>>* ranges = nullptr;
+    if (itBlackboxedRangesByHash != m_blackboxRangesByHash.end()) {
+        ranges = itBlackboxedRangesByHash->second;
+    } else {
+        auto itBlackboxedRangesByURL = m_blackboxRangesByURL.find(script->sourceURL());
+        if (itBlackboxedRangesByURL != m_blackboxRangesByURL.end())
+            ranges = itBlackboxedRangesByURL->second;
+    }
+    if (!ranges)
         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(JavaScriptCallFrame* topCallFrame)
 {
     if (m_steppingFromFramework)
         return RequestNoSkip;
@@ skipping 520 matching lines @@
 {
     m_asyncTaskStacks.clear();
     m_recurringTasks.clear();
     m_currentStacks.clear();
 
 #if ENABLE(ASSERT)
     m_currentTasks.clear();
 #endif
 }
 
-void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String16& scriptId, PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
+void V8DebuggerAgentImpl::setBlackboxPatterns(ErrorString* errorString, PassOwnPtr<protocol::Array<String16>> patterns)
 {
-    if (!m_scripts.contains(scriptId)) {
-        *error = "No script with passed id.";
+    if (!patterns->length()) {
+        m_blackboxPattern = nullptr;
+        m_state->setArray(DebuggerAgentState::blackboxPatterns, patterns->serialize());
         return;
     }
 
-    if (!inPositions->length()) {
-        m_blackboxedPositions.remove(scriptId);
+    String16 pattern;
+    for (size_t i = 0; i < patterns->length() - 1; ++i)
+        pattern = pattern + patterns->get(i) + "|";
+    pattern = "(" + pattern + patterns->get(patterns->length() - 1) + ")";
+
+    OwnPtr<V8Regex> regex = adoptPtr(new V8Regex(m_debugger, pattern, true /** caseSensitive */, false /** multiline */));
+    if (!regex->isValid()) {
+        *errorString = "Pattern parser error: " + regex->errorMessage();
         return;
     }
 
-    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;
+    m_blackboxPattern = regex.release();
+    m_state->setArray(DebuggerAgentState::blackboxPatterns, patterns->serialize());
+}
+
+void V8DebuggerAgentImpl::setScriptBlackboxed(ErrorString* errorString, const Maybe<String16>& hash, const Maybe<String16>& url, const Maybe<protocol::Array<protocol::Runtime::SourceRange>>& optRanges)
+{
+    using protocol::Runtime::SourceRange;
+
+    if (!hash.isJust() && !url.isJust()) {
+        *errorString = "Hash or URL should be set";
+        return;
+    }
+    BlackboxRangesByString& idToBlackboxRanges = hash.isJust() ? m_blackboxRangesByHash : m_blackboxRangesByURL;
+    String16 id = hash.isJust() ? hash.fromJust() : url.fromJust();
+
+    if (!optRanges.isJust()) {
+        const String16& stateKey = hash.isJust() ? DebuggerAgentState::blackboxScriptsByHash : DebuggerAgentState::blackboxScriptsByURL;
+        protocol::ListValue* stateBlackboxedScripts = m_state->getArray(stateKey);
+        if (!stateBlackboxedScripts) {
+            m_state->setArray(stateKey, protocol::ListValue::create());
+            stateBlackboxedScripts = m_state->getArray(stateKey);
         }
-        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.";
+        Vector<std::pair<int, int>> blackboxedRanges(1);
+        idToBlackboxRanges.set(id, blackboxedRanges);
+        stateBlackboxedScripts->pushValue(protocol::StringValue::create(id));
         return;
     }
 
-    m_blackboxedPositions.set(scriptId, positions);
+    const String16& stateKey = hash.isJust() ? DebuggerAgentState::blackboxRangesByHash : DebuggerAgentState::blackboxRangesByURL;
+    protocol::DictionaryValue* stateMap = m_state->getObject(stateKey);
+    if (!stateMap) {
+        m_state->setObject(stateKey, protocol::DictionaryValue::create());
+        stateMap = m_state->getObject(stateKey);
+    }
+    protocol::Array<SourceRange>* ranges = optRanges.fromJust();
+    if (!ranges->length()) {
+        idToBlackboxRanges.remove(id);
+        stateMap->remove(id);
+        return;
+    }
+
+    String16 errors;

[dgozman, 2016/04/20 02:06:40]

Let's extract validation into a helper function.

+    for (size_t i = 0; i < ranges->length(); ++i) {
+        SourceRange* range = ranges->get(i);
+        if (range->getStartLine() > range->getEndLine())
+            errors = errors + " 'startLine' should be not more then 'endLine' in (" + String16::number(i + 1) + ").";
+        if (range->getStartLine() == range->getEndLine() && range->getStartColumn() >= range->getEndColumn())
+            errors = errors + " 'startColumn' should be less then 'endColumn' if 'startLine' == 'endLine' in (" + String16::number(i + 1) + ").";
+        if (i > 0) {
+            SourceRange* prevRange = ranges->get(i - 1);
+            if (prevRange->getEndLine() > range->getStartLine() || (prevRange->getEndLine() == range->getStartLine() && prevRange->getEndColumn() > range->getStartColumn()))
+                errors = errors + " Records in ranges array should be sorted and disjoint.";
+        }
+    }
+    if (!errors.isEmpty()) {
+        *errorString = errors;
+        return;
+    }
+    Vector<std::pair<int, int>> blackboxedRanges(ranges->length() * 2);
+    for (size_t i = 0; i < ranges->length(); ++i) {
+        SourceRange* range = ranges->get(i);
+        blackboxedRanges[i * 2] = std::make_pair(range->getStartLine(), range->getStartColumn());
+        blackboxedRanges[i * 2 + 1] = std::make_pair(range->getEndLine(), range->getEndColumn());
+    }
+    idToBlackboxRanges.set(id, blackboxedRanges);
+    stateMap->setArray(id, ranges->serialize());
 }
 
 void V8DebuggerAgentImpl::willExecuteScript(int scriptId)
 {
     changeJavaScriptRecursionLevel(+1);
     // Fast return.
     if (m_scheduledDebuggerStep != StepInto)
         return;
     // Skip unknown scripts (e.g. InjectedScript).
     if (!m_scripts.contains(String16::number(scriptId)))
@@ skipping 309 matching lines @@
 {
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void V8DebuggerAgentImpl::reset()
 {
     if (!enabled())
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
-    m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     allAsyncTasksCanceled();
 }
 
 } // namespace blink