Changeset 182266 in webkit


Ignore:
Timestamp:
Apr 1, 2015 5:22:54 PM (9 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r182247.
​https://bugs.webkit.org/show_bug.cgi?id=143326

unfortunately broke some tests (Requested by dino on #webkit).

Reverted changeset:

"Async loading of image resources"
​https://bugs.webkit.org/show_bug.cgi?id=134488
​http://trac.webkit.org/changeset/182247

Location:
trunk
Files:
4 deleted
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r182264 r182266  
     12015-04-01  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r182247.
     4        https://bugs.webkit.org/show_bug.cgi?id=143326
     5
     6        unfortunately broke some tests (Requested by dino on #webkit).
     7
     8        Reverted changeset:
     9
     10        "Async loading of image resources"
     11        https://bugs.webkit.org/show_bug.cgi?id=134488
     12        http://trac.webkit.org/changeset/182247
     13
    1142015-04-01  Dean Jackson  <dino@apple.com>
    215

  • trunk/LayoutTests/fast/dom/HTMLImageElement/image-loading-gc.html

    r182247 r182266  
    3333</script>
    3434<body onload="runTest()">
    35     <div>This tests that an image element won't be garbage collected when it's loading, even if it doesn't have any references.</div>
     35<div>This tests that an image element won't be garbage collected when it's loading, even if it doesn't have any references.
    3636<div id="result">FAILURE</div>
    3737</body>

  • trunk/LayoutTests/fast/dom/image-object.html

    r182247 r182266  
    4747        numErrs++;
    4848    }
    49     i2 = new Image();
     49   
     50    i2 = new Image()
    5051    i2.onload = imageLoaded;
    5152    i2.src = 'resources/apple.gif';

  • trunk/LayoutTests/http/tests/misc/image-blocked-src-change-expected.txt

    r182247 r182266  
    1 CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
     1CONSOLE MESSAGE: line 44: Not allowed to load local resource: compass.jpg
    22Test case for bug 17897 : Not Rendering Images Imported from XHTML Document
    33

  • trunk/LayoutTests/http/tests/misc/image-blocked-src-no-change-expected.txt

    r182247 r182266  
    1 CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
    2 CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
     1CONSOLE MESSAGE: line 27: Not allowed to load local resource: compass.jpg
     2CONSOLE MESSAGE: line 21: Not allowed to load local resource: compass.jpg
    33Test case for bug 17897 : Not Rendering Images Imported from XHTML Document
    44

  • trunk/LayoutTests/http/tests/security/contentSecurityPolicy/report-blocked-file-uri-expected.txt

    r182247 r182266  
    66REQUEST_METHOD: POST
    77=== POST DATA ===
    8 {"csp-report":{"document-uri":"http://127.0.0.1:8000/security/contentSecurityPolicy/report-blocked-file-uri.html","referrer":"","violated-directive":"img-src 'none'","original-policy":"img-src 'none'; report-uri resources/save-report.php","blocked-uri":"file"}}
     8{"csp-report":{"document-uri":"http://127.0.0.1:8000/security/contentSecurityPolicy/report-blocked-file-uri.html","referrer":"","violated-directive":"img-src 'none'","original-policy":"img-src 'none'; report-uri resources/save-report.php","blocked-uri":"file","source-file":"http://127.0.0.1:8000/security/contentSecurityPolicy/report-blocked-file-uri.html","line-number":12}}

  • trunk/LayoutTests/http/tests/security/frame-loading-via-document-write-expected.txt

    r182247 r182266  
    1 CONSOLE MESSAGE: Not allowed to load local resource: abe.png
     1CONSOLE MESSAGE: line 1: Not allowed to load local resource: abe.png
    22
    33

  • trunk/LayoutTests/http/tests/security/local-image-from-remote-expected.txt

    r182247 r182266  
    1 CONSOLE MESSAGE: Not allowed to load local resource: compass.jpg
     1CONSOLE MESSAGE: line 14: Not allowed to load local resource: compass.jpg
    22This test is to see if a remote file can include a local image.
    33Currently this test cannot be run manually on Windows because we do not have a function like pathToLocalResource() outside of DRT.

  • trunk/Source/WebCore/ChangeLog

    r182265 r182266  
     12015-04-01  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r182247.
     4        https://bugs.webkit.org/show_bug.cgi?id=143326
     5
     6        unfortunately broke some tests (Requested by dino on #webkit).
     7
     8        Reverted changeset:
     9
     10        "Async loading of image resources"
     11        https://bugs.webkit.org/show_bug.cgi?id=134488
     12        http://trac.webkit.org/changeset/182247
     13
    1142015-04-01  Alex Christensen  <achristensen@webkit.org>
    215

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r182247 r182266  
    21022102                536D5A25193F40FC00CE4CAB /* SourceSizeList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 536D5A24193F40FC00CE4CAB /* SourceSizeList.cpp */; };
    21032103                536D5A27193F410B00CE4CAB /* SourceSizeList.h in Headers */ = {isa = PBXBuildFile; fileRef = 536D5A26193F410B00CE4CAB /* SourceSizeList.h */; settings = {ATTRIBUTES = (Private, ); }; };
    2104                 53B895AF19DC7ED9009CAA93 /* MicroTask.h in Headers */ = {isa = PBXBuildFile; fileRef = 53B895AD19DC7C37009CAA93 /* MicroTask.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2104                53B895AF19DC7ED9009CAA93 /* MicroTask.h in Headers */ = {isa = PBXBuildFile; fileRef = 53B895AD19DC7C37009CAA93 /* MicroTask.h */; settings = {ATTRIBUTES = (Public, ); }; };
    21052105                53C8298D13D8D92700DE2DEB /* RenderFlexibleBox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 53C8298B13D8D92700DE2DEB /* RenderFlexibleBox.cpp */; };
    21062106                53C8298E13D8D92700DE2DEB /* RenderFlexibleBox.h in Headers */ = {isa = PBXBuildFile; fileRef = 53C8298C13D8D92700DE2DEB /* RenderFlexibleBox.h */; settings = {ATTRIBUTES = (Private, ); }; };

  • trunk/Source/WebCore/bindings/js/JSEventListener.cpp

    r182247 r182266  
    3030#include "JSMainThreadExecState.h"
    3131#include "JSMainThreadExecStateInstrumentation.h"
    32 #include "MicroTask.h"
    3332#include "ScriptController.h"
    3433#include "WorkerGlobalScope.h"
    … …  
    153152        }
    154153    }
    155     if (scriptExecutionContext->isDocument())
    156         MicroTaskQueue::singleton().runMicroTasks();
    157154}
    158155

  • trunk/Source/WebCore/bindings/js/ScheduledAction.cpp

    r182247 r182266  
    3535#include "JSMainThreadExecStateInstrumentation.h"
    3636#include "JSWorkerGlobalScope.h"
    37 #include "MicroTask.h"
    3837#include "ScriptController.h"
    3938#include "ScriptExecutionContext.h"
    … …  
    127126    else
    128127        frame->script().executeScriptInWorld(*m_isolatedWorld, m_code);
    129 
    130     MicroTaskQueue::singleton().runMicroTasks();
    131128}
    132129

  • trunk/Source/WebCore/html/HTMLImageElement.cpp

    r182247 r182266  
    453453void HTMLImageElement::didMoveToNewDocument(Document* oldDocument)
    454454{
    455     m_imageLoader.elementDidMoveToNewDocument(oldDocument);
     455    m_imageLoader.elementDidMoveToNewDocument();
    456456    HTMLElement::didMoveToNewDocument(oldDocument);
    457457}

  • trunk/Source/WebCore/html/HTMLImageLoader.cpp

    r182247 r182266  
    7777{
    7878    CachedImage* cachedImage = image();
    79     if (!cachedImage)
    80         return;
    8179
    8280    Ref<Element> protect(element());

  • trunk/Source/WebCore/html/HTMLInputElement.cpp

    r182247 r182266  
    14961496{
    14971497    if (imageLoader())
    1498         imageLoader()->elementDidMoveToNewDocument(oldDocument);
     1498        imageLoader()->elementDidMoveToNewDocument();
    14991499
    15001500    bool needsSuspensionCallback = this->needsSuspensionCallback();

  • trunk/Source/WebCore/html/HTMLPlugInImageElement.cpp

    r182247 r182266  
    307307
    308308    if (m_imageLoader)
    309         m_imageLoader->elementDidMoveToNewDocument(oldDocument);
     309        m_imageLoader->elementDidMoveToNewDocument();
    310310
    311311    HTMLPlugInElement::didMoveToNewDocument(oldDocument);

  • trunk/Source/WebCore/html/HTMLVideoElement.cpp

    r182247 r182266  
    310310{
    311311    if (m_imageLoader)
    312         m_imageLoader->elementDidMoveToNewDocument(oldDocument);
     312        m_imageLoader->elementDidMoveToNewDocument();
    313313    HTMLMediaElement::didMoveToNewDocument(oldDocument);
    314314}

  • trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp

    r182247 r182266  
    3535#include "HTMLDocument.h"
    3636#include "InspectorInstrumentation.h"
    37 #include "MicroTask.h"
    3837
    3938namespace WebCore {
    … …  
    411410        return;
    412411    end();
    413     if (!isExecutingScript())
    414         MicroTaskQueue::singleton().runMicroTasks();
    415412}
    416413

  • trunk/Source/WebCore/loader/ImageLoader.cpp

    r182247 r182266  
    33 *           (C) 1999 Antti Koivisto (koivisto@kde.org)
    44 * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 Apple Inc. All rights reserved.
    5  * Copyright 2014 The Chromium Authors. All rights reserved.
    6  * Copyright (C) 2015 Akamai Technologies Inc. All rights reserved.
    75 *
    86 * This library is free software; you can redistribute it and/or
    … …  
    3735#include "HTMLObjectElement.h"
    3836#include "HTMLParserIdioms.h"
    39 #include "MemoryCache.h"
    4037#include "Page.h"
    4138#include "RenderImage.h"
    4239#include "RenderSVGImage.h"
    43 #include "ScriptController.h"
    4440#include "SecurityOrigin.h"
    4541#include <wtf/NeverDestroyed.h>
    … …  
    6864namespace WebCore {
    6965
    70 class ImageLoader::ImageLoaderTask : public MicroTask {
    71 public:
    72     ImageLoaderTask(WeakPtr<ImageLoader> loader, CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
    73         : m_loader(loader)
    74         , m_shouldBypassMainWorldContentSecurityPolicy(shouldBypassMainWorldContentSecurityPolicy)
    75     {
    76     }
    77 
    78 private:
    79     virtual void run() override
    80     {
    81         if (m_loader && m_loader->hasPendingTask())
    82             m_loader->doUpdateFromElement(m_shouldBypassMainWorldContentSecurityPolicy);
    83     }
    84 
    85     WeakPtr<ImageLoader> m_loader;
    86     CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy m_shouldBypassMainWorldContentSecurityPolicy;
    87 };
    88 
    8966static ImageEventSender& beforeLoadEventSender()
    9067{
    … …  
    11592    , m_image(0)
    11693    , m_derefElementTimer(*this, &ImageLoader::timerFired)
    117     , m_weakFactory(this)
    11894    , m_hasPendingBeforeLoadEvent(false)
    11995    , m_hasPendingLoadEvent(false)
    … …  
    12298    , m_loadManually(false)
    12399    , m_elementIsProtected(false)
    124     , m_hasPendingTask(false)
    125100{
    126101}
    … …  
    185160}
    186161
    187 void ImageLoader::doUpdateFromElement(CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
    188 {
    189     m_hasPendingTask = false;
    190     Document& document = m_element.document();
    191     AtomicString attr = m_element.imageSourceURL();
    192 
    193     String srcURI = sourceURI(attr);
    194     URL url;
    195     // Set url value only if srcURI is not empty. Otherwise, url will be the URL for the document itself.
    196     if (!srcURI.isEmpty())
    197         url = document.completeURL(srcURI);
     162void ImageLoader::updateFromElement()
     163{
     164    // If we're not making renderers for the page, then don't load images.  We don't want to slow
     165    // down the raw HTML parsing case by loading images we don't intend to display.
     166    Document& document = element().document();
     167    if (!document.hasLivingRenderTree())
     168        return;
     169
     170    AtomicString attr = element().imageSourceURL();
     171
     172    // Avoid loading a URL we already failed to load.
     173    if (!m_failedLoadURL.isEmpty() && attr == m_failedLoadURL)
     174        return;
     175
    198176    // Do not load any image if the 'src' attribute is missing or if it is
    199177    // an empty string.
    200178    CachedResourceHandle<CachedImage> newImage = 0;
    201     if (!url.isNull()) {
    202         ResourceRequest resourceRequest(url);
    203         CachedResourceRequest request(resourceRequest);
     179    if (!attr.isNull() && !stripLeadingAndTrailingHTMLSpaces(attr).isEmpty()) {
     180        CachedResourceRequest request(ResourceRequest(document.completeURL(sourceURI(attr))));
    204181        request.setInitiator(&element());
    205182
    206         AtomicString crossOriginMode = m_element.fastGetAttribute(HTMLNames::crossoriginAttr);
     183        String crossOriginMode = element().fastGetAttribute(HTMLNames::crossoriginAttr);
    207184        if (!crossOriginMode.isNull()) {
    208185            StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
    … …  
    219196            document.cachedResourceLoader().setAutoLoadImages(autoLoadOtherImages);
    220197        } else
    221             newImage = document.cachedResourceLoader().requestImage(request, shouldBypassMainWorldContentSecurityPolicy);
     198            newImage = document.cachedResourceLoader().requestImage(request);
    222199
    223200        // If we do not have an image here, it means that a cross-site
    … …  
    237214        errorEventSender().dispatchEventSoon(*this);
    238215    }
    239 
     216   
    240217    CachedImage* oldImage = m_image.get();
    241218    if (newImage != oldImage) {
    … …  
    289266    // from this function as doing so might result in the destruction of this ImageLoader.
    290267    updatedHasPendingEvent();
    291     document.decrementLoadEventDelayCount();
    292 }
    293 
    294 void ImageLoader::updateFromElement()
    295 {
    296     AtomicString attribute = m_element.imageSourceURL();
    297 
    298     // Avoid loading a URL we already failed to load.
    299     if (!m_failedLoadURL.isEmpty() && attribute == m_failedLoadURL)
    300         return;
    301 
    302     // If we're not making renderers for the page, then don't load images. We don't want to slow
    303     // down the raw HTML parsing case by loading images we don't intend to display.
    304     Document& document = element().document();
    305     if (!document.hasLivingRenderTree())
    306         return;
    307 
    308     CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy = CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy::No;
    309     if (document.frame() && document.frame()->script().shouldBypassMainWorldContentSecurityPolicy())
    310         shouldBypassMainWorldContentSecurityPolicy = CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy::Yes;
    311 
    312     if (!m_hasPendingTask) {
    313         m_hasPendingTask = true;
    314         document.incrementLoadEventDelayCount();
    315         if (shouldLoadImmediately(attribute))
    316             doUpdateFromElement(CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy::No);
    317         else
    318             MicroTaskQueue::singleton().queueMicroTask(std::make_unique<ImageLoaderTask>(createWeakPtr(), shouldBypassMainWorldContentSecurityPolicy));
    319     }
    320 }
    321 
    322 bool ImageLoader::shouldLoadImmediately(const AtomicString& attribute) const
    323 {
    324     String srcURI = sourceURI(attribute);
    325     URL url = element().document().completeURL(srcURI);
    326     return (srcURI.isEmpty()
    327         || url.isEmpty()
    328         || m_loadManually
    329         || !is<HTMLImageElement>(m_element)
    330         || url.protocolIsData()
    331         || MemoryCache::singleton().resourceForURL(url));
    332268}
    333269
    … …  
    341277{
    342278    ASSERT(m_failedLoadURL.isEmpty());
    343     ASSERT(resource);
    344279    ASSERT(resource == m_image.get());
    345280
    … …  
    350285    if (!m_hasPendingLoadEvent)
    351286        return;
    352 
    353     ASSERT(image());
    354     ASSERT(element().document().securityOrigin());
    355287
    356288    if (element().fastHasAttribute(HTMLNames::crossoriginAttr)
    … …  
    533465}
    534466
    535 void ImageLoader::elementDidMoveToNewDocument(Document* oldDocument)
    536 {
    537     if (m_hasPendingTask) {
    538         if (oldDocument)
    539             oldDocument->decrementLoadEventDelayCount();
    540         m_element.document().incrementLoadEventDelayCount();
    541     }
     467void ImageLoader::elementDidMoveToNewDocument()
     468{
    542469    clearFailedLoadURL();
    543470    clearImage();

  • trunk/Source/WebCore/loader/ImageLoader.h

    r182247 r182266  
    2626#include "CachedImageClient.h"
    2727#include "CachedResourceHandle.h"
    28 #include "CachedResourceLoader.h"
    29 #include "MicroTask.h"
    3028#include "Timer.h"
    31 #include <wtf/RefCounted.h>
    32 #include <wtf/WeakPtr.h>
    3329#include <wtf/text/AtomicString.h>
    3430
    3531namespace WebCore {
    3632
    37 class Document;
    3833class Element;
    3934class ImageLoader;
    4035class RenderImageResource;
    41 class URL;
    42 class Task;
    4336
    4437template<typename T> class EventSender;
    … …  
    5851    void updateFromElementIgnoringPreviousError();
    5952
    60     void elementDidMoveToNewDocument(Document* oldDocument);
     53    void elementDidMoveToNewDocument();
    6154
    6255    Element& element() { return m_element; }
    6356    const Element& element() const { return m_element; }
    6457
    65     bool imageComplete() const { return m_imageComplete && !m_hasPendingTask; }
     58    bool imageComplete() const { return m_imageComplete; }
    6659
    6760    CachedImage* image() const { return m_image.get(); }
    … …  
    7164
    7265    bool hasPendingBeforeLoadEvent() const { return m_hasPendingBeforeLoadEvent; }
    73     bool hasPendingActivity() const { return m_hasPendingLoadEvent || m_hasPendingErrorEvent || m_hasPendingTask; }
     66    bool hasPendingActivity() const { return m_hasPendingLoadEvent || m_hasPendingErrorEvent; }
    7467
    7568    void dispatchPendingEvent(ImageEventSender*);
    … …  
    7972    static void dispatchPendingErrorEvents();
    8073
    81     bool hasPendingTask() const { return m_hasPendingTask; }
    82 
    8374protected:
    8475    explicit ImageLoader(Element&);
    … …  
    8677
    8778private:
    88     class ImageLoaderTask;
    89 
    90     // Called from the task or from updateFromElement to initiate the load.
    91     void doUpdateFromElement(CachedResourceLoader::ShouldBypassMainWorldContentSecurityPolicy);
    9279    virtual void dispatchLoadEvent() = 0;
    9380    virtual String sourceURI(const AtomicString&) const = 0;
    … …  
    10794    void timerFired();
    10895
    109     // Determine whether to initiate a synchronous load or to schedule a microtask.
    110     bool shouldLoadImmediately(const AtomicString& attribtue) const;
    111     WeakPtr<ImageLoader> createWeakPtr() { return m_weakFactory.createWeakPtr(); }
    112 
    11396    Element& m_element;
    11497    CachedResourceHandle<CachedImage> m_image;
    11598    Timer m_derefElementTimer;
    116     WeakPtrFactory<ImageLoader> m_weakFactory;
    11799    AtomicString m_failedLoadURL;
    118100    bool m_hasPendingBeforeLoadEvent : 1;
    … …  
    122104    bool m_loadManually : 1;
    123105    bool m_elementIsProtected : 1;
    124     bool m_hasPendingTask : 1;
    125106};
    126107

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

    r182247 r182266  
    174174}
    175175
    176 CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request, ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
     176CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
    177177{
    178178    if (Frame* frame = this->frame()) {
    … …  
    186186   
    187187    request.setDefer(clientDefersImage(request.resourceRequest().url()) ? CachedResourceRequest::DeferredByClient : CachedResourceRequest::NoDefer);
    188     return downcast<CachedImage>(requestResource(CachedResource::ImageResource, request, shouldBypassMainWorldContentSecurityPolicy).get());
     188    return downcast<CachedImage>(requestResource(CachedResource::ImageResource, request).get());
    189189}
    190190
    … …  
    358358}
    359359
    360 bool CachedResourceLoader::canRequest(CachedResource::Type type, const URL& url, const ResourceLoaderOptions& options, bool forPreload, ShouldBypassMainWorldContentSecurityPolicy bypassMainWorldContentSecurityPolicy)
     360bool CachedResourceLoader::canRequest(CachedResource::Type type, const URL& url, const ResourceLoaderOptions& options, bool forPreload)
    361361{
    362362    if (document() && !document()->securityOrigin()->canDisplay(url)) {
    … …  
    367367    }
    368368
    369 
    370369    // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
    371     bool shouldBypassMainWorldContentSecurityPolicy = (bypassMainWorldContentSecurityPolicy == ShouldBypassMainWorldContentSecurityPolicy::Yes)
    372         || (frame() && frame()->script().shouldBypassMainWorldContentSecurityPolicy());
     370    bool shouldBypassMainWorldContentSecurityPolicy = (frame() && frame()->script().shouldBypassMainWorldContentSecurityPolicy());
    373371
    374372    // Some types of resources can be loaded only from the same origin.  Other
    … …  
    495493}
    496494
    497 CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request, ShouldBypassMainWorldContentSecurityPolicy shouldBypassMainWorldContentSecurityPolicy)
     495CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
    498496{
    499497    URL url = request.resourceRequest().url();
    … …  
    507505        return nullptr;
    508506
    509     if (!canRequest(type, url, request.options(), request.forPreload(), shouldBypassMainWorldContentSecurityPolicy))
     507    if (!canRequest(type, url, request.options(), request.forPreload()))
    510508        return nullptr;
    511509

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.h

    r182247 r182266  
    7272    ~CachedResourceLoader();
    7373
    74     enum class ShouldBypassMainWorldContentSecurityPolicy { No, Yes };
    75 
    76     CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&, ShouldBypassMainWorldContentSecurityPolicy = ShouldBypassMainWorldContentSecurityPolicy::No);
     74    CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&);
    7775    CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(CachedResourceRequest&);
    7876    CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&);
    … …  
    134132    void checkForPendingPreloads();
    135133    void printPreloadStats();
    136     bool canRequest(CachedResource::Type, const URL&, const ResourceLoaderOptions&, bool forPreload = false, ShouldBypassMainWorldContentSecurityPolicy = ShouldBypassMainWorldContentSecurityPolicy::No);
     134    bool canRequest(CachedResource::Type, const URL&, const ResourceLoaderOptions&, bool forPreload = false);
    137135
    138136    static const ResourceLoaderOptions& defaultCachedResourceOptions();
    … …  
    143141    explicit CachedResourceLoader(DocumentLoader*);
    144142
    145     CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&, ShouldBypassMainWorldContentSecurityPolicy = ShouldBypassMainWorldContentSecurityPolicy::No);
     143    CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&);
    146144    CachedResourceHandle<CachedResource> revalidateResource(const CachedResourceRequest&, CachedResource*);
    147145    CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, CachedResourceRequest&);

  • trunk/Source/WebCore/svg/SVGImageElement.cpp

    r182247 r182266  
    206206void SVGImageElement::didMoveToNewDocument(Document* oldDocument)
    207207{
    208     m_imageLoader.elementDidMoveToNewDocument(oldDocument);
     208    m_imageLoader.elementDidMoveToNewDocument();
    209209    SVGGraphicsElement::didMoveToNewDocument(oldDocument);
    210210}

  • trunk/Source/WebCore/xml/parser/XMLDocumentParser.cpp

    r182247 r182266  
    4141#include "HTMLStyleElement.h"
    4242#include "ImageLoader.h"
    43 #include "MicroTask.h"
    4443#include "ProcessingInstruction.h"
    4544#include "ResourceError.h"
    … …  
    202201    clearCurrentNodeStack();
    203202    document()->finishedParsing();
    204     MicroTaskQueue::singleton().runMicroTasks();
    205203}
    206204
Note: See TracChangeset for help on using the changeset viewer.