Changeset 181974 in webkit


Ignore:
Timestamp:
Mar 25, 2015 3:38:58 PM (9 years ago)
Author:
weinig@apple.com
Message:

[Content Extensions] Convert content extension compiling to return error codes and write its output using a client
https://bugs.webkit.org/show_bug.cgi?id=143059

Reviewed by Alex Christensen.

Source/WebCore:

  • WebCore.xcodeproj/project.pbxproj:

Add ContentExtensionError.h/cpp.

  • contentextensions/ContentExtensionError.cpp: Added.

(WebCore::ContentExtensions::contentExtensionErrorCategory):

  • contentextensions/ContentExtensionError.h: Added.

(WebCore::ContentExtensions::make_error_code):
Add ContentExtensionError enum and std::error_code adaptor.

  • contentextensions/ContentExtensionCompiler.h:

Instead of returning CompiledContentExtensionData, use a client interface
to pass data. Eventually, this should be turned into a direct streaming
interface so we can write directly to a file.

  • contentextensions/ContentExtensionCompiler.cpp:

(WebCore::ContentExtensions::compileRuleList):

  • contentextensions/ContentExtensionParser.cpp:

(WebCore::ContentExtensions::getTypeFlags):
(WebCore::ContentExtensions::loadTrigger):
(WebCore::ContentExtensions::loadAction):
(WebCore::ContentExtensions::loadRule):
(WebCore::ContentExtensions::loadEncodedRules):
(WebCore::ContentExtensions::parseRuleList):

  • contentextensions/ContentExtensionParser.h:

Convert to return an error.

Source/WebKit2:

  • Shared/WebCompiledContentExtension.cpp:
  • Shared/WebCompiledContentExtension.h:

(WebKit::LegacyContentExtensionCompilationClient::LegacyContentExtensionCompilationClient):
(WebKit::LegacyContentExtensionCompilationClient::writeBytecode):
(WebKit::LegacyContentExtensionCompilationClient::writeActions):
Add subclass of ContentExtensionCompilationClient for use with the non-file backed content
extensions.

  • UIProcess/API/C/WKUserContentFilterRef.cpp:

(WKUserContentFilterCreate):

  • UIProcess/API/Cocoa/_WKUserContentFilter.mm:

(-[_WKUserContentFilter initWithName:serializedRules:]):
Update to use the new interface of compileRuleList().

Tools:

  • TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp:

(TestWebKitAPI::InMemoryCompiledContentExtension::createFromFilter):
Update for new interface of compileRuleList().

Location:
trunk
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r181971 r181974  
     12015-03-25  Sam Weinig  <sam@webkit.org>
     2
     3        [Content Extensions] Convert content extension compiling to return error codes and write its output using a client
     4        https://bugs.webkit.org/show_bug.cgi?id=143059
     5
     6        Reviewed by Alex Christensen.
     7
     8        * WebCore.xcodeproj/project.pbxproj:
     9        Add ContentExtensionError.h/cpp.
     10
     11        * contentextensions/ContentExtensionError.cpp: Added.
     12        (WebCore::ContentExtensions::contentExtensionErrorCategory):
     13        * contentextensions/ContentExtensionError.h: Added.
     14        (WebCore::ContentExtensions::make_error_code):
     15        Add ContentExtensionError enum and std::error_code adaptor.
     16
     17        * contentextensions/ContentExtensionCompiler.h:
     18        Instead of returning CompiledContentExtensionData, use a client interface
     19        to pass data. Eventually, this should be turned into a direct streaming
     20        interface so we can write directly to a file.
     21
     22        * contentextensions/ContentExtensionCompiler.cpp:
     23        (WebCore::ContentExtensions::compileRuleList):
     24        * contentextensions/ContentExtensionParser.cpp:
     25        (WebCore::ContentExtensions::getTypeFlags):
     26        (WebCore::ContentExtensions::loadTrigger):
     27        (WebCore::ContentExtensions::loadAction):
     28        (WebCore::ContentExtensions::loadRule):
     29        (WebCore::ContentExtensions::loadEncodedRules):
     30        (WebCore::ContentExtensions::parseRuleList):
     31        * contentextensions/ContentExtensionParser.h:
     32        Convert to return an error.
     33
    1342015-03-25  Beth Dakin  <bdakin@apple.com>
    235
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r181933 r181974  
    25402540                7CE6CBFB187F370700D46BF5 /* FormatConverter.h in Headers */ = {isa = PBXBuildFile; fileRef = 7CE6CBFA187F370700D46BF5 /* FormatConverter.h */; };
    25412541                7CE6CBFD187F394900D46BF5 /* FormatConverter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7CE6CBFC187F394900D46BF5 /* FormatConverter.cpp */; };
     2542                7CFDC57C1AC1D80500E24A57 /* ContentExtensionError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7CFDC57A1AC1D80500E24A57 /* ContentExtensionError.cpp */; };
     2543                7CFDC57D1AC1D80500E24A57 /* ContentExtensionError.h in Headers */ = {isa = PBXBuildFile; fileRef = 7CFDC57B1AC1D80500E24A57 /* ContentExtensionError.h */; settings = {ATTRIBUTES = (Private, ); }; };
    25422544                7D741BDA177226AA00859170 /* CSSValueKeywords.h in Copy Generated Headers */ = {isa = PBXBuildFile; fileRef = 6565814809D13043000E61D7 /* CSSValueKeywords.h */; };
    25432545                7E37EF2E1339208800B29250 /* SubresourceLoaderCF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7E37EF2D1339208800B29250 /* SubresourceLoaderCF.cpp */; };
     
    97899791                7CE6CBFA187F370700D46BF5 /* FormatConverter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FormatConverter.h; sourceTree = "<group>"; };
    97909792                7CE6CBFC187F394900D46BF5 /* FormatConverter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FormatConverter.cpp; sourceTree = "<group>"; };
     9793                7CFDC57A1AC1D80500E24A57 /* ContentExtensionError.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ContentExtensionError.cpp; sourceTree = "<group>"; };
     9794                7CFDC57B1AC1D80500E24A57 /* ContentExtensionError.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ContentExtensionError.h; sourceTree = "<group>"; };
    97919795                7E37EF2D1339208800B29250 /* SubresourceLoaderCF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SubresourceLoaderCF.cpp; path = cf/SubresourceLoaderCF.cpp; sourceTree = "<group>"; };
    97929796                7E428CE413E3407F003B661C /* ResourceHandleIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ResourceHandleIOS.mm; sourceTree = "<group>"; };
     
    1550215506                                7C93F3481AA6BA5E00A98BAB /* CompiledContentExtension.h */,
    1550315507                                5CDFA6C71AA4F2DA00EA8746 /* ContentExtensionActions.h */,
     15508                                7CFDC57A1AC1D80500E24A57 /* ContentExtensionError.cpp */,
     15509                                7CFDC57B1AC1D80500E24A57 /* ContentExtensionError.h */,
    1550415510                                7C93F34B1AA6BF0700A98BAB /* ContentExtensionCompiler.cpp */,
    1550515511                                7C93F34C1AA6BF0700A98BAB /* ContentExtensionCompiler.h */,
     
    2541425420                                724ED3321A3A8B2300F5F13C /* JSEXTBlendMinMax.h in Headers */,
    2541525421                                B27B28280CEF0C0700D39D54 /* JSSVGGlyphElement.h in Headers */,
     25422                                7CFDC57D1AC1D80500E24A57 /* ContentExtensionError.h in Headers */,
    2541625423                                24D9129A13CA971400D21915 /* JSSVGGlyphRefElement.h in Headers */,
    2541725424                                B2FA3D9D0AB75A6F000E5AC4 /* JSSVGGradientElement.h in Headers */,
     
    2843028437                                2D46F04E17B96FBD005647F0 /* IntPoint.cpp in Sources */,
    2843128438                                B27535600B053814002CE64F /* IntPointCG.cpp in Sources */,
     28439                                7CFDC57C1AC1D80500E24A57 /* ContentExtensionError.cpp in Sources */,
    2843228440                                B275357C0B053814002CE64F /* IntPointMac.mm in Sources */,
    2843328441                                B27535730B053814002CE64F /* IntRect.cpp in Sources */,
  • trunk/Source/WebCore/contentextensions/ContentExtensionCompiler.cpp

    r181964 r181974  
    3131#include "CompiledContentExtension.h"
    3232#include "ContentExtensionActions.h"
     33#include "ContentExtensionError.h"
    3334#include "ContentExtensionParser.h"
    3435#include "ContentExtensionRule.h"
     
    100101
    101102
    102 CompiledContentExtensionData compileRuleList(const String& ruleList)
     103std::error_code compileRuleList(const String& ruleList, ContentExtensionCompilationClient& client)
    103104{
    104     auto parsedRuleList = parseRuleList(ruleList);
     105    Vector<ContentExtensionRule> parsedRuleList;
     106    auto parserError = parseRuleList(ruleList, parsedRuleList);
     107    if (parserError)
     108        return parserError;
    105109
    106110#if CONTENT_EXTENSIONS_PERFORMANCE_REPORTING
     
    179183#endif
    180184
    181     return { WTF::move(bytecode), WTF::move(actions) };
     185    client.writeBytecode(WTF::move(bytecode));
     186    client.writeActions(WTF::move(actions));
     187
     188    return { };
    182189}
    183190
  • trunk/Source/WebCore/contentextensions/ContentExtensionCompiler.h

    r181200 r181974  
    3030
    3131#include "CompiledContentExtension.h"
     32#include <system_error>
    3233#include <wtf/Forward.h>
    3334#include <wtf/Ref.h>
     
    4142};
    4243
    43 WEBCORE_EXPORT CompiledContentExtensionData compileRuleList(const String&);
     44class ContentExtensionCompilationClient {
     45public:
     46    virtual ~ContentExtensionCompilationClient() { }
     47   
     48    virtual void writeBytecode(Vector<DFABytecode>&&) = 0;
     49    virtual void writeActions(Vector<SerializedActionByte>&&) = 0;
     50};
     51
     52WEBCORE_EXPORT std::error_code compileRuleList(const String&, ContentExtensionCompilationClient&);
    4453
    4554} // namespace ContentExtensions
  • trunk/Source/WebCore/contentextensions/ContentExtensionParser.cpp

    r181754 r181974  
    2929#if ENABLE(CONTENT_EXTENSIONS)
    3030
     31#include "ContentExtensionError.h"
    3132#include "ContentExtensionRule.h"
    3233#include "ContentExtensionsBackend.h"
     
    4748namespace ContentExtensions {
    4849
    49 static bool getTypeFlags(ExecState& exec, const JSValue& typeValue, ResourceFlags& flags, uint16_t(*stringToType)(const String&))
     50static std::error_code getTypeFlags(ExecState& exec, const JSValue& typeValue, ResourceFlags& flags, uint16_t(*stringToType)(const String&))
    5051{
    5152    if (!typeValue.isObject())
    52         return true;
     53        return { };
    5354
    5455    JSObject* object = typeValue.toObject(&exec);
    55     if (!isJSArray(object)) {
    56         WTFLogAlways("Invalid trigger flags array");
    57         return false;
    58     }
     56    if (!isJSArray(object))
     57        return ContentExtensionError::JSONInvalidTriggerFlagsArray;
    5958
    6059    JSArray* array = jsCast<JSArray*>(object);
     
    6362    for (unsigned i = 0; i < length; ++i) {
    6463        JSValue value = array->getIndex(&exec, i);
    65         if (exec.hadException() || !value) {
    66             WTFLogAlways("Invalid object in the trigger flags array.");
    67             continue;
    68         }
     64        if (exec.hadException() || !value)
     65            return ContentExtensionError::JSONInvalidObjectInTriggerFlagsArray;
    6966       
    7067        String name = value.toWTFString(&exec);
    7168        uint16_t type = stringToType(name);
    72         if (!type) {
    73             WTFLogAlways("Invalid string in the trigger flags array.");
    74             continue;
    75         }
     69        if (!type)
     70            return ContentExtensionError::JSONInvalidStringInTriggerFlagsArray;
     71
    7672        flags |= type;
    7773    }
    78     return true;
    79 }
    80    
    81 static bool loadTrigger(ExecState& exec, JSObject& ruleObject, Trigger& trigger)
     74
     75    return { };
     76}
     77   
     78static std::error_code loadTrigger(ExecState& exec, JSObject& ruleObject, Trigger& trigger)
    8279{
    8380    JSValue triggerObject = ruleObject.get(&exec, Identifier(&exec, "trigger"));
    84     if (!triggerObject || exec.hadException() || !triggerObject.isObject()) {
    85         WTFLogAlways("Invalid trigger object.");
    86         return false;
    87     }
    88 
     81    if (!triggerObject || exec.hadException() || !triggerObject.isObject())
     82        return ContentExtensionError::JSONInvalidTrigger;
     83   
    8984    JSValue urlFilterObject = triggerObject.get(&exec, Identifier(&exec, "url-filter"));
    90     if (!urlFilterObject || exec.hadException() || !urlFilterObject.isString()) {
    91         WTFLogAlways("Invalid url-filter object.");
    92         return false;
    93     }
     85    if (!urlFilterObject || exec.hadException() || !urlFilterObject.isString())
     86        return ContentExtensionError::JSONInvalidURLFilterInTrigger;
    9487
    9588    String urlFilter = urlFilterObject.toWTFString(&exec);
    96     if (urlFilter.isEmpty()) {
    97         WTFLogAlways("Invalid url-filter object. The url is empty.");
    98         return false;
    99     }
     89    if (urlFilter.isEmpty())
     90        return ContentExtensionError::JSONInvalidURLFilterInTrigger;
     91
    10092    trigger.urlFilter = urlFilter;
    10193
     
    10597
    10698    JSValue resourceTypeValue = triggerObject.get(&exec, Identifier(&exec, "resource-type"));
    107     if (resourceTypeValue && !exec.hadException() && !getTypeFlags(exec, resourceTypeValue, trigger.flags, readResourceType))
    108         return false;
    109    
     99    if (resourceTypeValue && !exec.hadException()) {
     100        auto typeFlagsError = getTypeFlags(exec, resourceTypeValue, trigger.flags, readResourceType);
     101        if (typeFlagsError)
     102            return typeFlagsError;
     103    }
     104
    110105    JSValue loadTypeValue = triggerObject.get(&exec, Identifier(&exec, "load-type"));
    111     if (loadTypeValue && !exec.hadException() && !getTypeFlags(exec, loadTypeValue, trigger.flags, readLoadType))
    112         return false;
    113 
    114     return true;
    115 }
    116 
    117 static bool loadAction(ExecState& exec, JSObject& ruleObject, Action& action)
     106    if (loadTypeValue && !exec.hadException()) {
     107        auto typeFlagsError = getTypeFlags(exec, loadTypeValue, trigger.flags, readLoadType);
     108        if (typeFlagsError)
     109            return typeFlagsError;
     110    }
     111
     112    return { };
     113}
     114
     115static std::error_code loadAction(ExecState& exec, JSObject& ruleObject, Action& action)
    118116{
    119117    JSValue actionObject = ruleObject.get(&exec, Identifier(&exec, "action"));
    120     if (!actionObject || exec.hadException() || !actionObject.isObject()) {
    121         WTFLogAlways("Invalid action object.");
    122         return false;
    123     }
     118    if (!actionObject || exec.hadException() || !actionObject.isObject())
     119        return ContentExtensionError::JSONInvalidAction;
    124120
    125121    JSValue typeObject = actionObject.get(&exec, Identifier(&exec, "type"));
    126     if (!typeObject || exec.hadException() || !typeObject.isString()) {
    127         WTFLogAlways("Invalid url-filter object.");
    128         return false;
    129     }
     122    if (!typeObject || exec.hadException() || !typeObject.isString())
     123        return ContentExtensionError::JSONInvalidActionType;
    130124
    131125    String actionType = typeObject.toWTFString(&exec);
     
    139133    else if (actionType == "css-display-none") {
    140134        JSValue selector = actionObject.get(&exec, Identifier(&exec, "selector"));
    141         if (!selector || exec.hadException() || !selector.isString()) {
    142             WTFLogAlways("css-display-none action type requires a selector");
    143             return false;
    144         }
     135        if (!selector || exec.hadException() || !selector.isString())
     136            return ContentExtensionError::JSONInvalidCSSDisplayNoneActionType;
     137
    145138        action = Action(ActionType::CSSDisplayNoneSelector, selector.toWTFString(&exec));
    146     } else {
    147         WTFLogAlways("Unrecognized action: \"%s\"", actionType.utf8().data());
    148         return false;
    149     }
    150 
    151     return true;
    152 }
    153 
    154 static void loadRule(ExecState& exec, JSObject& ruleObject, Vector<ContentExtensionRule>& ruleList)
     139    } else
     140        return ContentExtensionError::JSONInvalidActionType;
     141
     142    return { };
     143}
     144
     145static std::error_code loadRule(ExecState& exec, JSObject& ruleObject, Vector<ContentExtensionRule>& ruleList)
    155146{
    156147    Trigger trigger;
    157     if (!loadTrigger(exec, ruleObject, trigger))
    158         return;
     148    auto triggerError = loadTrigger(exec, ruleObject, trigger);
     149    if (triggerError)
     150        return triggerError;
    159151
    160152    Action action;
    161     if (!loadAction(exec, ruleObject, action))
    162         return;
     153    auto actionError = loadAction(exec, ruleObject, action);
     154    if (actionError)
     155        return actionError;
    163156
    164157    ruleList.append(ContentExtensionRule(trigger, action));
    165 }
    166 
    167 static Vector<ContentExtensionRule> loadEncodedRules(ExecState& exec, const String& rules)
     158    return { };
     159}
     160
     161static std::error_code loadEncodedRules(ExecState& exec, const String& rules, Vector<ContentExtensionRule>& ruleList)
    168162{
    169163    JSValue decodedRules = JSONParse(&exec, rules);
    170164
    171     if (exec.hadException() || !decodedRules) {
    172         WTFLogAlways("Failed to parse the JSON string.");
    173         return Vector<ContentExtensionRule>();
    174     }
    175 
    176     if (decodedRules.isObject()) {
    177         JSObject* topLevelObject = decodedRules.toObject(&exec);
    178         if (!topLevelObject || exec.hadException()) {
    179             WTFLogAlways("Invalid input, the top level structure is not an object.");
    180             return Vector<ContentExtensionRule>();
    181         }
    182 
    183         if (!isJSArray(topLevelObject)) {
    184             WTFLogAlways("Invalid input, the top level object is not an array.");
    185             return Vector<ContentExtensionRule>();
    186         }
    187 
    188         Vector<ContentExtensionRule> ruleList;
    189         JSArray* topLevelArray = jsCast<JSArray*>(topLevelObject);
    190 
    191         unsigned length = topLevelArray->length();
    192         for (unsigned i = 0; i < length; ++i) {
    193             JSValue value = topLevelArray->getIndex(&exec, i);
    194             if (exec.hadException() || !value) {
    195                 WTFLogAlways("Invalid object in the array.");
    196                 continue;
    197             }
    198 
    199             JSObject* ruleObject = value.toObject(&exec);
    200             if (!ruleObject || exec.hadException()) {
    201                 WTFLogAlways("Invalid rule");
    202                 continue;
    203             }
    204             loadRule(exec, *ruleObject, ruleList);
    205         }
    206         return ruleList;
    207     }
    208     return Vector<ContentExtensionRule>();
    209 }
    210 
    211 Vector<ContentExtensionRule> parseRuleList(const String& rules)
     165    if (exec.hadException() || !decodedRules)
     166        return ContentExtensionError::JSONInvalid;
     167
     168    if (!decodedRules.isObject())
     169        return ContentExtensionError::JSONTopLevelStructureNotAnObject;
     170
     171    JSObject* topLevelObject = decodedRules.toObject(&exec);
     172    if (!topLevelObject || exec.hadException())
     173        return ContentExtensionError::JSONTopLevelStructureNotAnObject;
     174   
     175    if (!isJSArray(topLevelObject))
     176        return ContentExtensionError::JSONTopLevelStructureNotAnArray;
     177
     178    JSArray* topLevelArray = jsCast<JSArray*>(topLevelObject);
     179
     180    Vector<ContentExtensionRule> localRuleList;
     181
     182    unsigned length = topLevelArray->length();
     183    for (unsigned i = 0; i < length; ++i) {
     184        JSValue value = topLevelArray->getIndex(&exec, i);
     185        if (exec.hadException() || !value)
     186            return ContentExtensionError::JSONInvalidObjectInTopLevelArray;
     187
     188        JSObject* ruleObject = value.toObject(&exec);
     189        if (!ruleObject || exec.hadException())
     190            return ContentExtensionError::JSONInvalidRule;
     191
     192        auto error = loadRule(exec, *ruleObject, localRuleList);
     193        if (error)
     194            return error;
     195    }
     196
     197    ruleList = WTF::move(localRuleList);
     198    return { };
     199}
     200
     201std::error_code parseRuleList(const String& rules, Vector<ContentExtensionRule>& ruleList)
    212202{
    213203#if CONTENT_EXTENSIONS_PERFORMANCE_REPORTING
     
    220210
    221211    ExecState* exec = globalObject->globalExec();
    222     Vector<ContentExtensionRule> ruleList = loadEncodedRules(*exec, rules);
     212    auto error = loadEncodedRules(*exec, rules, ruleList);
    223213
    224214    vm.clear();
    225215
     216    if (error)
     217        return error;
     218
    226219    if (ruleList.isEmpty())
    227         WTFLogAlways("Empty extension.");
     220        return ContentExtensionError::JSONContainsNoRules;
    228221
    229222#if CONTENT_EXTENSIONS_PERFORMANCE_REPORTING
     
    232225#endif
    233226
    234     return ruleList;
     227    return { };
    235228}
    236229
  • trunk/Source/WebCore/contentextensions/ContentExtensionParser.h

    r181000 r181974  
    2929#if ENABLE(CONTENT_EXTENSIONS)
    3030
     31#include <system_error>
    3132#include <wtf/Forward.h>
    3233#include <wtf/Vector.h>
     
    3839class ContentExtensionRule;
    3940
    40 Vector<ContentExtensionRule> parseRuleList(const String& rules);
     41std::error_code parseRuleList(const String& rules, Vector<ContentExtensionRule>&);
    4142
    4243} // namespace ContentExtensions
  • trunk/Source/WebKit2/ChangeLog

    r181972 r181974  
     12015-03-25  Sam Weinig  <sam@webkit.org>
     2
     3        [Content Extensions] Convert content extension compiling to return error codes and write its output using a client
     4        https://bugs.webkit.org/show_bug.cgi?id=143059
     5
     6        Reviewed by Alex Christensen.
     7
     8        * Shared/WebCompiledContentExtension.cpp:
     9        * Shared/WebCompiledContentExtension.h:
     10        (WebKit::LegacyContentExtensionCompilationClient::LegacyContentExtensionCompilationClient):
     11        (WebKit::LegacyContentExtensionCompilationClient::writeBytecode):
     12        (WebKit::LegacyContentExtensionCompilationClient::writeActions):
     13        Add subclass of ContentExtensionCompilationClient for use with the non-file backed content
     14        extensions.
     15
     16        * UIProcess/API/C/WKUserContentFilterRef.cpp:
     17        (WKUserContentFilterCreate):
     18        * UIProcess/API/Cocoa/_WKUserContentFilter.mm:
     19        (-[_WKUserContentFilter initWithName:serializedRules:]):
     20        Update to use the new interface of compileRuleList().
     21
    1222015-03-25  Ryosuke Niwa  <rniwa@webkit.org>
    223
  • trunk/Source/WebKit2/Shared/WebCompiledContentExtension.cpp

    r181246 r181974  
    2929#if ENABLE(CONTENT_EXTENSIONS)
    3030
    31 #include <WebCore/ContentExtensionCompiler.h>
     31namespace WebKit {
    3232
    33 namespace WebKit {
     33LegacyContentExtensionCompilationClient::LegacyContentExtensionCompilationClient(WebCore::ContentExtensions::CompiledContentExtensionData& data)
     34    : m_data(data)
     35{
     36}
     37
     38void LegacyContentExtensionCompilationClient::writeBytecode(Vector<WebCore::ContentExtensions::DFABytecode>&& bytecode)
     39{
     40    m_data.bytecode = WTF::move(bytecode);
     41}
     42
     43void LegacyContentExtensionCompilationClient::writeActions(Vector<WebCore::ContentExtensions::SerializedActionByte>&& actions)
     44{
     45    m_data.actions = WTF::move(actions);
     46}
     47
    3448
    3549Ref<WebCompiledContentExtension> WebCompiledContentExtension::createFromCompiledContentExtensionData(const WebCore::ContentExtensions::CompiledContentExtensionData& compilerData)
     
    4357    data.bytecodeOffset = 0;
    4458    data.bytecodeSize = compilerData.bytecode.size();
    45     data.actionsOffset = compilerData.bytecode.size();
     59    data.actionsOffset = compilerData.  bytecode.size();
    4660    data.actionsSize = compilerData.actions.size();
    4761
  • trunk/Source/WebKit2/Shared/WebCompiledContentExtension.h

    r181246 r181974  
    3030
    3131#include "WebCompiledContentExtensionData.h"
     32#include <WebCore/ContentExtensionCompiler.h>
    3233#include <WebCore/CompiledContentExtension.h>
    3334
    34 namespace WebCore {
    35 namespace ContentExtensions {
    36 struct CompiledContentExtensionData;
    37 }
    38 }
     35namespace WebKit {
    3936
    40 namespace WebKit {
     37// FIXME: Remove this once everyone is converted to using the UserContentExtensionStore.
     38class LegacyContentExtensionCompilationClient final : public WebCore::ContentExtensions::ContentExtensionCompilationClient {
     39public:
     40    LegacyContentExtensionCompilationClient(WebCore::ContentExtensions::CompiledContentExtensionData&);
     41
     42    virtual void writeBytecode(Vector<WebCore::ContentExtensions::DFABytecode>&&) override;
     43    virtual void writeActions(Vector<WebCore::ContentExtensions::SerializedActionByte>&&) override;
     44
     45private:
     46    WebCore::ContentExtensions::CompiledContentExtensionData& m_data;
     47};
     48
    4149
    4250class WebCompiledContentExtension final : public WebCore::ContentExtensions::CompiledContentExtension {
  • trunk/Source/WebKit2/UIProcess/API/C/WKUserContentFilterRef.cpp

    r181246 r181974  
    3131#include "WebCompiledContentExtension.h"
    3232#include <WebCore/ContentExtensionCompiler.h>
     33#include <WebCore/ContentExtensionError.h>
    3334
    3435using namespace WebKit;
     
    4243{
    4344#if ENABLE(CONTENT_EXTENSIONS)
    44     auto compiledContentExtensionData = WebCore::ContentExtensions::compileRuleList(toWTFString(serializedRulesRef));
    45     auto compiledContentExtension = WebKit::WebCompiledContentExtension::createFromCompiledContentExtensionData(compiledContentExtensionData);
     45    WebCore::ContentExtensions::CompiledContentExtensionData data;
     46    LegacyContentExtensionCompilationClient client(data);
     47
     48    auto compilerError = WebCore::ContentExtensions::compileRuleList(toWTFString(serializedRulesRef), client);
     49    if (compilerError)
     50        return nullptr;
     51
     52    auto compiledContentExtension = WebKit::WebCompiledContentExtension::createFromCompiledContentExtensionData(data);
    4653
    4754    return toAPI(&API::UserContentExtension::create(toWTFString(nameRef), WTF::move(compiledContentExtension)).leakRef());
  • trunk/Source/WebKit2/UIProcess/API/Cocoa/_WKUserContentFilter.mm

    r181246 r181974  
    3131#include "WebCompiledContentExtension.h"
    3232#include <WebCore/ContentExtensionCompiler.h>
     33#include <WebCore/ContentExtensionError.h>
     34#include <string>
    3335
    3436@implementation _WKUserContentFilter
     
    3941        return nil;
    4042
    41     auto compiledContentExtensionData = WebCore::ContentExtensions::compileRuleList(String(serializedRules));
    42     auto compiledContentExtension = WebKit::WebCompiledContentExtension::createFromCompiledContentExtensionData(compiledContentExtensionData);
     43    WebCore::ContentExtensions::CompiledContentExtensionData data;
     44    WebKit::LegacyContentExtensionCompilationClient client(data);
    4345
     46    auto compilerError = WebCore::ContentExtensions::compileRuleList(String(serializedRules), client);
     47    if (compilerError)
     48        [NSException raise:NSGenericException format:@"Failed to compile rules with error: %s", compilerError.message().c_str()];
     49
     50    auto compiledContentExtension = WebKit::WebCompiledContentExtension::createFromCompiledContentExtensionData(data);
    4451    API::Object::constructInWrapper<API::UserContentExtension>(self, String(name), WTF::move(compiledContentExtension));
    4552
  • trunk/Tools/ChangeLog

    r181964 r181974  
     12015-03-25  Sam Weinig  <sam@webkit.org>
     2
     3        [Content Extensions] Convert content extension compiling to return error codes and write its output using a client
     4        https://bugs.webkit.org/show_bug.cgi?id=143059
     5
     6        Reviewed by Alex Christensen.
     7
     8        * TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp:
     9        (TestWebKitAPI::InMemoryCompiledContentExtension::createFromFilter):
     10        Update for new interface of compileRuleList().
     11
    1122015-03-25  Alex Christensen  <achristensen@webkit.org>
    213
  • trunk/Tools/TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp

    r181964 r181974  
    7575};
    7676
     77class InMemoryContentExtensionCompilationClient final : public WebCore::ContentExtensions::ContentExtensionCompilationClient {
     78public:
     79    InMemoryContentExtensionCompilationClient(WebCore::ContentExtensions::CompiledContentExtensionData& data)
     80        : m_data(data)
     81    {
     82    }
     83
     84    virtual void writeBytecode(Vector<WebCore::ContentExtensions::DFABytecode>&& bytecode) override
     85    {
     86        m_data.bytecode = WTF::move(bytecode);
     87    }
     88   
     89    virtual void writeActions(Vector<WebCore::ContentExtensions::SerializedActionByte>&& actions) override
     90    {
     91        m_data.actions = WTF::move(actions);
     92    }
     93
     94private:
     95    WebCore::ContentExtensions::CompiledContentExtensionData& m_data;
     96};
     97
    7798class InMemoryCompiledContentExtension : public ContentExtensions::CompiledContentExtension {
    7899public:
     100    static RefPtr<InMemoryCompiledContentExtension> createFromFilter(const String& filter)
     101    {
     102        WebCore::ContentExtensions::CompiledContentExtensionData extensionData;
     103        InMemoryContentExtensionCompilationClient client(extensionData);
     104        auto compilerError = ContentExtensions::compileRuleList(filter, client);
     105        if (compilerError)
     106            return nullptr;
     107
     108        return InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     109    }
     110
    79111    static RefPtr<InMemoryCompiledContentExtension> create(ContentExtensions::CompiledContentExtensionData&& data)
    80112    {
     
    127159TEST_F(ContentExtensionTest, Basic)
    128160{
    129     auto extensionData = ContentExtensions::compileRuleList(basicFilter);
    130     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     161    auto extension = InMemoryCompiledContentExtension::createFromFilter(basicFilter);
    131162
    132163    ContentExtensions::ContentExtensionsBackend backend;
     
    140171    const char* rangeBasicFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"w[0-9]c\", \"url-filter-is-case-sensitive\":true}},"
    141172        "{\"action\":{\"type\":\"block-cookies\"},\"trigger\":{\"url-filter\":\"[A-H][a-z]cko\", \"url-filter-is-case-sensitive\":true}}]";
    142     auto extensionData = ContentExtensions::compileRuleList(rangeBasicFilter);
    143     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     173    auto extension = InMemoryCompiledContentExtension::createFromFilter(rangeBasicFilter);
    144174
    145175    ContentExtensions::ContentExtensionsBackend backend;
     
    167197    // Transition of the type ([^X]X) effictively transition on every input.
    168198    const char* rangeExclusionGeneratingUniversalTransitionFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[^a]+afoobar\"}}]";
    169     auto extensionData = ContentExtensions::compileRuleList(rangeExclusionGeneratingUniversalTransitionFilter);
    170     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     199    auto extension = InMemoryCompiledContentExtension::createFromFilter(rangeExclusionGeneratingUniversalTransitionFilter);
    171200
    172201    ContentExtensions::ContentExtensionsBackend backend;
     
    190219{
    191220    const char* patternsStartingWithGroupFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^(http://whatwg\\\\.org/)?webkit\134\134.org\"}}]";
    192     auto extensionData = ContentExtensions::compileRuleList(patternsStartingWithGroupFilter);
    193     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     221    auto extension = InMemoryCompiledContentExtension::createFromFilter(patternsStartingWithGroupFilter);
    194222
    195223    ContentExtensions::ContentExtensionsBackend backend;
     
    207235    const char* patternNestedGroupsFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^http://webkit\\\\.org/(foo(bar)*)+\"}}]";
    208236
    209     auto extensionData = ContentExtensions::compileRuleList(patternNestedGroupsFilter);
    210     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     237    auto extension = InMemoryCompiledContentExtension::createFromFilter(patternNestedGroupsFilter);
    211238
    212239    ContentExtensions::ContentExtensionsBackend backend;
     
    230257    const char* matchPastEndOfStringFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".+\"}}]";
    231258
    232     auto extensionData = ContentExtensions::compileRuleList(matchPastEndOfStringFilter);
    233     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     259    auto extension = InMemoryCompiledContentExtension::createFromFilter(matchPastEndOfStringFilter);
    234260
    235261    ContentExtensions::ContentExtensionsBackend backend;
     
    250276TEST_F(ContentExtensionTest, StartOfLineAssertion)
    251277{
    252     auto extensionData = ContentExtensions::compileRuleList(startOfLineAssertionFilter);
    253     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     278    auto extension = InMemoryCompiledContentExtension::createFromFilter(startOfLineAssertionFilter);
    254279
    255280    ContentExtensions::ContentExtensionsBackend backend;
     
    269294{
    270295    const char* endOfLineAssertionFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foobar$\"}}]";
    271     auto extensionData = ContentExtensions::compileRuleList(endOfLineAssertionFilter);
    272     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     296    auto extension = InMemoryCompiledContentExtension::createFromFilter(endOfLineAssertionFilter);
    273297
    274298    ContentExtensions::ContentExtensionsBackend backend;
     
    286310{
    287311    const char* endOfLineAssertionWithInvertedCharacterSetFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"[^y]$\"}}]";
    288     auto extensionData = ContentExtensions::compileRuleList(endOfLineAssertionWithInvertedCharacterSetFilter);
    289     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     312    auto extension = InMemoryCompiledContentExtension::createFromFilter(endOfLineAssertionWithInvertedCharacterSetFilter);
    290313
    291314    ContentExtensions::ContentExtensionsBackend backend;
     
    309332        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"suffix$\"}},"
    310333        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^http://exact\\\\.org/$\"}}]";
    311     auto extensionData = ContentExtensions::compileRuleList(prefixInfixSuffixExactMatchFilter);
    312     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     334    auto extension = InMemoryCompiledContentExtension::createFromFilter(prefixInfixSuffixExactMatchFilter);
    313335
    314336    ContentExtensions::ContentExtensionsBackend backend;
     
    335357    const char* duplicatedMatchAllTermsInVariousFormatFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".*.*(.)*(.*)(.+)*(.?)*infix\"}},"
    336358        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"pre(.?)+(.+)?post\"}}]";
    337     auto extensionData = ContentExtensions::compileRuleList(duplicatedMatchAllTermsInVariousFormatFilter);
    338     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     359    auto extension = InMemoryCompiledContentExtension::createFromFilter(duplicatedMatchAllTermsInVariousFormatFilter);
    339360
    340361    ContentExtensions::ContentExtensionsBackend backend;
     
    368389        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre9(.+)?post9$\"}},"
    369390        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"^pre0(.?)+post0$\"}}]";
    370     auto extensionData = ContentExtensions::compileRuleList(termsKnownToMatchAnythingFilter);
    371     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     391    auto extension = InMemoryCompiledContentExtension::createFromFilter(termsKnownToMatchAnythingFilter);
    372392
    373393    ContentExtensions::ContentExtensionsBackend backend;
     
    412432    const char* trailingDotStarFilter = "[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"foo.*$\"}},"
    413433        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"bar(.*)$\"}}]";
    414     auto extensionData = ContentExtensions::compileRuleList(trailingDotStarFilter);
    415     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     434    auto extension = InMemoryCompiledContentExtension::createFromFilter(trailingDotStarFilter);
    416435
    417436    ContentExtensions::ContentExtensionsBackend backend;
     
    436455        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"bazo(ok)?a?$\"}},"
    437456        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"cats*$\"}}]";
    438     auto extensionData = ContentExtensions::compileRuleList(trailingTermsCarryingNoDataFilter);
    439     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     457    auto extension = InMemoryCompiledContentExtension::createFromFilter(trailingTermsCarryingNoDataFilter);
    440458
    441459    ContentExtensions::ContentExtensionsBackend backend;
     
    479497        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"alwaysblock.pdf\"}}]";
    480498
    481     auto extensionData = ContentExtensions::compileRuleList(loadTypeFilter);
    482     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     499    auto extension = InMemoryCompiledContentExtension::createFromFilter(loadTypeFilter);
    483500       
    484501    ContentExtensions::ContentExtensionsBackend backend;
     
    500517        "{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"block_only_images\",\"resource-type\":[\"image\"]}}]";
    501518
    502     auto extensionData = ContentExtensions::compileRuleList(resourceTypeFilter);
    503     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     519    auto extension = InMemoryCompiledContentExtension::createFromFilter(resourceTypeFilter);
    504520       
    505521    ContentExtensions::ContentExtensionsBackend backend;
     
    546562    ruleList.append(']');
    547563   
    548     auto extensionData = ContentExtensions::compileRuleList(ruleList.toString());
    549     auto extension = InMemoryCompiledContentExtension::create(WTF::move(extensionData));
     564    auto extension = InMemoryCompiledContentExtension::createFromFilter(ruleList.toString());
    550565       
    551566    ContentExtensions::ContentExtensionsBackend backend;
Note: See TracChangeset for help on using the changeset viewer.