[webkit-changes] [182239] trunk

Wed, 01 Apr 2015 10:49:27 -0700

Title: [182239] trunk
Revision
182239
Author
achristen...@apple.com
Date
2015-04-01 10:48:57 -0700 (Wed, 01 Apr 2015)

Log Message

[Content Extensions] Properly handle regexes that match everything.
https://bugs.webkit.org/show_bug.cgi?id=143281

Reviewed by Benjamin Poulain.

Source/WebCore:

* contentextensions/ContentExtensionCompiler.cpp:
(WebCore::ContentExtensions::compileRuleList):
Make sure we always have at least one NFA for rule lists with triggers that all match everything.
* contentextensions/DFABytecodeInterpreter.cpp:
(WebCore::ContentExtensions::DFABytecodeInterpreter::interpretAppendAction):
(WebCore::ContentExtensions::DFABytecodeInterpreter::interpretTestFlagsAndAppendAction):
Add helper functions to reduce duplicate code.
(WebCore::ContentExtensions::DFABytecodeInterpreter::actionsFromDFARoot):
Get all actions without flags from the DFA root.
(WebCore::ContentExtensions::DFABytecodeInterpreter::interpret):
Remove branches when interpreting.
* contentextensions/DFABytecodeInterpreter.h:
Add helper functions to reduce duplicate code.

Tools:

* TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp:
(TestWebKitAPI::testRequest):
(TestWebKitAPI::makeBackend):
(TestWebKitAPI::TEST_F):
Removed duplicate code and added test.

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (182238 => 182239)


--- trunk/Source/WebCore/ChangeLog	2015-04-01 17:43:21 UTC (rev 182238)
+++ trunk/Source/WebCore/ChangeLog	2015-04-01 17:48:57 UTC (rev 182239)
@@ -1,3 +1,24 @@
+2015-04-01  Alex Christensen  <achristen...@webkit.org>
+
+        [Content Extensions] Properly handle regexes that match everything.
+        https://bugs.webkit.org/show_bug.cgi?id=143281
+
+        Reviewed by Benjamin Poulain.
+
+        * contentextensions/ContentExtensionCompiler.cpp:
+        (WebCore::ContentExtensions::compileRuleList):
+        Make sure we always have at least one NFA for rule lists with triggers that all match everything.
+        * contentextensions/DFABytecodeInterpreter.cpp:
+        (WebCore::ContentExtensions::DFABytecodeInterpreter::interpretAppendAction):
+        (WebCore::ContentExtensions::DFABytecodeInterpreter::interpretTestFlagsAndAppendAction):
+        Add helper functions to reduce duplicate code.
+        (WebCore::ContentExtensions::DFABytecodeInterpreter::actionsFromDFARoot):
+        Get all actions without flags from the DFA root.
+        (WebCore::ContentExtensions::DFABytecodeInterpreter::interpret):
+        Remove branches when interpreting.
+        * contentextensions/DFABytecodeInterpreter.h:
+        Add helper functions to reduce duplicate code.
+
 2015-04-01  Myles C. Maxfield  <mmaxfi...@apple.com>
 
         Addressing post-review comments.

Modified: trunk/Source/WebCore/contentextensions/ContentExtensionCompiler.cpp (182238 => 182239)


--- trunk/Source/WebCore/contentextensions/ContentExtensionCompiler.cpp	2015-04-01 17:43:21 UTC (rev 182238)
+++ trunk/Source/WebCore/contentextensions/ContentExtensionCompiler.cpp	2015-04-01 17:48:57 UTC (rev 182239)
@@ -173,6 +173,8 @@
 #endif
 
     Vector<NFA> nfas = combinedURLFilters.createNFAs();
+    if (!nfas.size() && universalActionLocations.size())
+        nfas.append(NFA());
 
 #if CONTENT_EXTENSIONS_PERFORMANCE_REPORTING
     double nfaBuildTimeEnd = monotonicallyIncreasingTime();

Modified: trunk/Source/WebCore/contentextensions/DFABytecodeInterpreter.cpp (182238 => 182239)


--- trunk/Source/WebCore/contentextensions/DFABytecodeInterpreter.cpp	2015-04-01 17:43:21 UTC (rev 182238)
+++ trunk/Source/WebCore/contentextensions/DFABytecodeInterpreter.cpp	2015-04-01 17:48:57 UTC (rev 182239)
@@ -41,18 +41,39 @@
     return *reinterpret_cast<const IntType*>(&bytecode[index]);
 }
     
+void DFABytecodeInterpreter::interpretAppendAction(unsigned& programCounter, Actions& actions)
+{
+    ASSERT(getBits<DFABytecodeInstruction>(m_bytecode, m_bytecodeLength, programCounter) == DFABytecodeInstruction::AppendAction);
+    actions.add(static_cast<uint64_t>(getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode))));
+    programCounter += instructionSizeWithArguments(DFABytecodeInstruction::AppendAction);
+}
+
+void DFABytecodeInterpreter::interpretTestFlagsAndAppendAction(unsigned& programCounter, uint16_t flags, Actions& actions)
+{
+    ASSERT(getBits<DFABytecodeInstruction>(m_bytecode, m_bytecodeLength, programCounter) == DFABytecodeInstruction::TestFlagsAndAppendAction);
+    if (flags & getBits<uint16_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode)))
+        actions.add(static_cast<uint64_t>(getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint16_t))));
+    programCounter += instructionSizeWithArguments(DFABytecodeInstruction::TestFlagsAndAppendAction);
+}
+
 DFABytecodeInterpreter::Actions DFABytecodeInterpreter::actionsFromDFARoot()
 {
-    DFABytecodeInterpreter::Actions universalActionLocations;
+    Actions actions;
 
-    // Skip first DFA header. All universal actions are in the first DFA root.
+    // DFA header.
+    unsigned dfaBytecodeLength = getBits<unsigned>(m_bytecode, m_bytecodeLength, 0);
     unsigned programCounter = sizeof(unsigned);
 
-    while (static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]) == DFABytecodeInstruction::AppendAction) {
-        universalActionLocations.add(static_cast<uint64_t>(getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode))));
-        programCounter += instructionSizeWithArguments(DFABytecodeInstruction::AppendAction);
+    while (programCounter < dfaBytecodeLength) {
+        DFABytecodeInstruction instruction = static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]);
+        if (instruction == DFABytecodeInstruction::AppendAction)
+            interpretAppendAction(programCounter, actions);
+        else if (instruction == DFABytecodeInstruction::TestFlagsAndAppendAction)
+            programCounter += instructionSizeWithArguments(DFABytecodeInstruction::TestFlagsAndAppendAction);
+        else
+            break;
     }
-    return universalActionLocations;
+    return actions;
 }
     
 DFABytecodeInterpreter::Actions DFABytecodeInterpreter::interpret(const CString& urlCString, uint16_t flags)
@@ -71,9 +92,22 @@
         programCounter += sizeof(unsigned);
 
         // Skip the actions on the DFA root. These are accessed via actionsFromDFARoot.
-        while (static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]) == DFABytecodeInstruction::AppendAction) {
-            ASSERT_WITH_MESSAGE(!dfaStart, "Triggers that match everything should only be in the first DFA.");
-            programCounter += instructionSizeWithArguments(DFABytecodeInstruction::AppendAction);
+        if (!dfaStart) {
+            while (programCounter < dfaBytecodeLength) {
+                DFABytecodeInstruction instruction = static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]);
+                if (instruction == DFABytecodeInstruction::AppendAction)
+                    programCounter += instructionSizeWithArguments(DFABytecodeInstruction::AppendAction);
+                else if (instruction == DFABytecodeInstruction::TestFlagsAndAppendAction)
+                    interpretTestFlagsAndAppendAction(programCounter, flags, actions);
+                else
+                    break;
+            }
+            if (programCounter >= m_bytecodeLength)
+                return actions;
+        } else {
+            ASSERT_WITH_MESSAGE(static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]) != DFABytecodeInstruction::AppendAction 
+                && static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]) != DFABytecodeInstruction::TestFlagsAndAppendAction, 
+                "Triggers that match everything should only be in the first DFA.");
         }
         
         // Interpret the bytecode from this DFA.
@@ -87,49 +121,70 @@
             case DFABytecodeInstruction::Terminate:
                 goto nextDFA;
                     
-            case DFABytecodeInstruction::CheckValueCaseSensitive:
-            case DFABytecodeInstruction::CheckValueCaseInsensitive: {
+            case DFABytecodeInstruction::CheckValueCaseSensitive: {
                 if (urlIndexIsAfterEndOfString)
                     goto nextDFA;
 
+                // Check to see if the next character in the url is the value stored with the bytecode.
                 char character = url[urlIndex];
-                if (static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]) == DFABytecodeInstruction::CheckValueCaseInsensitive)
-                    character = toASCIILower(character);
+                if (character == getBits<uint8_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode))) {
+                    programCounter = getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint8_t));
+                    if (!character)
+                        urlIndexIsAfterEndOfString = true;
+                    urlIndex++; // This represents an edge in the DFA.
+                } else
+                    programCounter += instructionSizeWithArguments(DFABytecodeInstruction::CheckValueCaseSensitive);
+                break;
+            }
 
+            case DFABytecodeInstruction::CheckValueCaseInsensitive: {
+                if (urlIndexIsAfterEndOfString)
+                    goto nextDFA;
+
                 // Check to see if the next character in the url is the value stored with the bytecode.
+                char character = toASCIILower(url[urlIndex]);
                 if (character == getBits<uint8_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode))) {
                     programCounter = getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint8_t));
                     if (!character)
                         urlIndexIsAfterEndOfString = true;
                     urlIndex++; // This represents an edge in the DFA.
-                } else {
-                    programCounter += instructionSizeWithArguments(DFABytecodeInstruction::CheckValueCaseSensitive);
-                    ASSERT(instructionSizeWithArguments(DFABytecodeInstruction::CheckValueCaseSensitive) == instructionSizeWithArguments(DFABytecodeInstruction::CheckValueCaseInsensitive));
-                }
+                } else
+                    programCounter += instructionSizeWithArguments(DFABytecodeInstruction::CheckValueCaseInsensitive);
                 break;
             }
                     
-            case DFABytecodeInstruction::CheckValueRangeCaseSensitive:
-            case DFABytecodeInstruction::CheckValueRangeCaseInsensitive: {
+            case DFABytecodeInstruction::CheckValueRangeCaseSensitive: {
                 if (urlIndexIsAfterEndOfString)
                     goto nextDFA;
                 
                 char character = url[urlIndex];
-                if (static_cast<DFABytecodeInstruction>(m_bytecode[programCounter]) == DFABytecodeInstruction::CheckValueRangeCaseInsensitive)
-                    character = toASCIILower(character);
                 if (character >= getBits<uint8_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode))
                     && character <= getBits<uint8_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint8_t))) {
                     programCounter = getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint8_t) + sizeof(uint8_t));
                     if (!character)
                         urlIndexIsAfterEndOfString = true;
                     urlIndex++; // This represents an edge in the DFA.
-                } else {
+                } else
                     programCounter += instructionSizeWithArguments(DFABytecodeInstruction::CheckValueRangeCaseSensitive);
-                    ASSERT(instructionSizeWithArguments(DFABytecodeInstruction::CheckValueRangeCaseSensitive) == instructionSizeWithArguments(DFABytecodeInstruction::CheckValueRangeCaseInsensitive));
-                }
                 break;
             }
 
+            case DFABytecodeInstruction::CheckValueRangeCaseInsensitive: {
+                if (urlIndexIsAfterEndOfString)
+                    goto nextDFA;
+                
+                char character = toASCIILower(url[urlIndex]);
+                if (character >= getBits<uint8_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode))
+                    && character <= getBits<uint8_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint8_t))) {
+                    programCounter = getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint8_t) + sizeof(uint8_t));
+                    if (!character)
+                        urlIndexIsAfterEndOfString = true;
+                    urlIndex++; // This represents an edge in the DFA.
+                } else
+                    programCounter += instructionSizeWithArguments(DFABytecodeInstruction::CheckValueRangeCaseInsensitive);
+                break;
+            }
+
             case DFABytecodeInstruction::Jump:
                 if (!url[urlIndex] || urlIndexIsAfterEndOfString)
                     goto nextDFA;
@@ -139,14 +194,11 @@
                 break;
                     
             case DFABytecodeInstruction::AppendAction:
-                actions.add(static_cast<uint64_t>(getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode))));
-                programCounter += instructionSizeWithArguments(DFABytecodeInstruction::AppendAction);
+                interpretAppendAction(programCounter, actions);
                 break;
                     
             case DFABytecodeInstruction::TestFlagsAndAppendAction:
-                if (flags & getBits<uint16_t>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode)))
-                    actions.add(static_cast<uint64_t>(getBits<unsigned>(m_bytecode, m_bytecodeLength, programCounter + sizeof(DFABytecode) + sizeof(uint16_t))));
-                programCounter += instructionSizeWithArguments(DFABytecodeInstruction::TestFlagsAndAppendAction);
+                interpretTestFlagsAndAppendAction(programCounter, flags, actions);
                 break;
                     
             default:
@@ -155,6 +207,7 @@
             // We should always terminate before or at a null character at the end of a String.
             ASSERT(urlIndex <= urlCString.length() || (urlIndexIsAfterEndOfString && urlIndex <= urlCString.length() + 1));
         }
+        RELEASE_ASSERT_NOT_REACHED(); // The while loop can only be exited using goto nextDFA.
         nextDFA:
         ASSERT(dfaBytecodeLength);
         programCounter = dfaStart + dfaBytecodeLength;

Modified: trunk/Source/WebCore/contentextensions/DFABytecodeInterpreter.h (182238 => 182239)


--- trunk/Source/WebCore/contentextensions/DFABytecodeInterpreter.h	2015-04-01 17:43:21 UTC (rev 182238)
+++ trunk/Source/WebCore/contentextensions/DFABytecodeInterpreter.h	2015-04-01 17:48:57 UTC (rev 182239)
@@ -51,6 +51,8 @@
     Actions actionsFromDFARoot();
 
 private:
+    void interpretAppendAction(unsigned& programCounter, Actions&);
+    void interpretTestFlagsAndAppendAction(unsigned& programCounter, uint16_t flags, Actions&);
     const DFABytecode* m_bytecode;
     const unsigned m_bytecodeLength;
 };

Modified: trunk/Tools/ChangeLog (182238 => 182239)


--- trunk/Tools/ChangeLog	2015-04-01 17:43:21 UTC (rev 182238)
+++ trunk/Tools/ChangeLog	2015-04-01 17:48:57 UTC (rev 182239)
@@ -1,3 +1,16 @@
+2015-04-01  Alex Christensen  <achristen...@webkit.org>
+
+        [Content Extensions] Properly handle regexes that match everything.
+        https://bugs.webkit.org/show_bug.cgi?id=143281
+
+        Reviewed by Benjamin Poulain.
+
+        * TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp:
+        (TestWebKitAPI::testRequest):
+        (TestWebKitAPI::makeBackend):
+        (TestWebKitAPI::TEST_F):
+        Removed duplicate code and added test.
+
 2015-03-31  Benjamin Poulain  <bpoul...@apple.com>
 
         Content Extensions: split the state machines to minimize prefix states

Modified: trunk/Tools/TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp (182238 => 182239)


--- trunk/Tools/TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp	2015-04-01 17:43:21 UTC (rev 182238)
+++ trunk/Tools/TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp	2015-04-01 17:48:57 UTC (rev 182239)
@@ -136,9 +136,8 @@
 void static testRequest(ContentExtensions::ContentExtensionsBackend contentExtensionsBackend, const ResourceLoadInfo& resourceLoadInfo, Vector<ContentExtensions::ActionType> expectedActions, bool ignorePreviousRules = false)
 {
     auto actions = contentExtensionsBackend.actionsForResourceLoad(resourceLoadInfo);
-
     unsigned expectedSize = actions.size();
-    if (actions.size() && !ignorePreviousRules)
+    if (!ignorePreviousRules)
         expectedSize--; // The last action is applying the compiled stylesheet.
     
     EXPECT_EQ(expectedActions.size(), expectedSize);
@@ -156,27 +155,26 @@
     return { URL(URL(), url), URL(URL(), url), resourceType };
 }
 
-const char* basicFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"webkit.org\"}}]";
-
-TEST_F(ContentExtensionTest, Basic)
+ContentExtensions::ContentExtensionsBackend makeBackend(const char* json)
 {
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(basicFilter);
-
+    auto extension = InMemoryCompiledContentExtension::createFromFilter(json);
     ContentExtensions::ContentExtensionsBackend backend;
     backend.addContentExtension("testFilter", extension);
+    return backend;
+}
 
+TEST_F(ContentExtensionTest, Basic)
+{
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"webkit.org\"}}]");
+
     testRequest(backend, mainDocumentRequest("http://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
 }
 
 TEST_F(ContentExtensionTest, RangeBasic)
 {
-    const char* rangeBasicFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"w[0-9]c\", \"url-filter-is-case-sensitive\":true}},"
-        "{\"action\":{\"type\":\"block-cookies\"},\"trigger\":{\"url-filter\":\"[A-H][a-z]cko\", \"url-filter-is-case-sensitive\":true}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(rangeBasicFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"w[0-9]c\", \"url-filter-is-case-sensitive\":true}},"
+        "{\"action\":{\"type\":\"block-cookies\"},\"trigger\":{\"url-filter\":\"[A-H][a-z]cko\", \"url-filter-is-case-sensitive\":true}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("PatternNestedGroupsFilter", extension);
-
     testRequest(backend, mainDocumentRequest("http://w3c.org"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("w2c://whatwg.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/w0c"), { ContentExtensions::ActionType::BlockLoad });
@@ -197,12 +195,8 @@
 TEST_F(ContentExtensionTest, RangeExclusionGeneratingUniversalTransition)
 {
     // Transition of the type ([^X]X) effictively transition on every input.
-    const char* rangeExclusionGeneratingUniversalTransitionFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[^a]+afoobar\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(rangeExclusionGeneratingUniversalTransitionFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[^a]+afoobar\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("PatternNestedGroupsFilter", extension);
-
     testRequest(backend, mainDocumentRequest("http://w3c.org"), { });
 
     testRequest(backend, mainDocumentRequest("http://w3c.org/foobafoobar"), { ContentExtensions::ActionType::BlockLoad });
@@ -219,12 +213,8 @@
 
 TEST_F(ContentExtensionTest, PatternStartingWithGroup)
 {
-    const char* patternsStartingWithGroupFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^(http://whatwg\\\\.org/)?webkit\134\134.org\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(patternsStartingWithGroupFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^(http://whatwg\\\\.org/)?webkit\134\134.org\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("PatternNestedGroupsFilter", extension);
-
     testRequest(backend, mainDocumentRequest("http://whatwg.org/webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://whatwg.org/webkit.org"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/"), { });
@@ -234,13 +224,8 @@
 
 TEST_F(ContentExtensionTest, PatternNestedGroups)
 {
-    const char* patternNestedGroupsFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^http://webkit\\\\.org/(foo(bar)*)+\"}}]";
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^http://webkit\\\\.org/(foo(bar)*)+\"}}]");
 
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(patternNestedGroupsFilter);
-
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("PatternNestedGroupsFilter", extension);
-
     testRequest(backend, mainDocumentRequest("http://webkit.org/foo"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/foobar"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/foobarbar"), { ContentExtensions::ActionType::BlockLoad });
@@ -256,13 +241,8 @@
 
 TEST_F(ContentExtensionTest, MatchPastEndOfString)
 {
-    const char* matchPastEndOfStringFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".+\"}}]";
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".+\"}}]");
 
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(matchPastEndOfStringFilter);
-
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("MatchPastEndOfString", extension);
-
     testRequest(backend, mainDocumentRequest("http://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/foo"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/foobar"), { ContentExtensions::ActionType::BlockLoad });
@@ -273,15 +253,10 @@
     testRequest(backend, mainDocumentRequest("http://webkit.org/foor"), { ContentExtensions::ActionType::BlockLoad });
 }
 
-const char* startOfLineAssertionFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^foobar\"}}]";
-
 TEST_F(ContentExtensionTest, StartOfLineAssertion)
 {
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(startOfLineAssertionFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^foobar\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("StartOfLineAssertion", extension);
-
     testRequest(backend, mainDocumentRequest("foobar://webkit.org/foobar"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("foobars:///foobar"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("foobarfoobar:///foobarfoobarfoobar"), { ContentExtensions::ActionType::BlockLoad });
@@ -294,12 +269,8 @@
 
 TEST_F(ContentExtensionTest, EndOfLineAssertion)
 {
-    const char* endOfLineAssertionFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foobar$\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(endOfLineAssertionFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foobar$\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("EndOfLineAssertion", extension);
-
     testRequest(backend, mainDocumentRequest("http://webkit.org/foobar"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("file:///foobar"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("file:///foobarfoobarfoobar"), { ContentExtensions::ActionType::BlockLoad });
@@ -310,12 +281,8 @@
 
 TEST_F(ContentExtensionTest, EndOfLineAssertionWithInvertedCharacterSet)
 {
-    const char* endOfLineAssertionWithInvertedCharacterSetFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[^y]$\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(endOfLineAssertionWithInvertedCharacterSetFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[^y]$\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("EndOfLineAssertion", extension);
-
     testRequest(backend, mainDocumentRequest("http://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/a"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/foobar"), { ContentExtensions::ActionType::BlockLoad });
@@ -329,15 +296,11 @@
 
 TEST_F(ContentExtensionTest, PrefixInfixSuffixExactMatch)
 {
-    const char* prefixInfixSuffixExactMatchFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"infix\"}},"
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"infix\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^prefix\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"suffix$\"}},"
-        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^http://exact\\\\.org/$\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(prefixInfixSuffixExactMatchFilter);
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^http://exact\\\\.org/$\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("PrefixInfixSuffixExactMatch", extension);
-
     testRequest(backend, mainDocumentRequest("infix://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://infix.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("https://webkit.org/infix"), { ContentExtensions::ActionType::BlockLoad });
@@ -356,13 +319,9 @@
 
 TEST_F(ContentExtensionTest, DuplicatedMatchAllTermsInVariousFormat)
 {
-    const char* duplicatedMatchAllTermsInVariousFormatFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".*.*(.)*(.*)(.+)*(.?)*infix\"}},"
-        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"pre(.?)+(.+)?post\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(duplicatedMatchAllTermsInVariousFormatFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".*.*(.)*(.*)(.+)*(.?)*infix\"}},"
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"pre(.?)+(.+)?post\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("DuplicatedMatchAllTermsInVariousFormat", extension);
-
     testRequest(backend, mainDocumentRequest("infix://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://infix.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("https://webkit.org/infix"), { ContentExtensions::ActionType::BlockLoad });
@@ -380,7 +339,7 @@
 
 TEST_F(ContentExtensionTest, TermsKnownToMatchAnything)
 {
-    const char* termsKnownToMatchAnythingFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre1.*post1$\"}},"
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre1.*post1$\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre2(.*)post2$\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre3(.*)?post3$\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre4(.*)+post4$\"}},"
@@ -389,12 +348,8 @@
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre7(.+)*post7$\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre8(.?)*post8$\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre9(.+)?post9$\"}},"
-        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre0(.?)+post0$\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(termsKnownToMatchAnythingFilter);
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre0(.?)+post0$\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("TermsKnownToMatchAnything", extension);
-
     testRequest(backend, mainDocumentRequest("pre1://webkit.org/post1"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("pre2://webkit.org/post2"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("pre3://webkit.org/post3"), { ContentExtensions::ActionType::BlockLoad });
@@ -431,13 +386,9 @@
 
 TEST_F(ContentExtensionTest, TrailingDotStar)
 {
-    const char* trailingDotStarFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foo.*$\"}},"
-        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"bar(.*)$\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(trailingDotStarFilter);
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foo.*$\"}},"
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"bar(.*)$\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("TrailingDotStar", extension);
-
     testRequest(backend, mainDocumentRequest("https://webkit.org/"), { });
 
     testRequest(backend, mainDocumentRequest("foo://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
@@ -453,14 +404,10 @@
 
 TEST_F(ContentExtensionTest, TrailingTermsCarryingNoData)
 {
-    const char* trailingTermsCarryingNoDataFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foob?a?r?\"}},"
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foob?a?r?\"}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"bazo(ok)?a?$\"}},"
-        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"cats*$\"}}]";
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(trailingTermsCarryingNoDataFilter);
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"cats*$\"}}]");
 
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("TrailingTermsCarryingNoData", extension);
-
     testRequest(backend, mainDocumentRequest("https://webkit.org/"), { });
 
     // Anything is fine after foo.
@@ -494,15 +441,10 @@
 
 TEST_F(ContentExtensionTest, LoadType)
 {
-    const char* loadTypeFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"webkit.org\",\"load-type\":[\"third-party\"]}},"
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"webkit.org\",\"load-type\":[\"third-party\"]}},"
         "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"whatwg.org\",\"load-type\":[\"first-party\"]}},"
-        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"alwaysblock.pdf\"}}]";
-
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(loadTypeFilter);
-        
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("LoadTypeFilter", extension);
-        
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"alwaysblock.pdf\"}}]");
+    
     testRequest(backend, mainDocumentRequest("http://webkit.org"), { });
     testRequest(backend, {URL(URL(), "http://webkit.org"), URL(URL(), "http://not_webkit.org"), ResourceType::Document}, { ContentExtensions::ActionType::BlockLoad });
         
@@ -515,14 +457,9 @@
 
 TEST_F(ContentExtensionTest, ResourceType)
 {
-    const char* resourceTypeFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"block_all_types.org\",\"resource-type\":[\"document\",\"image\",\"style-sheet\",\"script\",\"font\",\"raw\",\"svg-document\",\"media\"]}},"
-        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"block_only_images\",\"resource-type\":[\"image\"]}}]";
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"block_all_types.org\",\"resource-type\":[\"document\",\"image\",\"style-sheet\",\"script\",\"font\",\"raw\",\"svg-document\",\"media\"]}},"
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"block_only_images\",\"resource-type\":[\"image\"]}}]");
 
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(resourceTypeFilter);
-        
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("ResourceTypeFilter", extension);
-
     testRequest(backend, mainDocumentRequest("http://block_all_types.org", ResourceType::Document), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://block_all_types.org", ResourceType::Image), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://block_all_types.org", ResourceType::StyleSheet), { ContentExtensions::ActionType::BlockLoad });
@@ -535,6 +472,17 @@
     testRequest(backend, mainDocumentRequest("http://block_only_images.org", ResourceType::Document), { });
 }
 
+TEST_F(ContentExtensionTest, ResourceOrLoadTypeMatchingEverything)
+{
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".*\",\"resource-type\":[\"image\"]}},"
+        "{\"action\":{\"type\":\"block-cookies\"},\"trigger\":{\"url-filter\":\".*\",\"load-type\":[\"third-party\"]}},"
+        "{\"action\":{\"type\":\"ignore-previous-rules\"},\"trigger\":{\"url-filter\":\".*\",\"load-type\":[\"first-party\"]}}]");
+    
+    testRequest(backend, mainDocumentRequest("http://webkit.org"), { }, true);
+    testRequest(backend, {URL(URL(), "http://webkit.org"), URL(URL(), "http://not_webkit.org"), ResourceType::Document}, { ContentExtensions::ActionType::BlockCookies });
+    testRequest(backend, {URL(URL(), "http://webkit.org"), URL(URL(), "http://not_webkit.org"), ResourceType::Image}, { ContentExtensions::ActionType::BlockCookies, ContentExtensions::ActionType::BlockLoad });
+}
+    
 TEST_F(ContentExtensionTest, MultiDFA)
 {
     // Make an NFA with about 1400 nodes.
@@ -563,10 +511,7 @@
     }
     ruleList.append(']');
     
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(ruleList.toString());
-        
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("ResourceTypeFilter", extension);
+    auto backend = makeBackend(ruleList.toString().utf8().data());
 
     testRequest(backend, mainDocumentRequest("http://webkit.org/AAA"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/ZAA"), { ContentExtensions::ActionType::BlockLoad });
@@ -624,15 +569,10 @@
 
 TEST_F(ContentExtensionTest, StrictPrefixSeparatedMachines1)
 {
-    const char* strictPrefixSeparatedMachinesFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^.*foo\"}},"
-    "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"bar$\"}},"
-    "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^[ab]+bang\"}}]";
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^.*foo\"}},"
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"bar$\"}},"
+        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^[ab]+bang\"}}]");
 
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(strictPrefixSeparatedMachinesFilter);
-
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("StrictPrefixSeparatedMachines1", extension);
-
     testRequest(backend, mainDocumentRequest("http://webkit.org/foo"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("foo://webkit.org/bar"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("http://webkit.org/bar"), { ContentExtensions::ActionType::BlockLoad });
@@ -662,16 +602,11 @@
 
 TEST_F(ContentExtensionTest, StrictPrefixSeparatedMachines2)
 {
-    const char* strictPrefixSeparatedMachinesFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^foo\"}},"
+    auto backend = makeBackend("[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^foo\"}},"
     "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^.*[a-c]+bar\"}},"
     "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^webkit:\"}},"
-    "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[a-c]+b+oom\"}}]";
+    "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[a-c]+b+oom\"}}]");
 
-    auto extension = InMemoryCompiledContentExtension::createFromFilter(strictPrefixSeparatedMachinesFilter);
-
-    ContentExtensions::ContentExtensionsBackend backend;
-    backend.addContentExtension("StrictPrefixSeparatedMachines2", extension);
-
     testRequest(backend, mainDocumentRequest("http://webkit.org/"), { });
     testRequest(backend, mainDocumentRequest("foo://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });
     testRequest(backend, mainDocumentRequest("webkit://webkit.org/"), { ContentExtensions::ActionType::BlockLoad });

_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to