Changeset 175491 in webkit


Ignore:
Timestamp:
Nov 3, 2014, 2:27:59 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r175406, r175413, and r175423.
​https://bugs.webkit.org/show_bug.cgi?id=138327

Multipart tests are still broken (Requested by ap on #webkit).

Reverted changesets:

"Eliminate ResourceBuffer and use SharedBuffer directly
instead"
​https://bugs.webkit.org/show_bug.cgi?id=138174
​http://trac.webkit.org/changeset/175406

"Unreviewed, iOS build fix since 175406."
​http://trac.webkit.org/changeset/175413

"Fix assertion in CachedResource::addDataBuffer"
​http://trac.webkit.org/changeset/175423

Location:
trunk/Source
Files:
3 added
76 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/CMakeLists.txt

    r175414 r175491  
    18171817    loader/PolicyChecker.cpp
    18181818    loader/ProgressTracker.cpp
     1819    loader/ResourceBuffer.cpp
    18191820    loader/ResourceLoadNotifier.cpp
    18201821    loader/ResourceLoadScheduler.cpp

  • trunk/Source/WebCore/ChangeLog

    r175490 r175491  
     12014-11-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r175406, r175413, and r175423.
     4        https://bugs.webkit.org/show_bug.cgi?id=138327
     5
     6        Multipart tests are still broken (Requested by ap on #webkit).
     7
     8        Reverted changesets:
     9
     10        "Eliminate ResourceBuffer and use SharedBuffer directly
     11        instead"
     12        https://bugs.webkit.org/show_bug.cgi?id=138174
     13        http://trac.webkit.org/changeset/175406
     14
     15        "Unreviewed, iOS build fix since 175406."
     16        http://trac.webkit.org/changeset/175413
     17
     18        "Fix assertion in CachedResource::addDataBuffer"
     19        http://trac.webkit.org/changeset/175423
     20
    1212014-11-03  Chris Dumez  <cdumez@apple.com>
    222

  • trunk/Source/WebCore/WebCore.exp.in

    r175484 r175491  
    342342__ZN7WebCore14CachedResource12removeClientEPNS_20CachedResourceClientE
    343343__ZN7WebCore14CachedResource16unregisterHandleEPNS_24CachedResourceHandleBaseE
    344 __ZN7WebCore14CachedResource21tryReplaceEncodedDataERNS_12SharedBufferE
     344__ZN7WebCore14CachedResource21tryReplaceEncodedDataEN3WTF10PassRefPtrINS_12SharedBufferEEE
    345345__ZN7WebCore14CachedResource9addClientEPNS_20CachedResourceClientE
    346346__ZN7WebCore14ClientRectListC1ERKN3WTF6VectorINS_9FloatQuadELm0ENS1_15CrashOnOverflowEEE
    … …  
    385385__ZN7WebCore14LoaderStrategy25loadResourceSynchronouslyEPNS_17NetworkingContextEmRKNS_15ResourceRequestENS_17StoredCredentialsENS_22ClientCredentialPolicyERNS_13ResourceErrorERNS_16ResourceResponseERN3WTF6VectorIcLm0ENSC_15CrashOnOverflowEEE
    386386__ZN7WebCore14PluginDocument12pluginWidgetEv
     387__ZN7WebCore14ResourceBuffer12createNSDataEv
     388__ZN7WebCore14ResourceBuffer6appendEPKcj
     389__ZN7WebCore14ResourceBufferC1EPKcj
     390__ZN7WebCore14ResourceBufferC1Ev
     391__ZN7WebCore14ResourceBufferC2Ev
     392__ZN7WebCore14ResourceBufferD1Ev
     393__ZN7WebCore14ResourceBufferD2Ev
    387394__ZN7WebCore14ResourceHandle12firstRequestEv
    388395__ZN7WebCore14ResourceHandle16setDefersLoadingEb
    … …  
    17251732__ZNK7WebCore14InsertionPoint8isActiveEv
    17261733__ZNK7WebCore14RenderListItem10markerTextEv
     1734__ZNK7WebCore14ResourceBuffer4dataEv
     1735__ZNK7WebCore14ResourceBuffer4sizeEv
     1736__ZNK7WebCore14ResourceBuffer7isEmptyEv
    17271737__ZNK7WebCore14ResourceHandle10connectionEv
    17281738__ZNK7WebCore14ResourceLoader11frameLoaderEv
    … …  
    27972807__ZNK7WebCore14FrameSelection35characterInRelationToCaretSelectionEi
    27982808__ZNK7WebCore14FrameSelection36elementRangeContainingCaretSelectionEv
     2809__ZNK7WebCore14ResourceBuffer12sharedBufferEv
    27992810__ZNK7WebCore14SecurityOrigin8toStringEv
    28002811__ZNK7WebCore15GraphicsLayerCA21contentsLayerForMediaEv

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r175406 r175491  
    72527252    <ClCompile Include="..\loader\PolicyChecker.cpp" />
    72537253    <ClCompile Include="..\loader\ProgressTracker.cpp" />
     7254    <ClCompile Include="..\loader\ResourceBuffer.cpp" />
    72547255    <ClCompile Include="..\loader\ResourceLoader.cpp" />
    72557256    <ClCompile Include="..\loader\cf\ResourceLoaderCFNet.cpp" />
    … …  
    1925419255    <ClInclude Include="..\loader\ProgressTracker.h" />
    1925519256    <ClInclude Include="..\loader\ProgressTrackerClient.h" />
     19257    <ClInclude Include="..\loader\ResourceBuffer.h" />
    1925619258    <ClInclude Include="..\loader\ResourceLoader.h" />
    1925719259    <ClInclude Include="..\loader\ResourceLoaderOptions.h" />

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

    r175406 r175491  
    928928      <Filter>loader</Filter>
    929929    </ClCompile>
     930    <ClCompile Include="..\loader\ResourceBuffer.cpp">
     931      <Filter>loader</Filter>
     932    </ClCompile>
    930933    <ClCompile Include="..\loader\ResourceLoader.cpp">
    931934      <Filter>loader</Filter>
    … …  
    79467949    </ClInclude>
    79477950    <ClInclude Include="..\loader\ProgressTrackerClient.h">
     7951      <Filter>loader</Filter>
     7952    </ClInclude>
     7953    <ClInclude Include="..\loader\ResourceBuffer.h">
    79487954      <Filter>loader</Filter>
    79497955    </ClInclude>

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

    r175406 r175491  
    18691869                514B3F730C722047000530DF /* FileSystem.h in Headers */ = {isa = PBXBuildFile; fileRef = 514B3F720C722047000530DF /* FileSystem.h */; settings = {ATTRIBUTES = (Private, ); }; };
    18701870                514B3F760C722055000530DF /* FileSystemMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 514B3F750C722055000530DF /* FileSystemMac.mm */; };
     1871                514BC83F161CF04A004D52F4 /* ResourceBuffer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 514BC83D161CF043004D52F4 /* ResourceBuffer.mm */; };
     1872                514BC842161CF05C004D52F4 /* ResourceBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 514BC840161CF05C004D52F4 /* ResourceBuffer.cpp */; };
     1873                514BC843161CF05C004D52F4 /* ResourceBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 514BC841161CF05C004D52F4 /* ResourceBuffer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    18711874                514C76370CE9225E007EF3CD /* JSSQLError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 514C76350CE9225E007EF3CD /* JSSQLError.cpp */; };
    18721875                514C76380CE9225E007EF3CD /* JSSQLTransaction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 514C76360CE9225E007EF3CD /* JSSQLTransaction.cpp */; };
    … …  
    89788981                514B3F720C722047000530DF /* FileSystem.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystem.h; sourceTree = "<group>"; };
    89798982                514B3F750C722055000530DF /* FileSystemMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = FileSystemMac.mm; sourceTree = "<group>"; };
     8983                514BC83D161CF043004D52F4 /* ResourceBuffer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ResourceBuffer.mm; sourceTree = "<group>"; };
     8984                514BC840161CF05C004D52F4 /* ResourceBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResourceBuffer.cpp; sourceTree = "<group>"; };
     8985                514BC841161CF05C004D52F4 /* ResourceBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceBuffer.h; sourceTree = "<group>"; };
    89808986                514C76350CE9225E007EF3CD /* JSSQLError.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSSQLError.cpp; sourceTree = "<group>"; };
    89818987                514C76360CE9225E007EF3CD /* JSSQLTransaction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSSQLTransaction.cpp; sourceTree = "<group>"; };
    … …  
    1762517631                                656D371A0ADBA5DE00A4554D /* LoaderNSURLExtras.h */,
    1762617632                                656D371B0ADBA5DE00A4554D /* LoaderNSURLExtras.mm */,
     17633                                514BC83D161CF043004D52F4 /* ResourceBuffer.mm */,
    1762717634                                51AA3F6E0BD5AA9E00892971 /* ResourceLoaderMac.mm */,
    1762817635                        );
    … …  
    2129221299                                1A2A68220B5BEDE70002A480 /* ProgressTracker.h */,
    2129321300                                1ACADD781880D91C00D8B71D /* ProgressTrackerClient.h */,
     21301                                514BC840161CF05C004D52F4 /* ResourceBuffer.cpp */,
     21302                                514BC841161CF05C004D52F4 /* ResourceBuffer.h */,
    2129421303                                93E227DE0AF589AD00D48324 /* ResourceLoader.cpp */,
    2129521304                                656D37270ADBA5DE00A4554D /* ResourceLoader.h */,
    … …  
    2585425863                                4998AEC613F9D0EA0090B1AA /* RequestAnimationFrameCallback.h in Headers */,
    2585525864                                F55B3DD01251F12D003EF269 /* ResetInputType.h in Headers */,
     25865                                514BC843161CF05C004D52F4 /* ResourceBuffer.h in Headers */,
    2585625866                                7EE6846A12D26E3800E79415 /* ResourceError.h in Headers */,
    2585725867                                934F713C0D5A6F1900018D69 /* ResourceErrorBase.h in Headers */,
    … …  
    2932129331                                99CC0B5B18BE984A006CEBCC /* ReplaySessionSegment.cpp in Sources */,
    2932229332                                F55B3DCF1251F12D003EF269 /* ResetInputType.cpp in Sources */,
     29333                                514BC842161CF05C004D52F4 /* ResourceBuffer.cpp in Sources */,
     29334                                514BC83F161CF04A004D52F4 /* ResourceBuffer.mm in Sources */,
    2932329335                                934F713E0D5A6F2800018D69 /* ResourceErrorBase.cpp in Sources */,
    2932429336                                7EE6846B12D26E3800E79415 /* ResourceErrorCF.cpp in Sources */,

  • trunk/Source/WebCore/bindings/objc/DOMUIKitExtensions.mm

    r175406 r175491  
    6363#import "RenderStyleConstants.h"
    6464#import "RenderText.h"
     65#import "ResourceBuffer.h"
    6566#import "SharedBuffer.h"
    6667#import "VisiblePosition.h"
    … …  
    464465- (NSData *)dataRepresentation:(BOOL)rawImageData
    465466{
    466     WebCore::CachedImage* cachedImage = core(self)->cachedImage();
     467    WebCore::CachedImage *cachedImage = core(self)->cachedImage();
    467468    if (!cachedImage)
    468469        return nil;
    469     WebCore::Image* image = cachedImage->image();
     470    WebCore::Image *image = cachedImage->image();
    470471    if (!image)
    471472        return nil;
    472     WebCore::SharedBuffer* data = rawImageData ? cachedImage->resourceBuffer() : image->data();
     473    WebCore::SharedBuffer *data = nil;
     474    if (rawImageData) {
     475        ResourceBuffer *resourceBuffer = cachedImage->resourceBuffer();
     476        if (resourceBuffer)
     477            data = resourceBuffer->sharedBuffer();
     478    } else {
     479        data = image->data();
     480    }
    473481    if (!data)
    474482        return nil;
     483
    475484    return data->createNSData().autorelease();
    476485}

  • trunk/Source/WebCore/editing/ios/EditorIOS.mm

    r175406 r175491  
    5050#include "RenderBlock.h"
    5151#include "RenderImage.h"
     52#include "ResourceBuffer.h"
    5253#include "SharedBuffer.h"
    5354#include "SoftLinking.h"
    … …  
    385386    pasteboardImage.url.title = title;
    386387    pasteboardImage.resourceMIMEType = pasteboard.resourceMIMEType(cachedImage->response().mimeType());
    387     pasteboardImage.resourceData = cachedImage->resourceBuffer();
     388    pasteboardImage.resourceData = cachedImage->resourceBuffer()->sharedBuffer();
    388389
    389390    pasteboard.write(pasteboardImage);

  • trunk/Source/WebCore/editing/mac/EditorMac.mm

    r175406 r175491  
    5353#import "RenderBlock.h"
    5454#import "RenderImage.h"
     55#import "ResourceBuffer.h"
    5556#import "RuntimeApplicationChecks.h"
    5657#import "Sound.h"
    … …  
    447448    pasteboardImage.url.title = title;
    448449    pasteboardImage.url.userVisibleForm = client()->userVisibleString(pasteboardImage.url.url);
    449     pasteboardImage.resourceData = cachedImage->resourceBuffer();
     450    pasteboardImage.resourceData = cachedImage->resourceBuffer()->sharedBuffer();
    450451    pasteboardImage.resourceMIMEType = cachedImage->response().mimeType();
    451452

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

    r175406 r175491  
    4646#include "RawDataDocumentParser.h"
    4747#include "RenderElement.h"
     48#include "ResourceBuffer.h"
    4849#include "Settings.h"
    4950
    … …  
    134135        createDocumentStructure();
    135136
    136     if (RefPtr<SharedBuffer> buffer = loader()->mainResourceData())
    137         m_imageElement->cachedImage()->addDataBuffer(*buffer);
     137    m_imageElement->cachedImage()->addDataBuffer(loader()->mainResourceData().get());
    138138
    139139    imageUpdated();
    … …  
    144144    if (!parser()->isStopped() && m_imageElement) {
    145145        CachedImage& cachedImage = *m_imageElement->cachedImage();
    146         RefPtr<SharedBuffer> data = loader()->mainResourceData();
     146        RefPtr<ResourceBuffer> data = loader()->mainResourceData();
    147147
    148148        // If this is a multipart image, make a copy of the current part, since the resource data
    149149        // will be overwritten by the next part.
    150         if (data && loader()->isLoadingMultipartContent())
     150        if (loader()->isLoadingMultipartContent())
    151151            data = data->copy();
    152152

  • trunk/Source/WebCore/inspector/InspectorPageAgent.cpp

    r175406 r175491  
    6363#include "MemoryCache.h"
    6464#include "Page.h"
     65#include "ResourceBuffer.h"
    6566#include "ScriptController.h"
    6667#include "SecurityOrigin.h"
    … …  
    143144    *base64Encoded = !hasTextContent(cachedResource);
    144145    if (*base64Encoded) {
    145         RefPtr<SharedBuffer> buffer = hasZeroSize ? SharedBuffer::create() : cachedResource->resourceBuffer();
     146        RefPtr<SharedBuffer> buffer = hasZeroSize ? SharedBuffer::create() : cachedResource->resourceBuffer()->sharedBuffer();
     147
    146148        if (!buffer)
    147149            return false;
     150
    148151        *result = base64Encode(buffer->data(), buffer->size());
    149152        return true;
    … …  
    164167            return true;
    165168        case CachedResource::RawResource: {
    166             auto* buffer = cachedResource->resourceBuffer();
     169            ResourceBuffer* buffer = cachedResource->resourceBuffer();
    167170            if (!buffer)
    168171                return false;
    … …  
    175178        }
    176179        default:
    177             auto* buffer = cachedResource->resourceBuffer();
     180            ResourceBuffer* buffer = cachedResource->resourceBuffer();
    178181            return decodeBuffer(buffer ? buffer->data() : nullptr, buffer ? buffer->size() : 0, cachedResource->encoding(), result);
    179182        }
    … …  
    184187bool InspectorPageAgent::mainResourceContent(Frame* frame, bool withBase64Encode, String* result)
    185188{
    186     RefPtr<SharedBuffer> buffer = frame->loader().documentLoader()->mainResourceData();
     189    RefPtr<ResourceBuffer> buffer = frame->loader().documentLoader()->mainResourceData();
    187190    if (!buffer)
    188191        return false;
    189     return InspectorPageAgent::dataContent(buffer->data(), buffer->size(), frame->document()->inputEncoding(), withBase64Encode, result);
     192    String textEncodingName = frame->document()->inputEncoding();
     193
     194    return InspectorPageAgent::dataContent(buffer->data(), buffer->size(), textEncodingName, withBase64Encode, result);
    190195}
    191196

  • trunk/Source/WebCore/inspector/InspectorResourceAgent.cpp

    r175406 r175491  
    5555#include "Page.h"
    5656#include "ProgressTracker.h"
     57#include "ResourceBuffer.h"
    5758#include "ResourceError.h"
    5859#include "ResourceLoader.h"
    … …  
    405406    String requestId = IdentifiersFactory::requestId(identifier);
    406407    if (m_resourcesData->resourceType(requestId) == InspectorPageAgent::DocumentResource) {
    407         m_resourcesData->addResourceSharedBuffer(requestId,
    408             loader->frameLoader()->documentLoader()->mainResourceData(),
    409             loader->frame()->document()->inputEncoding());
     408        RefPtr<ResourceBuffer> buffer = loader->frameLoader()->documentLoader()->mainResourceData();
     409        m_resourcesData->addResourceSharedBuffer(requestId, buffer ? buffer->sharedBuffer() : nullptr, loader->frame()->document()->inputEncoding());
    410410    }
    411411
    … …  
    436436        Frame* frame = loader ? loader->frame() : nullptr;
    437437        if (frame && frame->loader().documentLoader() && frame->document()) {
    438             m_resourcesData->addResourceSharedBuffer(requestId,
    439                 frame->loader().documentLoader()->mainResourceData(),
    440                 frame->document()->inputEncoding());
     438            RefPtr<ResourceBuffer> buffer = frame->loader().documentLoader()->mainResourceData();
     439            m_resourcesData->addResourceSharedBuffer(requestId, buffer ? buffer->sharedBuffer() : nullptr, frame->document()->inputEncoding());
    441440        }
    442441    }

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

    r175406 r175491  
    5757#include "PolicyChecker.h"
    5858#include "ProgressTracker.h"
     59#include "ResourceBuffer.h"
    5960#include "ResourceHandle.h"
    6061#include "SchemeRegistry.h"
    … …  
    171172}
    172173
    173 PassRefPtr<SharedBuffer> DocumentLoader::mainResourceData() const
     174PassRefPtr<ResourceBuffer> DocumentLoader::mainResourceData() const
    174175{
    175176    if (m_substituteData.isValid())
    176         return m_substituteData.content()->copy();
     177        return ResourceBuffer::create(m_substituteData.content()->data(), m_substituteData.content()->size());
    177178    if (m_mainResource)
    178179        return m_mainResource->resourceBuffer();
    179     return nullptr;
     180    return 0;
    180181}
    181182
    … …  
    184185    if (m_frame && m_frame->loader().documentLoader() == this)
    185186        return m_frame->document();
    186     return nullptr;
     187    return 0;
    187188}
    188189
    … …  
    994995   
    995996    // Give the archive machinery a crack at this document. If the MIME type is not an archive type, it will return 0.
    996     m_archive = ArchiveFactory::create(m_response.url(), mainResourceData().get(), m_response.mimeType());
     997    RefPtr<ResourceBuffer> mainResourceBuffer = mainResourceData();
     998    m_archive = ArchiveFactory::create(m_response.url(), mainResourceBuffer ? mainResourceBuffer->sharedBuffer() : 0, m_response.mimeType());
    997999    if (!m_archive)
    9981000        return false;
    … …  
    10101012
    10111013#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
    1012 
    10131014void DocumentLoader::setArchive(PassRefPtr<Archive> archive)
    10141015{
    … …  
    10581059    return m_parsedArchiveData.get();
    10591060}
    1060 
    10611061#endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
    10621062
    … …  
    10641064{
    10651065    if (!m_archiveResourceCollection)
    1066         return nullptr;
     1066        return 0;
     1067       
    10671068    ArchiveResource* resource = m_archiveResourceCollection->archiveResourceForURL(url);
    1068     if (!resource || resource->shouldIgnoreWhenUnarchiving())
    1069         return nullptr;
    1070     return resource;
     1069
     1070    return resource && !resource->shouldIgnoreWhenUnarchiving() ? resource : 0;
    10711071}
    10721072
    10731073PassRefPtr<ArchiveResource> DocumentLoader::mainResource() const
    10741074{
    1075     RefPtr<SharedBuffer> data = mainResourceData();
     1075    const ResourceResponse& r = response();
     1076   
     1077    RefPtr<ResourceBuffer> mainResourceBuffer = mainResourceData();
     1078    RefPtr<SharedBuffer> data = mainResourceBuffer ? mainResourceBuffer->sharedBuffer() : 0;
    10761079    if (!data)
    10771080        data = SharedBuffer::create();
    10781081       
    1079     auto& response = this->response();
    1080     return ArchiveResource::create(data, response.url(), response.mimeType(), response.textEncodingName(), frame()->tree().uniqueName());
     1082    return ArchiveResource::create(data, r.url(), r.mimeType(), r.textEncodingName(), frame()->tree().uniqueName());
    10811083}
    10821084
    … …  
    10841086{
    10851087    if (!isCommitted())
    1086         return nullptr;
     1088        return 0;
    10871089   
    10881090    CachedResource* resource = m_cachedResourceLoader->cachedResource(url);
    … …  
    10911093
    10921094    if (resource->type() == CachedResource::MainResource)
    1093         return nullptr;
    1094 
    1095     auto* data = resource->resourceBuffer();
     1095        return 0;
     1096
     1097    ResourceBuffer* data = resource->resourceBuffer();
    10961098    if (!data)
    1097         return nullptr;
    1098 
    1099     return ArchiveResource::create(data, url, resource->response());
     1099        return 0;
     1100
     1101    return ArchiveResource::create(data->sharedBuffer(), url, resource->response());
    11001102}
    11011103
    … …  
    15101512    frameLoader()->setupForReplace();
    15111513    m_committed = false;
    1512     RefPtr<SharedBuffer> resourceData = mainResourceData();
     1514    RefPtr<ResourceBuffer> resourceData = mainResourceData();
    15131515    commitLoad(resourceData->data(), resourceData->size());
    15141516}

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

    r175406 r175491  
    6969    class FrameLoader;
    7070    class Page;
     71    class ResourceBuffer;
    7172    class ResourceLoader;
    7273    class SharedBuffer;
    … …  
    9394        WEBCORE_EXPORT FrameLoader* frameLoader() const;
    9495        WEBCORE_EXPORT ResourceLoader* mainResourceLoader() const;
    95         WEBCORE_EXPORT PassRefPtr<SharedBuffer> mainResourceData() const;
     96        WEBCORE_EXPORT PassRefPtr<ResourceBuffer> mainResourceData() const;
    9697       
    9798        DocumentWriter& writer() const { return m_writer; }

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

    r175406 r175491  
    2828
    2929#if ENABLE(VIDEO)
    30 
    3130#include "CachedRawResource.h"
    3231#include "CachedResourceLoader.h"
    … …  
    3433#include "CrossOriginAccessControl.h"
    3534#include "Document.h"
     35#include "ResourceBuffer.h"
    3636#include "SecurityOrigin.h"
    3737#include <wtf/NeverDestroyed.h>
    … …  
    113113void MediaResourceLoader::dataReceived(CachedResource* resource, const char* data, int dataLength)
    114114{
    115     ASSERT_UNUSED(resource, resource == m_resource);
     115    ASSERT(resource == m_resource);
    116116
    117117    RefPtr<MediaResourceLoader> protect(this);
    118118    m_client->dataReceived(data, dataLength);
     119
     120    if (SharedBuffer* buffer = resource->resourceBuffer() ? resource->resourceBuffer()->sharedBuffer() : nullptr)
     121        m_client->bufferReceived(buffer);
    119122}
    120123
    … …  
    127130        m_client->loadFailed(resource->resourceError());
    128131    else
    129         m_client->loadFinished();
     132        m_client->loadFinished(resource->resourceBuffer() ? resource->resourceBuffer()->sharedBuffer() : nullptr);
    130133    stop();
    131134}

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

    r175406 r175491  
    4343#include "PlatformStrategies.h"
    4444#include "ProgressTracker.h"
     45#include "ResourceBuffer.h"
    4546#include "ResourceError.h"
    4647#include "ResourceHandle.h"
    … …  
    222223
    223224    if (dataPayloadType == DataPayloadWholeResource) {
    224         m_resourceData = buffer ? buffer : SharedBuffer::create(data, length);
     225        m_resourceData = buffer ? ResourceBuffer::adoptSharedBuffer(buffer) : ResourceBuffer::create(data, length);
    225226        return;
    226227    }
    227228       
    228229    if (!m_resourceData)
    229         m_resourceData = buffer ? buffer : SharedBuffer::create(data, length);
     230        m_resourceData = buffer ? ResourceBuffer::adoptSharedBuffer(buffer) : ResourceBuffer::create(data, length);
    230231    else {
    231232        if (buffer)

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

    r175406 r175491  
    4848class FrameLoader;
    4949class URL;
     50class ResourceBuffer;
    5051
    5152#if USE(QUICK_LOOK)
    … …  
    8889    const ResourceResponse& response() const;
    8990
    90     SharedBuffer* resourceData() const { return m_resourceData.get(); }
     91    ResourceBuffer* resourceData() const { return m_resourceData.get(); }
    9192    void clearResourceData();
    9293   
    … …  
    204205    ResourceRequest m_request;
    205206    ResourceRequest m_originalRequest; // Before redirects.
    206     RefPtr<SharedBuffer> m_resourceData;
     207    RefPtr<ResourceBuffer> m_resourceData;
    207208   
    208209    unsigned long m_identifier;

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

    r175406 r175491  
    3939#include "Page.h"
    4040#include "PageActivityAssertionToken.h"
     41#include "ResourceBuffer.h"
    4142#include <wtf/Ref.h>
    4243#include <wtf/RefCountedLeakCounter.h>
    … …  
    233234    }
    234235
    235     auto* buffer = resourceData();
     236    RefPtr<ResourceBuffer> buffer = resourceData();
    236237    if (m_loadingMultipartContent && buffer && buffer->size()) {
    237238        // The resource data will change as the next part is loaded, so we need to make a copy.
    238         m_resource->finishLoading(&buffer->copy().get());
     239        RefPtr<ResourceBuffer> copiedData = ResourceBuffer::create(buffer->data(), buffer->size());
     240        m_resource->finishLoading(copiedData.get());
    239241        clearResourceData();
    240242        // Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.       
    … …  
    272274
    273275    if (!m_loadingMultipartContent) {
    274         if (auto* resourceData = this->resourceData())
    275             m_resource->addDataBuffer(*resourceData);
     276        if (ResourceBuffer* resourceData = this->resourceData())
     277            m_resource->addDataBuffer(resourceData);
    276278        else
    277279            m_resource->addData(buffer ? buffer->data() : data, buffer ? buffer->size() : length);

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

    r175406 r175491  
    3737#include "Document.h"
    3838#include "Logging.h"
     39#include "ResourceBuffer.h"
    3940#include "SecurityOrigin.h"
    40 #include "SharedBuffer.h"
    4141#include "VTTCue.h"
    4242#include "WebVTTParser.h"
    … …  
    8888        return;
    8989   
    90     auto* buffer = resource->resourceBuffer();
     90    ResourceBuffer* buffer = resource->resourceBuffer();
    9191    if (m_parseOffset == buffer->size())
    9292        return;

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp

    r175406 r175491  
    4242#include "ManifestParser.h"
    4343#include "Page.h"
     44#include "ResourceBuffer.h"
    4445#include "ResourceHandle.h"
    4546#include "SecurityOrigin.h"
    … …  
    254255                ASSERT(!resource->storageID());
    255256            }
    256         } else
    257             m_newestCache->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, loader->mainResourceData()));
     257        } else {
     258            RefPtr<ResourceBuffer> buffer = loader->mainResourceData();
     259            m_newestCache->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, buffer ? buffer->sharedBuffer() : 0));
     260        }
     261
    258262        break;
    259263    case Failure:
    … …  
    273277                ASSERT(!resource->storageID());
    274278            }
    275         } else
    276             m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, loader->mainResourceData()));
     279        } else {
     280            RefPtr<ResourceBuffer> buffer = loader->mainResourceData();
     281            m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, buffer ? buffer->sharedBuffer() : 0));
     282        }
    277283        // The "cached" event will be posted to all associated documents once update is complete.
    278284        break;

  • trunk/Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp

    r175406 r175491  
    4747#include "Page.h"
    4848#include "Range.h"
     49#include "ResourceBuffer.h"
    4950#include "Settings.h"
    5051#include "markup.h"
    … …  
    550551                CachedResource* cachedResource = memoryCache()->resourceForRequest(request, frame->page()->sessionID());
    551552                if (cachedResource) {
    552                     if (RefPtr<ArchiveResource> resource = ArchiveResource::create(cachedResource->resourceBuffer(), subresourceURL, cachedResource->response())) {
     553                    ResourceBuffer* data = cachedResource->resourceBuffer();
     554
     555                    if (RefPtr<ArchiveResource> resource = ArchiveResource::create(data ? data->sharedBuffer() : 0, subresourceURL, cachedResource->response())) {
    553556                        subresources.append(WTF::move(resource));
    554557                        continue;

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

    r175406 r175491  
    3434#include "HTTPParsers.h"
    3535#include "MemoryCache.h"
    36 #include "SharedBuffer.h"
     36#include "ResourceBuffer.h"
    3737#include "StyleSheetContents.h"
    3838#include "TextResourceDecoder.h"
    … …  
    9191}
    9292
    93 void CachedCSSStyleSheet::finishLoading(SharedBuffer* data)
     93void CachedCSSStyleSheet::finishLoading(ResourceBuffer* data)
    9494{
    9595    m_data = data;
    96     setEncodedSize(data ? data->size() : 0);
     96    setEncodedSize(m_data.get() ? m_data->size() : 0);
    9797    // Decode the data to find out the encoding and keep the sheet text around during checkNotify()
    98     if (data)
    99         m_decodedSheetText = m_decoder->decodeAndFlush(data->data(), data->size());
     98    if (m_data)
     99        m_decodedSheetText = m_decoder->decodeAndFlush(m_data->data(), m_data->size());
    100100    setLoading(false);
    101101    checkNotify();

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

    r175406 r175491  
    5555        virtual void setEncoding(const String&) override;
    5656        virtual String encoding() const override;
    57         virtual void finishLoading(SharedBuffer*) override;
     57        virtual void finishLoading(ResourceBuffer*) override;
    5858        virtual void destroyDecodedData() override;
    5959

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

    r175406 r175491  
    3434#include "FontPlatformData.h"
    3535#include "MemoryCache.h"
     36#include "ResourceBuffer.h"
    3637#include "SharedBuffer.h"
    3738#include "TextResourceDecoder.h"
    … …  
    7677}
    7778
    78 void CachedFont::finishLoading(SharedBuffer* data)
     79void CachedFont::finishLoading(ResourceBuffer* data)
    7980{
    8081    m_data = data;
    … …  
    9596{
    9697    if (!m_fontData && !errorOccurred() && !isLoading() && m_data) {
    97         RefPtr<SharedBuffer> buffer = m_data;
     98        SharedBuffer* buffer = m_data.get()->sharedBuffer();
     99        ASSERT(buffer);
     100
    98101        bool fontIsWOFF = false;
     102#if (!PLATFORM(MAC) || __MAC_OS_X_VERSION_MIN_REQUIRED <= 1090) && (!PLATFORM(IOS) || __IPHONE_OS_VERSION_MIN_REQUIRED < 80000)
     103        RefPtr<SharedBuffer> sfntBuffer;
    99104
    100 #if (!PLATFORM(MAC) || __MAC_OS_X_VERSION_MIN_REQUIRED <= 1090) && (!PLATFORM(IOS) || __IPHONE_OS_VERSION_MIN_REQUIRED < 80000)
    101         if (isWOFF(buffer.get())) {
    102             Vector<char> convertedFont;
    103             if (!convertWOFFToSfnt(buffer.get(), convertedFont))
     105        fontIsWOFF = isWOFF(buffer);
     106        if (fontIsWOFF) {
     107            Vector<char> sfnt;
     108            if (convertWOFFToSfnt(buffer, sfnt)) {
     109                sfntBuffer = SharedBuffer::adoptVector(sfnt);
     110                buffer = sfntBuffer.get();
     111            } else
    104112                buffer = nullptr;
    105             else {
    106                 buffer = SharedBuffer::adoptVector(convertedFont);
    107                 fontIsWOFF = true;
    108             }
    109113        }
    110114#endif
    111115
    112116        m_fontData = buffer ? createFontCustomPlatformData(*buffer) : nullptr;
    113         m_hasCreatedFontDataWrappingResource = m_fontData && !fontIsWOFF;
    114         if (!m_fontData)
     117        if (m_fontData)
     118            m_hasCreatedFontDataWrappingResource = !fontIsWOFF;
     119        else
    115120            setStatus(DecodeError);
    116121    }
    117 
    118122    return m_fontData.get();
    119123}

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

    r175406 r175491  
    6464
    6565    virtual void didAddClient(CachedResourceClient*) override;
    66     virtual void finishLoading(SharedBuffer*) override;
     66    virtual void finishLoading(ResourceBuffer*) override;
    6767
    6868    virtual void allClientsRemoved() override;

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

    r175406 r175491  
    3838#include "Page.h"
    3939#include "RenderElement.h"
     40#include "ResourceBuffer.h"
    4041#include "SVGImage.h"
    4142#include "SecurityOrigin.h"
    … …  
    116117}
    117118
    118 void CachedImage::didAddClient(CachedResourceClient* client)
     119void CachedImage::didAddClient(CachedResourceClient* c)
    119120{
    120121    if (m_data && !m_image && !errorOccurred()) {
    121122        createImage();
    122         m_image->setData(m_data, true);
     123        m_image->setData(m_data->sharedBuffer(), true);
    123124    }
    124125   
    125     ASSERT(client->resourceClientType() == CachedImageClient::expectedType());
     126    ASSERT(c->resourceClientType() == CachedImageClient::expectedType());
    126127    if (m_image && !m_image->isNull())
    127         static_cast<CachedImageClient*>(client)->imageChanged(this);
    128 
    129     CachedResource::didAddClient(client);
    130 }
    131 
    132 void CachedImage::didRemoveClient(CachedResourceClient* client)
    133 {
    134     ASSERT(client);
    135     ASSERT(client->resourceClientType() == CachedImageClient::expectedType());
    136 
    137     m_pendingContainerSizeRequests.remove(static_cast<CachedImageClient*>(client));
     128        static_cast<CachedImageClient*>(c)->imageChanged(this);
     129
     130    CachedResource::didAddClient(c);
     131}
     132
     133void CachedImage::didRemoveClient(CachedResourceClient* c)
     134{
     135    ASSERT(c);
     136    ASSERT(c->resourceClientType() == CachedImageClient::expectedType());
     137
     138    m_pendingContainerSizeRequests.remove(static_cast<CachedImageClient*>(c));
    138139
    139140    if (m_svgImageCache)
    140         m_svgImageCache->removeClientFromCache(static_cast<CachedImageClient*>(client));
    141 
    142     CachedResource::didRemoveClient(client);
     141        m_svgImageCache->removeClientFromCache(static_cast<CachedImageClient*>(c));
     142
     143    CachedResource::didRemoveClient(c);
    143144}
    144145
    … …  
    365366}
    366367
    367 void CachedImage::addIncrementalDataBuffer(SharedBuffer& data)
    368 {
    369     m_data = &data;
     368void CachedImage::addIncrementalDataBuffer(ResourceBuffer* data)
     369{
     370    m_data = data;
     371    if (!data)
     372        return;
    370373
    371374    createImage();
    … …  
    374377    // It will not do anything now, but will delay decoding until
    375378    // queried for info (like size or specific image frames).
    376     bool sizeAvailable = m_image->setData(&data, false);
     379    bool sizeAvailable = m_image->setData(m_data->sharedBuffer(), false);
    377380    if (!sizeAvailable)
    378381        return;
    … …  
    396399}
    397400
    398 void CachedImage::addDataBuffer(SharedBuffer& data)
    399 {
    400     ASSERT(dataBufferingPolicy() == BufferData);
     401void CachedImage::addDataBuffer(ResourceBuffer* data)
     402{
     403    ASSERT(m_options.dataBufferingPolicy() == BufferData);
    401404    addIncrementalDataBuffer(data);
    402     CachedResource::addDataBuffer(data);
    403405}
    404406
    405407void CachedImage::addData(const char* data, unsigned length)
    406408{
    407     ASSERT(dataBufferingPolicy() == DoNotBufferData);
    408     addIncrementalDataBuffer(*SharedBuffer::create(data, length));
    409     CachedResource::addData(data, length);
    410 }
    411 
    412 void CachedImage::finishLoading(SharedBuffer* data)
     409    ASSERT(m_options.dataBufferingPolicy() == DoNotBufferData);
     410    addIncrementalDataBuffer(ResourceBuffer::create(data, length).get());
     411}
     412
     413void CachedImage::finishLoading(ResourceBuffer* data)
    413414{
    414415    m_data = data;
    … …  
    417418
    418419    if (m_image)
    419         m_image->setData(data, true);
     420        m_image->setData(m_data->sharedBuffer(), true);
    420421
    421422    if (!m_image || m_image->isNull()) {

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

    r175406 r175491  
    7272    bool imageHasRelativeHeight() const;
    7373
    74     virtual void addDataBuffer(SharedBuffer&) override;
    75     virtual void finishLoading(SharedBuffer*) override;
     74    virtual void addDataBuffer(ResourceBuffer*) override;
     75    virtual void finishLoading(ResourceBuffer*) override;
    7676
    7777    enum SizeType {
    … …  
    9595    void clearImage();
    9696    // If not null, changeRect is the changed part of the image.
    97     void notifyObservers(const IntRect* changeRect = nullptr);
     97    void notifyObservers(const IntRect* changeRect = 0);
    9898    void checkShouldPaintBrokenImage();
    9999
    … …  
    123123    virtual void changedInRect(const Image*, const IntRect&) override;
    124124
    125     void addIncrementalDataBuffer(SharedBuffer&);
     125    void addIncrementalDataBuffer(ResourceBuffer*);
    126126
    127127    typedef std::pair<LayoutSize, float> SizeAndZoom;
    … …  
    131131    RefPtr<Image> m_image;
    132132    std::unique_ptr<SVGImageCache> m_svgImageCache;
    133     unsigned m_isManuallyCached : 1;
    134     unsigned m_shouldPaintBrokenImage : 1;
     133    unsigned char m_isManuallyCached : 1;
     134    unsigned char m_shouldPaintBrokenImage : 1;
    135135};
    136136

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

    r175423 r175491  
    3131#include "CachedResourceLoader.h"
    3232#include "HTTPHeaderNames.h"
    33 #include "SharedBuffer.h"
     33#include "ResourceBuffer.h"
    3434#include "SubresourceLoader.h"
    3535#include <wtf/PassRefPtr.h>
    … …  
    4747}
    4848
    49 const char* CachedRawResource::calculateIncrementalDataChunk(SharedBuffer* data, unsigned& incrementalDataLength)
     49const char* CachedRawResource::calculateIncrementalDataChunk(ResourceBuffer* data, unsigned& incrementalDataLength)
    5050{
    5151    incrementalDataLength = 0;
    … …  
    5959}
    6060
    61 void CachedRawResource::addDataBuffer(SharedBuffer& data)
    62 {
    63     CachedResourceHandle<CachedRawResource> protect(this);
    64     ASSERT(dataBufferingPolicy() == BufferData);
    65     m_data = &data;
     61void CachedRawResource::addDataBuffer(ResourceBuffer* data)
     62{
     63    CachedResourceHandle<CachedRawResource> protect(this);
     64    ASSERT(m_options.dataBufferingPolicy() == BufferData);
     65    m_data = data;
    6666
    6767    unsigned incrementalDataLength;
    68     const char* incrementalData = calculateIncrementalDataChunk(&data, incrementalDataLength);
    69     setEncodedSize(data.size());
     68    const char* incrementalData = calculateIncrementalDataChunk(data, incrementalDataLength);
     69    if (data)
     70        setEncodedSize(data->size());
    7071    notifyClientsDataWasReceived(incrementalData, incrementalDataLength);
    71     if (dataBufferingPolicy() == DoNotBufferData) {
     72    if (m_options.dataBufferingPolicy() == DoNotBufferData) {
    7273        if (m_loader)
    7374            m_loader->setDataBufferingPolicy(DoNotBufferData);
    7475        clear();
    75         return;
    76     }
    77 
    78     CachedResource::addDataBuffer(data);
     76    }
    7977}
    8078
    8179void CachedRawResource::addData(const char* data, unsigned length)
    8280{
    83     ASSERT(dataBufferingPolicy() == DoNotBufferData);
     81    ASSERT(m_options.dataBufferingPolicy() == DoNotBufferData);
    8482    notifyClientsDataWasReceived(data, length);
    85     CachedResource::addData(data, length);
    86 }
    87 
    88 void CachedRawResource::finishLoading(SharedBuffer* data)
    89 {
    90     CachedResourceHandle<CachedRawResource> protect(this);
    91     DataBufferingPolicy dataBufferingPolicy = this->dataBufferingPolicy();
     83}
     84
     85void CachedRawResource::finishLoading(ResourceBuffer* data)
     86{
     87    CachedResourceHandle<CachedRawResource> protect(this);
     88    DataBufferingPolicy dataBufferingPolicy = m_options.dataBufferingPolicy();
    9289    if (dataBufferingPolicy == BufferData) {
    9390        m_data = data;
    … …  
    103100
    104101    CachedResource::finishLoading(data);
    105     if (dataBufferingPolicy == BufferData && this->dataBufferingPolicy() == DoNotBufferData) {
     102    if (dataBufferingPolicy == BufferData && m_options.dataBufferingPolicy() == DoNotBufferData) {
    106103        if (m_loader)
    107104            m_loader->setDataBufferingPolicy(DoNotBufferData);
    … …  
    226223bool CachedRawResource::canReuse(const ResourceRequest& newRequest) const
    227224{
    228     if (dataBufferingPolicy() == DoNotBufferData)
     225    if (m_options.dataBufferingPolicy() == DoNotBufferData)
    229226        return false;
    230227

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

    r175406 r175491  
    4949private:
    5050    virtual void didAddClient(CachedResourceClient*) override;
    51     virtual void addDataBuffer(SharedBuffer&) override;
     51    virtual void addDataBuffer(ResourceBuffer*) override;
    5252    virtual void addData(const char* data, unsigned length) override;
    53     virtual void finishLoading(SharedBuffer*) override;
     53    virtual void finishLoading(ResourceBuffer*) override;
    5454
    5555    virtual bool shouldIgnoreHTTPStatusCodeErrors() const override { return true; }
    … …  
    6565    virtual bool canReuse(const ResourceRequest&) const override;
    6666
    67     const char* calculateIncrementalDataChunk(SharedBuffer*, unsigned& incrementalDataLength);
     67    const char* calculateIncrementalDataChunk(ResourceBuffer*, unsigned& incrementalDataLength);
    6868    void notifyClientsDataWasReceived(const char* data, unsigned length);
    6969

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

    r175406 r175491  
    4141#include "MemoryCache.h"
    4242#include "PlatformStrategies.h"
     43#include "ResourceBuffer.h"
    4344#include "ResourceHandle.h"
    4445#include "ResourceLoadScheduler.h"
    … …  
    108109CachedResource::CachedResource(const ResourceRequest& request, Type type, SessionID sessionID)
    109110    : m_resourceRequest(request)
    110     , m_decodedDataDeletionTimer(this, &CachedResource::decodedDataDeletionTimerFired, deadDecodedDataDeletionIntervalForResourceType(type))
    111111    , m_sessionID(sessionID)
    112112    , m_loadPriority(defaultPriorityForResourceType(type))
    113113    , m_responseTimestamp(currentTime())
     114    , m_decodedDataDeletionTimer(this, &CachedResource::decodedDataDeletionTimerFired, deadDecodedDataDeletionIntervalForResourceType(type))
    114115    , m_lastDecodedAccessTime(0)
    115116    , m_loadFinishTime(0)
    … …  
    286287        return;
    287288
    288     CachedResourceClientWalker<CachedResourceClient> walker(m_clients);
    289     while (CachedResourceClient* client = walker.next())
    290         client->notifyFinished(this);
    291 }
    292 
    293 void CachedResource::addDataBuffer(SharedBuffer&)
    294 {
    295     ASSERT(dataBufferingPolicy() == BufferData);
     289    CachedResourceClientWalker<CachedResourceClient> w(m_clients);
     290    while (CachedResourceClient* c = w.next())
     291        c->notifyFinished(this);
     292}
     293
     294void CachedResource::addDataBuffer(ResourceBuffer*)
     295{
     296    ASSERT(m_options.dataBufferingPolicy() == BufferData);
    296297}
    297298
    298299void CachedResource::addData(const char*, unsigned)
    299300{
    300     ASSERT(dataBufferingPolicy() == DoNotBufferData);
    301 }
    302 
    303 void CachedResource::finishLoading(SharedBuffer*)
     301    ASSERT(m_options.dataBufferingPolicy() == DoNotBufferData);
     302}
     303
     304void CachedResource::finishLoading(ResourceBuffer*)
    304305{
    305306    setLoading(false);
    … …  
    391392}
    392393
    393 void CachedResource::didAddClient(CachedResourceClient* client)
     394void CachedResource::didAddClient(CachedResourceClient* c)
    394395{
    395396    if (m_decodedDataDeletionTimer.isActive())
    396397        m_decodedDataDeletionTimer.stop();
    397398
    398     if (m_clientsAwaitingCallback.remove(client))
    399         m_clients.add(client);
     399    if (m_clientsAwaitingCallback.contains(c)) {
     400        m_clients.add(c);
     401        m_clientsAwaitingCallback.remove(c);
     402    }
    400403    if (!isLoading() && !stillNeedsLoad())
    401         client->notifyFinished(this);
     404        c->notifyFinished(this);
    402405}
    403406
    … …  
    421424        // we schedule the callbacks and ensure we never finish synchronously.
    422425        ASSERT(!m_clientsAwaitingCallback.contains(client));
    423         m_clientsAwaitingCallback.add(client, std::make_unique<Callback>(*this, *client));
     426        m_clientsAwaitingCallback.add(client, CachedResourceCallback::schedule(this, client));
    424427        return false;
    425428    }
    … …  
    729732}
    730733
    731 inline CachedResource::Callback::Callback(CachedResource& resource, CachedResourceClient& client)
     734CachedResource::CachedResourceCallback::CachedResourceCallback(CachedResource* resource, CachedResourceClient* client)
    732735    : m_resource(resource)
    733736    , m_client(client)
    734     , m_timer(this, &Callback::timerFired)
    735 {
    736     m_timer.startOneShot(0);
    737 }
    738 
    739 inline void CachedResource::Callback::cancel()
    740 {
    741     if (m_timer.isActive())
    742         m_timer.stop();
    743 }
    744 
    745 void CachedResource::Callback::timerFired(Timer<Callback>&)
    746 {
    747     m_resource.didAddClient(&m_client);
     737    , m_callbackTimer(this, &CachedResourceCallback::timerFired)
     738{
     739    m_callbackTimer.startOneShot(0);
     740}
     741
     742void CachedResource::CachedResourceCallback::cancel()
     743{
     744    if (m_callbackTimer.isActive())
     745        m_callbackTimer.stop();
     746}
     747
     748void CachedResource::CachedResourceCallback::timerFired(Timer<CachedResourceCallback>&)
     749{
     750    m_resource->didAddClient(m_client);
    748751}
    749752
    750753#if USE(FOUNDATION)
    751 
    752 void CachedResource::tryReplaceEncodedData(SharedBuffer& newBuffer)
     754void CachedResource::tryReplaceEncodedData(PassRefPtr<SharedBuffer> newBuffer)
    753755{
    754756    if (!m_data)
    … …  
    761763    // same resource or if we made a second request with the same URL which gave us a different
    762764    // resource. We have seen this happen for cached POST resources.
    763     if (m_data->size() != newBuffer.size() || memcmp(m_data->data(), newBuffer.data(), m_data->size()))
    764         return;
    765 
    766     m_data->tryReplaceContentsWithPlatformBuffer(newBuffer);
    767 }
    768 
    769 #endif
    770 
    771 }
     765    if (m_data->size() != newBuffer->size() || memcmp(m_data->data(), newBuffer->data(), m_data->size()))
     766        return;
     767
     768    m_data->tryReplaceSharedBufferContents(newBuffer.get());
     769}
     770#endif
     771
     772}

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

    r175406 r175491  
    4848class CachedResourceLoader;
    4949class InspectorResource;
     50class ResourceBuffer;
    5051class SecurityOrigin;
    5152class SharedBuffer;
    … …  
    9697    virtual void setEncoding(const String&) { }
    9798    virtual String encoding() const { return String(); }
    98     virtual void addDataBuffer(SharedBuffer&);
     99    virtual void addDataBuffer(ResourceBuffer*);
    99100    virtual void addData(const char* data, unsigned length);
    100     virtual void finishLoading(SharedBuffer*);
     101    virtual void finishLoading(ResourceBuffer*);
    101102    virtual void error(CachedResource::Status);
    102103
    … …  
    187188    void clearLoader();
    188189
    189     SharedBuffer* resourceBuffer() const { return m_data.get(); }
     190    ResourceBuffer* resourceBuffer() const { return m_data.get(); }
    190191
    191192    virtual void willSendRequest(ResourceRequest&, const ResourceResponse&);
    … …  
    245246
    246247#if USE(FOUNDATION)
    247     WEBCORE_EXPORT void tryReplaceEncodedData(SharedBuffer&);
     248    WEBCORE_EXPORT void tryReplaceEncodedData(PassRefPtr<SharedBuffer>);
    248249#endif
    249250
    250251#if USE(SOUP)
    251     virtual char* getOrCreateReadBuffer(size_t /* requestedSize */, size_t& /* actualSize */) { return nullptr; }
     252    virtual char* getOrCreateReadBuffer(size_t /* requestedSize */, size_t& /* actualSize */) { return 0; }
    252253#endif
    253254
    254255protected:
     256    virtual void checkNotify();
     257
    255258    void setEncodedSize(unsigned);
    256259    void setDecodedSize(unsigned);
    257260    void didAccessDecodedData(double timeStamp);
    258261
    259     // FIXME: Make the rest of these data members private and use functions in derived classes instead.
    260262    HashCountedSet<CachedResourceClient*> m_clients;
     263
     264    class CachedResourceCallback {
     265    public:
     266        CachedResourceCallback(CachedResource*, CachedResourceClient*);
     267
     268        static std::unique_ptr<CachedResourceCallback> schedule(CachedResource* resource, CachedResourceClient* client) { return std::make_unique<CachedResourceCallback>(resource, client); }
     269        void cancel();
     270    private:
     271        void timerFired(Timer<CachedResourceCallback>&);
     272
     273        CachedResource* m_resource;
     274        CachedResourceClient* m_client;
     275        Timer<CachedResourceCallback> m_callbackTimer;
     276    };
     277    HashMap<CachedResourceClient*, std::unique_ptr<CachedResourceCallback>> m_clientsAwaitingCallback;
     278
    261279    ResourceRequest m_resourceRequest;
     280    SessionID m_sessionID;
     281    String m_accept;
    262282    RefPtr<SubresourceLoader> m_loader;
    263283    ResourceLoaderOptions m_options;
     284    ResourceLoadPriority m_loadPriority;
     285
    264286    ResourceResponse m_response;
    265     RefPtr<SharedBuffer> m_data;
     287    double m_responseTimestamp;
     288
     289    RefPtr<ResourceBuffer> m_data;
    266290    DeferrableOneShotTimer m_decodedDataDeletionTimer;
    267291
    268292private:
    269     class Callback;
    270 
    271293    bool addClientToSet(CachedResourceClient*);
    272294
    273295    void decodedDataDeletionTimerFired();
    274296
    275     virtual void checkNotify();
    276297    virtual bool mayTryReplaceEncodedData() const { return false; }
    277298
    … …  
    280301    void addAdditionalRequestHeaders(CachedResourceLoader*);
    281302    void failBeforeStarting();
    282 
    283     HashMap<CachedResourceClient*, std::unique_ptr<Callback>> m_clientsAwaitingCallback;
    284     SessionID m_sessionID;
    285     String m_accept;
    286     ResourceLoadPriority m_loadPriority;
    287     double m_responseTimestamp;
    288303
    289304    String m_fragmentIdentifierForRequest;
    … …  
    324339    CachedResource* m_prevInLiveResourcesList;
    325340
    326     CachedResourceLoader* m_owningCachedResourceLoader; // only non-null for resources that are not in the cache
     341    CachedResourceLoader* m_owningCachedResourceLoader; // only non-0 for resources that are not in the cache
    327342   
    328343    // If this field is non-null we are using the resource as a proxy for checking whether an existing resource is still up to date
    … …  
    341356};
    342357
    343 class CachedResource::Callback {
    344 public:
    345     Callback(CachedResource&, CachedResourceClient&);
    346 
    347     void cancel();
    348 
    349 private:
    350     void timerFired(Timer<Callback>&);
    351 
    352     CachedResource& m_resource;
    353     CachedResourceClient& m_client;
    354     Timer<Callback> m_timer;
    355 };
    356 
    357358} // namespace WebCore
    358359

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

    r175406 r175491  
    2626#define CachedResourceClient_h
    2727
     28#include <wtf/FastMalloc.h>
     29
    2830namespace WebCore {
    29 
    3031class CachedResource;
    3132
    … …  
    4445    virtual void notifyFinished(CachedResource*) { }
    4546    virtual void deprecatedDidReceiveCachedResource(CachedResource*) { }
    46 
     47   
    4748    static CachedResourceClientType expectedType() { return BaseResourceType; }
    4849    virtual CachedResourceClientType resourceClientType() const { return expectedType(); }
    … …  
    5152    CachedResourceClient() { }
    5253};
    53 
    5454}
    5555

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

    r175406 r175491  
    2424#include "CachedSVGDocument.h"
    2525
    26 #include "SharedBuffer.h"
     26#include "CachedResourceClient.h"
     27#include "CachedResourceHandle.h"
     28#include "ResourceBuffer.h"
     29#include <wtf/text/StringBuilder.h>
    2730
    2831namespace WebCore {
    … …  
    4952}
    5053
    51 void CachedSVGDocument::finishLoading(SharedBuffer* data)
     54void CachedSVGDocument::finishLoading(ResourceBuffer* data)
    5255{
    5356    if (data) {

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

    r175406 r175491  
    3838    SVGDocument* document() const { return m_document.get(); }
    3939
     40protected:
     41    RefPtr<SVGDocument> m_document;
     42    RefPtr<TextResourceDecoder> m_decoder;
     43
    4044private:
    4145    virtual bool mayTryReplaceEncodedData() const override { return true; }
    4246    virtual void setEncoding(const String&) override;
    4347    virtual String encoding() const override;
    44     virtual void finishLoading(SharedBuffer*) override;
    45 
    46     RefPtr<SVGDocument> m_document;
    47     RefPtr<TextResourceDecoder> m_decoder;
     48    virtual void finishLoading(ResourceBuffer*) override;
    4849};
    4950

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

    r175406 r175491  
    3434#include "MIMETypeRegistry.h"
    3535#include "MemoryCache.h"
     36#include "ResourceBuffer.h"
    3637#include "RuntimeApplicationChecks.h"
    37 #include "SharedBuffer.h"
    3838#include "TextResourceDecoder.h"
    3939#include <wtf/Vector.h>
    … …  
    7777    }
    7878    m_decodedDataDeletionTimer.restart();
     79   
    7980    return m_script;
    8081}
    8182
    82 void CachedScript::finishLoading(SharedBuffer* data)
     83void CachedScript::finishLoading(ResourceBuffer* data)
    8384{
    8485    m_data = data;
    85     setEncodedSize(data ? data->size() : 0);
     86    setEncodedSize(m_data.get() ? m_data->size() : 0);
    8687    CachedResource::finishLoading(data);
    8788}

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

    r175406 r175491  
    3131namespace WebCore {
    3232
    33 class TextResourceDecoder;
     33    class CachedResourceLoader;
     34    class TextResourceDecoder;
    3435
    35 class CachedScript final : public CachedResource {
    36 public:
    37     CachedScript(const ResourceRequest&, const String& charset, SessionID);
    38     virtual ~CachedScript();
     36    class CachedScript final : public CachedResource {
     37    public:
     38        CachedScript(const ResourceRequest&, const String& charset, SessionID);
     39        virtual ~CachedScript();
    3940
    40     const String& script();
     41        const String& script();
    4142
    42     String mimeType() const;
     43        String mimeType() const;
    4344
    4445#if ENABLE(NOSNIFF)
    45     bool mimeTypeAllowedByNosniff() const;
     46        bool mimeTypeAllowedByNosniff() const;
    4647#endif
    4748
    48 private:
    49     virtual bool mayTryReplaceEncodedData() const override { return true; }
     49    private:
     50        virtual bool mayTryReplaceEncodedData() const override { return true; }
    5051
    51     virtual bool shouldIgnoreHTTPStatusCodeErrors() const override;
     52        virtual bool shouldIgnoreHTTPStatusCodeErrors() const override;
    5253
    53     virtual void setEncoding(const String&) override;
    54     virtual String encoding() const override;
    55     virtual void finishLoading(SharedBuffer*) override;
     54        virtual void setEncoding(const String&) override;
     55        virtual String encoding() const override;
     56        virtual void finishLoading(ResourceBuffer*) override;
    5657
    57     virtual void destroyDecodedData() override;
     58        virtual void destroyDecodedData() override;
    5859
    59     String m_script;
    60     RefPtr<TextResourceDecoder> m_decoder;
    61 };
     60        String m_script;
     61        RefPtr<TextResourceDecoder> m_decoder;
     62    };
    6263
    6364} // namespace WebCore

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

    r175406 r175491  
    3333#include "CachedResourceClientWalker.h"
    3434#include "CachedResourceLoader.h"
     35#include "ResourceBuffer.h"
    3536#include "SharedBuffer.h"
    3637#include "TextResourceDecoder.h"
    … …  
    4445}
    4546
    46 void CachedTextTrack::updateData(SharedBuffer* data)
     47CachedTextTrack::~CachedTextTrack()
    4748{
    48     ASSERT(dataBufferingPolicy() == BufferData);
     49}
     50
     51void CachedTextTrack::addDataBuffer(ResourceBuffer* data)
     52{
     53    ASSERT(m_options.dataBufferingPolicy() == BufferData);
    4954    m_data = data;
    50     setEncodedSize(data ? data->size() : 0);
     55    setEncodedSize(m_data.get() ? m_data->size() : 0);
    5156
    5257    CachedResourceClientWalker<CachedResourceClient> walker(m_clients);
    53     while (CachedResourceClient* client = walker.next())
     58    while (CachedResourceClient *client = walker.next())
    5459        client->deprecatedDidReceiveCachedResource(this);
    5560}
    5661
    57 void CachedTextTrack::addDataBuffer(SharedBuffer& data)
     62void CachedTextTrack::finishLoading(ResourceBuffer* data)
    5863{
    59     updateData(&data);
    60     CachedResource::addDataBuffer(data);
    61 }
    62 
    63 void CachedTextTrack::finishLoading(SharedBuffer* data)
    64 {
    65     updateData(data);
     64    addDataBuffer(data);
    6665    CachedResource::finishLoading(data);
    6766}

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

    r175406 r175491  
    3737public:
    3838    CachedTextTrack(const ResourceRequest&, SessionID);
     39    virtual ~CachedTextTrack();
    3940
    4041private:
    4142    virtual bool mayTryReplaceEncodedData() const override { return true; }
    42     virtual void addDataBuffer(SharedBuffer&) override;
    43     virtual void finishLoading(SharedBuffer*) override;
    44 
    45     void updateData(SharedBuffer*);
     43    virtual void addDataBuffer(ResourceBuffer*) override;
     44    virtual void finishLoading(ResourceBuffer*) override;
    4645};
    4746

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

    r175406 r175491  
    3030#include "CachedResourceClientWalker.h"
    3131#include "CachedStyleSheetClient.h"
    32 #include "SharedBuffer.h"
     32#include "ResourceBuffer.h"
    3333#include "TextResourceDecoder.h"
    3434#include <wtf/Vector.h>
    … …  
    4545    // FIXME: This should accept more general xml formats */*+xml, image/svg+xml for example.
    4646    setAccept("text/xml, application/xml, application/xhtml+xml, text/xsl, application/rss+xml, application/atom+xml");
    47 }
    48 
    49 CachedXSLStyleSheet::~CachedXSLStyleSheet()
    50 {
    5147}
    5248
    … …  
    6864}
    6965
    70 void CachedXSLStyleSheet::finishLoading(SharedBuffer* data)
     66void CachedXSLStyleSheet::finishLoading(ResourceBuffer* data)
    7167{
    7268    m_data = data;
    73     setEncodedSize(data ? data->size() : 0);
    74     if (data)
    75         m_sheet = m_decoder->decodeAndFlush(data->data(), encodedSize());
     69    setEncodedSize(m_data.get() ? m_data->size() : 0);
     70    if (m_data.get())
     71        m_sheet = m_decoder->decodeAndFlush(m_data->data(), encodedSize());
    7672    setLoading(false);
    7773    checkNotify();

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

    r175406 r175491  
    3030
    3131#include "CachedResource.h"
     32#include <wtf/Vector.h>
    3233
    3334namespace WebCore {
    3435
    35 class TextResourceDecoder;
     36    class CachedResourceLoader;
     37    class TextResourceDecoder;
    3638
    37 class CachedXSLStyleSheet final : public CachedResource {
    38 public:
    39     CachedXSLStyleSheet(const ResourceRequest&, SessionID);
    40     virtual ~CachedXSLStyleSheet();
     39    class CachedXSLStyleSheet final : public CachedResource {
     40    public:
     41        CachedXSLStyleSheet(const ResourceRequest&, SessionID);
    4142
    42     const String& sheet() const { return m_sheet; }
     43        const String& sheet() const { return m_sheet; }
    4344
    44 private:
    45     virtual void checkNotify() override;
    46     virtual bool mayTryReplaceEncodedData() const override { return true; }
    47     virtual void didAddClient(CachedResourceClient*) override;
    48     virtual void setEncoding(const String&) override;
    49     virtual String encoding() const override;
    50     virtual void finishLoading(SharedBuffer*) override;
     45    protected:
     46        virtual void checkNotify() override;
    5147
    52     String m_sheet;
    53     RefPtr<TextResourceDecoder> m_decoder;
    54 };
     48        String m_sheet;
     49        RefPtr<TextResourceDecoder> m_decoder;
     50
     51    private:
     52        virtual bool mayTryReplaceEncodedData() const override { return true; }
     53
     54        virtual void didAddClient(CachedResourceClient*) override;
     55
     56        virtual void setEncoding(const String&) override;
     57        virtual String encoding() const override;
     58        virtual void finishLoading(ResourceBuffer*) override;
     59    };
    5560
    5661} // namespace WebCore

  • trunk/Source/WebCore/loader/cf/SubresourceLoaderCF.cpp

    r175406 r175491  
    5252            if (!m_resource)
    5353                return;
    54             if (auto* resourceData = this->resourceData())
    55                 m_resource->addDataBuffer(*resourceData);
     54            if (ResourceBuffer* resourceData = this->resourceData())
     55                m_resource->addDataBuffer(resourceData);
    5656            else {
    5757                CFDataRef cfData = reinterpret_cast<CFDataRef>(CFArrayGetValueAtIndex(dataArray, i));

  • trunk/Source/WebCore/loader/cocoa/DiskCacheMonitorCocoa.h

    r175406 r175491  
    4646    WEBCORE_EXPORT DiskCacheMonitor(const ResourceRequest&, SessionID, CFCachedURLResponseRef);
    4747
    48     virtual void resourceBecameFileBacked(SharedBuffer&);
     48    virtual void resourceBecameFileBacked(PassRefPtr<SharedBuffer>);
    4949
    5050    const ResourceRequest& resourceRequest() const { return m_resourceRequest; }

  • trunk/Source/WebCore/loader/cocoa/DiskCacheMonitorCocoa.mm

    r175406 r175491  
    104104            return;
    105105
    106         monitor->resourceBecameFileBacked(*fileBackedBuffer);
     106        monitor->resourceBecameFileBacked(fileBackedBuffer);
    107107    };
    108108
    … …  
    122122}
    123123
    124 void DiskCacheMonitor::resourceBecameFileBacked(SharedBuffer& fileBackedBuffer)
     124void DiskCacheMonitor::resourceBecameFileBacked(PassRefPtr<SharedBuffer> fileBackedBuffer)
    125125{
    126126    CachedResource* resource = memoryCache()->resourceForRequest(m_resourceRequest, m_sessionID);

  • trunk/Source/WebCore/loader/icon/IconLoader.cpp

    r175406 r175491  
    3838#include "IconDatabase.h"
    3939#include "Logging.h"
     40#include "ResourceBuffer.h"
    4041#include "ResourceRequest.h"
    4142#include "SharedBuffer.h"
    … …  
    8586    // If we got a status code indicating an invalid response, then lets
    8687    // ignore the data and not try to decode the error page as an icon.
    87     auto* data = resource->resourceBuffer();
     88    RefPtr<ResourceBuffer> data = resource->resourceBuffer();
    8889    int status = resource->response().httpStatusCode();
    8990    if (status && (status < 200 || status > 299))
    90         data = nullptr;
     91        data = 0;
    9192
    9293    static const char pdfMagicNumber[] = "%PDF";
    … …  
    9495    if (data && data->size() >= pdfMagicNumberLength && !memcmp(data->data(), pdfMagicNumber, pdfMagicNumberLength)) {
    9596        LOG(IconDatabase, "IconLoader::finishLoading() - Ignoring icon at %s because it appears to be a PDF", resource->url().string().ascii().data());
    96         data = nullptr;
     97        data = 0;
    9798    }
    9899
    … …  
    102103    // kept in memory (so it does not have to be read from the database asynchronously), since
    103104    // there is a page URL referencing it.
    104     iconDatabase().setIconDataForIconURL(data, resource->url().string());
     105    iconDatabase().setIconDataForIconURL(data ? data->sharedBuffer() : 0, resource->url().string());
    105106    m_frame.loader().client().dispatchDidReceiveIcon();
    106107    stopLoading();

  • trunk/Source/WebCore/loader/mac/ResourceLoaderMac.mm

    r175406 r175491  
    3232#include "FrameLoader.h"
    3333#include "FrameLoaderClient.h"
    34 #include "SharedBuffer.h"
    3534
    3635#if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
    3736#include "InspectorInstrumentation.h"
     37#include "ResourceBuffer.h"
    3838#endif
    3939
    … …  
    8484        if (m_options.dataBufferingPolicy() == BufferData) {
    8585            if (!m_resourceData)
    86                 m_resourceData = SharedBuffer::create();
     86                m_resourceData = ResourceBuffer::create();
    8787            m_resourceData->append(data);
    8888        }

  • trunk/Source/WebCore/platform/SharedBuffer.cpp

    r175406 r175491  
    3434
    3535#if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
    36 
    3736static const unsigned segmentSize = 0x1000;
    3837static const unsigned segmentPositionMask = 0x0FFF;
    … …  
    5857    fastFree(p);
    5958}
    60 
    6159#endif
    6260
    … …  
    217215   
    218216#if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
    219     for (char* segment : m_segments)
    220         freeSegment(segment);
     217    for (unsigned i = 0; i < m_segments.size(); ++i)
     218        freeSegment(m_segments[i]);
     219
    221220    m_segments.clear();
    222221#else
    … …  
    228227}
    229228
    230 PassRef<SharedBuffer> SharedBuffer::copy() const
    231 {
    232     PassRef<SharedBuffer> clone { adoptRef(*new SharedBuffer) };
     229PassRefPtr<SharedBuffer> SharedBuffer::copy() const
     230{
     231    RefPtr<SharedBuffer> clone(adoptRef(new SharedBuffer));
    233232    if (hasPlatformData()) {
    234         clone.get().append(data(), size());
     233        clone->append(data(), size());
    235234        return clone;
    236235    }
    237236
    238     clone.get().m_size = m_size;
    239     clone.get().m_buffer->data.reserveCapacity(m_size);
    240     clone.get().m_buffer->data.append(m_buffer->data.data(), m_buffer->data.size());
    241 
    242 #if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
    243     for (char* segment : m_segments)
    244         clone.get().m_buffer->data.append(segment, segmentSize);
     237    clone->m_size = m_size;
     238    clone->m_buffer->data.reserveCapacity(m_size);
     239    clone->m_buffer->data.append(m_buffer->data.data(), m_buffer->data.size());
     240#if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
     241    for (unsigned i = 0; i < m_segments.size(); ++i)
     242        clone->m_buffer->data.append(m_segments[i], segmentSize);
    245243#else
    246     for (auto& data : m_dataArray)
    247         clone.get().append(data.get());
    248 #endif
    249 
     244    for (unsigned i = 0; i < m_dataArray.size(); ++i)
     245        clone->append(m_dataArray[i].get());
     246#endif
    250247    return clone;
    251248}
    … …  
    279276
    280277#if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
    281 
    282278void SharedBuffer::copyBufferAndClear(char* destination, unsigned bytesToCopy) const
    283279{
    284     for (char* segment : m_segments) {
     280    for (unsigned i = 0; i < m_segments.size(); ++i) {
    285281        unsigned effectiveBytesToCopy = std::min(bytesToCopy, segmentSize);
    286         memcpy(destination, segment, effectiveBytesToCopy);
     282        memcpy(destination, m_segments[i], effectiveBytesToCopy);
    287283        destination += effectiveBytesToCopy;
    288284        bytesToCopy -= effectiveBytesToCopy;
    289         freeSegment(segment);
     285        freeSegment(m_segments[i]);
    290286    }
    291287    m_segments.clear();
    292288}
    293 
    294289#endif
    295290

  • trunk/Source/WebCore/platform/SharedBuffer.h

    r175406 r175491  
    103103#endif
    104104
    105     PassRef<SharedBuffer> copy() const;
     105    PassRefPtr<SharedBuffer> copy() const;
    106106   
    107107    // Return the number of consecutive bytes after "position". "data"
    … …  
    119119    WEBCORE_EXPORT unsigned getSomeData(const char*& data, unsigned position = 0) const;
    120120
    121     void tryReplaceContentsWithPlatformBuffer(SharedBuffer&);
     121    void tryReplaceContentsWithPlatformBuffer(SharedBuffer*);
    122122    WEBCORE_EXPORT bool hasPlatformData() const;
    123123
    … …  
    159159    mutable Vector<char*> m_segments;
    160160#endif
    161 
    162161#if USE(CF)
    163162    explicit SharedBuffer(CFDataRef);

  • trunk/Source/WebCore/platform/cf/SharedBufferCF.cpp

    r175406 r175491  
    9393}
    9494
    95 void SharedBuffer::tryReplaceContentsWithPlatformBuffer(SharedBuffer& newContents)
     95void SharedBuffer::tryReplaceContentsWithPlatformBuffer(SharedBuffer* newContents)
    9696{
    97     if (!newContents.m_cfData)
     97    if (!newContents->m_cfData)
    9898        return;
    9999
    100100    clear();
    101     m_cfData = newContents.m_cfData;
     101    m_cfData = newContents->m_cfData;
    102102}
    103103

  • trunk/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h

    r175406 r175491  
    2828
    2929#if ENABLE(VIDEO)
    30 
    3130#include <wtf/Noncopyable.h>
    3231#include <wtf/RefCounted.h>
    … …  
    3736class ResourceRequest;
    3837class ResourceResponse;
     38class SharedBuffer;
    3939
    4040class PlatformMediaResourceLoaderClient {
    … …  
    4444    virtual void responseReceived(const ResourceResponse&) { }
    4545    virtual void dataReceived(const char*, int) { }
     46    virtual void bufferReceived(SharedBuffer*) { }
    4647    virtual void accessControlCheckFailed(const ResourceError&) { }
    4748    virtual void loadFailed(const ResourceError&) { }
    48     virtual void loadFinished() { }
     49    virtual void loadFinished(SharedBuffer*) { }
    4950#if USE(SOUP)
    5051    virtual char* getOrCreateReadBuffer(size_t /*requestedSize*/, size_t& /*actualSize*/) { return nullptr; };
    … …  
    6869
    6970protected:
    70     explicit PlatformMediaResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient> client)
     71    PlatformMediaResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient> client)
    7172        : m_client(WTF::move(client))
    7273    {

  • trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp

    r175406 r175491  
    3434#include "MediaPlayerPrivateAVFoundationCF.h"
    3535#include "NotImplemented.h"
     36#include "ResourceBuffer.h"
    3637#include "ResourceLoaderOptions.h"
    3738#include "SharedBuffer.h"

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm

    r175406 r175491  
    3333#import "CachedResourceRequest.h"
    3434#import "MediaPlayerPrivateAVFoundationObjC.h"
     35#import "ResourceBuffer.h"
    3536#import "ResourceLoaderOptions.h"
    3637#import "SharedBuffer.h"
    … …  
    152153        return;
    153154
    154     SharedBuffer* data = resource->resourceBuffer();
     155    SharedBuffer* data = resource->resourceBuffer() ? resource->resourceBuffer()->sharedBuffer() : 0;
    155156    if (!data)
    156157        return;

  • trunk/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

    r175406 r175491  
    7575        virtual void accessControlCheckFailed(const ResourceError&) override;
    7676        virtual void loadFailed(const ResourceError&) override;
    77         virtual void loadFinished() override;
     77        virtual void loadFinished(SharedBuffer*) override;
    7878};
    7979
    … …  
    10321032}
    10331033
    1034 void CachedResourceStreamingClient::loadFinished()
     1034void CachedResourceStreamingClient::loadFinished(SharedBuffer*)
    10351035{
    10361036    handleNotifyFinished();

  • trunk/Source/WebCore/platform/mac/PasteboardMac.mm

    r175406 r175491  
    5252#import "PlatformStrategies.h"
    5353#import "RenderImage.h"
     54#import "ResourceBuffer.h"
    5455#import "Text.h"
    5556#import "WebCoreNSStringExtras.h"

  • trunk/Source/WebCore/platform/soup/SharedBufferSoup.cpp

    r175406 r175491  
    4545}
    4646
     47void SharedBuffer::tryReplaceContentsWithPlatformBuffer(SharedBuffer*)
     48{
     49    ASSERT_NOT_REACHED();
     50}
     51
    4752void SharedBuffer::maybeTransferPlatformData()
    4853{

  • trunk/Source/WebKit/mac/ChangeLog

    r175443 r175491  
     12014-11-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r175406, r175413, and r175423.
     4        https://bugs.webkit.org/show_bug.cgi?id=138327
     5
     6        Multipart tests are still broken (Requested by ap on #webkit).
     7
     8        Reverted changesets:
     9
     10        "Eliminate ResourceBuffer and use SharedBuffer directly
     11        instead"
     12        https://bugs.webkit.org/show_bug.cgi?id=138174
     13        http://trac.webkit.org/changeset/175406
     14
     15        "Unreviewed, iOS build fix since 175406."
     16        http://trac.webkit.org/changeset/175413
     17
     18        "Fix assertion in CachedResource::addDataBuffer"
     19        http://trac.webkit.org/changeset/175423
     20
    1212014-10-31  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
    222

  • trunk/Source/WebKit/mac/WebView/WebDataSource.mm

    r175406 r175491  
    5454#import <WebCore/LegacyWebArchive.h>
    5555#import <WebCore/MIMETypeRegistry.h>
     56#import <WebCore/ResourceBuffer.h>
    5657#import <WebCore/ResourceRequest.h>
    5758#import <WebCore/SharedBuffer.h>
    … …  
    459460- (NSData *)data
    460461{
    461     RefPtr<SharedBuffer> mainResourceData = toPrivate(_private)->loader->mainResourceData();
     462    RefPtr<ResourceBuffer> mainResourceData = toPrivate(_private)->loader->mainResourceData();
    462463    if (!mainResourceData)
    463464        return nil;

  • trunk/Source/WebKit/mac/WebView/WebHTMLView.mm

    r175406 r175491  
    109109#import <WebCore/RenderView.h>
    110110#import <WebCore/RenderWidget.h>
     111#import <WebCore/ResourceBuffer.h>
    111112#import <WebCore/RuntimeApplicationChecks.h>
    112113#import <WebCore/SharedBuffer.h>
    … …  
    39553956   
    39563957    if (WebCore::CachedImage* tiffResource = [self promisedDragTIFFDataSource]) {
    3957         if (auto* buffer = tiffResource->resourceBuffer()) {
     3958        if (ResourceBuffer *buffer = static_cast<CachedResource*>(tiffResource)->resourceBuffer()) {
    39583959            NSURLResponse *response = tiffResource->response().nsURLResponse();
    39593960            draggingImageURL = [response URL];

  • trunk/Source/WebKit/win/ChangeLog

    r175466 r175491  
     12014-11-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r175406, r175413, and r175423.
     4        https://bugs.webkit.org/show_bug.cgi?id=138327
     5
     6        Multipart tests are still broken (Requested by ap on #webkit).
     7
     8        Reverted changesets:
     9
     10        "Eliminate ResourceBuffer and use SharedBuffer directly
     11        instead"
     12        https://bugs.webkit.org/show_bug.cgi?id=138174
     13        http://trac.webkit.org/changeset/175406
     14
     15        "Unreviewed, iOS build fix since 175406."
     16        http://trac.webkit.org/changeset/175413
     17
     18        "Fix assertion in CachedResource::addDataBuffer"
     19        http://trac.webkit.org/changeset/175423
     20
    1212014-11-03  Sungmann Cho  <sungmann.cho@navercorp.com>
    222

  • trunk/Source/WebKit/win/WebDataSource.cpp

    r175406 r175491  
    4646#include <WebCore/FrameLoader.h>
    4747#include <WebCore/URL.h>
     48#include <WebCore/ResourceBuffer.h>
    4849
    4950using namespace WebCore;
    … …  
    181182        return E_FAIL;
    182183
    183     return MemoryStream::createInstance(m_loader->mainResourceData()).copyRefTo(stream);
     184    RefPtr<ResourceBuffer> buffer = m_loader->mainResourceData();
     185    return MemoryStream::createInstance(buffer ? buffer->sharedBuffer() : 0).copyRefTo(stream);
    184186}
    185187
    … …  
    302304        return E_FAIL;
    303305
    304     *resource = WebResource::createInstance(cachedResource->resourceBuffer(), cachedResource->response());
     306    ResourceBuffer* buffer = cachedResource->resourceBuffer();
     307    *resource = WebResource::createInstance(buffer ? buffer->sharedBuffer() : 0, cachedResource->response());
    305308    return S_OK;
    306309}

  • trunk/Source/WebKit2/CMakeLists.txt

    r175476 r175491  
    236236    Shared/WebRenderLayer.cpp
    237237    Shared/WebRenderObject.cpp
     238    Shared/WebResourceBuffer.cpp
    238239    Shared/WebTouchEvent.cpp
    239240    Shared/WebWheelEvent.cpp

  • trunk/Source/WebKit2/ChangeLog

    r175486 r175491  
     12014-11-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r175406, r175413, and r175423.
     4        https://bugs.webkit.org/show_bug.cgi?id=138327
     5
     6        Multipart tests are still broken (Requested by ap on #webkit).
     7
     8        Reverted changesets:
     9
     10        "Eliminate ResourceBuffer and use SharedBuffer directly
     11        instead"
     12        https://bugs.webkit.org/show_bug.cgi?id=138174
     13        http://trac.webkit.org/changeset/175406
     14
     15        "Unreviewed, iOS build fix since 175406."
     16        http://trac.webkit.org/changeset/175413
     17
     18        "Fix assertion in CachedResource::addDataBuffer"
     19        http://trac.webkit.org/changeset/175423
     20
    1212014-11-03  Tim Horton  <timothy_horton@apple.com>
    222

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r175406 r175491  
    4646#include <WebCore/CertificateInfo.h>
    4747#include <WebCore/NotImplemented.h>
     48#include <WebCore/ResourceBuffer.h>
    4849#include <WebCore/ResourceHandle.h>
    4950#include <WebCore/SharedBuffer.h>
    … …  
    409410void NetworkResourceLoader::sendBuffer(WebCore::SharedBuffer* buffer, int encodedDataLength)
    410411{
    411     ASSERT(buffer);
    412412    ASSERT(!isSynchronous());
    413413
    414414#if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
    415415    ShareableResource::Handle shareableResourceHandle;
    416     NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, *buffer);
     416    NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer);
    417417    if (!shareableResourceHandle.isNull()) {
    418         // Since we're delivering this resource by ourselves all at once and don't need any more data or callbacks from the network layer, abort the loader.
     418        // Since we're delivering this resource by ourselves all at once and don't need anymore data or callbacks from the network layer, abort the loader.
    419419        abort();
    420420        send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime()));
    … …  
    422422    }
    423423#endif
    424 
    425424    IPC::SharedBufferDataReference dataReference(buffer);
    426425    sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

    r175406 r175491  
    4747namespace WebCore {
    4848class BlobDataFileReference;
     49class ResourceBuffer;
    4950class ResourceHandle;
    5051class ResourceRequest;
    … …  
    9293#if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
    9394    static void tryGetShareableHandleFromCFURLCachedResponse(ShareableResource::Handle&, CFCachedURLResponseRef);
    94     static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer&);
     95    static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer*);
    9596#endif
    9697

  • trunk/Source/WebKit2/NetworkProcess/mac/NetworkDiskCacheMonitor.h

    r175406 r175491  
    4949
    5050    // WebCore::DiskCacheMonitor
    51     virtual void resourceBecameFileBacked(WebCore::SharedBuffer&) override;
     51    virtual void resourceBecameFileBacked(PassRefPtr<WebCore::SharedBuffer>) override;
    5252
    5353    // IPC::MessageSender

  • trunk/Source/WebKit2/NetworkProcess/mac/NetworkDiskCacheMonitor.mm

    r175406 r175491  
    6060}
    6161
    62 void NetworkDiskCacheMonitor::resourceBecameFileBacked(SharedBuffer& fileBackedBuffer)
     62void NetworkDiskCacheMonitor::resourceBecameFileBacked(PassRefPtr<SharedBuffer> fileBackedBuffer)
    6363{
    6464    ShareableResource::Handle handle;
    65     NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(handle, fileBackedBuffer);
     65    NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(handle, fileBackedBuffer.get());
    6666    if (handle.isNull())
    6767        return;

  • trunk/Source/WebKit2/NetworkProcess/mac/NetworkResourceLoaderMac.mm

    r175406 r175491  
    8585}
    8686
    87 void NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle& handle, SharedBuffer& buffer)
     87void NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle& handle, SharedBuffer* buffer)
    8888{
    8989    static CFURLCacheRef cache = CFURLCacheCopySharedURLCache();
    … …  
    9494        return;
    9595
    96     CFDataRef data = buffer.existingCFData();
     96    CFDataRef data = buffer->existingCFData();
    9797    if (!data)
    9898        return;
    … …  
    103103    tryGetShareableHandleFromCFData(handle, data);
    104104}
    105 
    106 #endif // IOS || __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
     105#endif // __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
    107106
    108107size_t NetworkResourceLoader::fileBackedResourceMinimumSize()
    … …  
    112111
    113112#if USE(CFNETWORK)
    114 
    115113void NetworkResourceLoader::willCacheResponseAsync(ResourceHandle* handle, CFCachedURLResponseRef cfResponse)
    116114{
    … …  
    136134    m_handle->continueWillCacheResponse(nsResponse);
    137135}
    138 
    139136#endif // !USE(CFNETWORK)
    140137

  • trunk/Source/WebKit2/Platform/IPC/DataReference.h

    r175406 r175491  
    8484};
    8585
    86 class SharedBufferDataReference : public DataReference {
     86class SharedBufferDataReference: public DataReference {
    8787public:
    88     // FIXME: This class doesn't handle null, so the argument should be a reference or PassRef.
    8988    SharedBufferDataReference(WebCore::SharedBuffer* buffer)
    90         : m_buffer(buffer)
    9189    {
     90        m_buffer = buffer;
    9291    }
    9392
    94 private:
    95     // FIXME: It is a bad idea to violate the Liskov Substitution Principle as we do here.
    96     // Since we are using DataReference as a polymoprhic base class in this fashion,
    97     // then we need it to be a base class that does not have functions such as isEmpty,
    98     // size, data, and vector, all of which will do the wrong thing if they are called.
    99     // Deleting these functions here does not prevent them from being called.
    100     bool isEmpty() const = delete;
    101     size_t size() const = delete;
     93    size_t size() const { return m_buffer->size(); }
    10294    const uint8_t* data() const = delete;
    10395    Vector<uint8_t> vector() const = delete;
    10496
    105     virtual void encode(ArgumentEncoder&) const override;
     97    void encode(ArgumentEncoder&) const override;
     98    virtual ~SharedBufferDataReference() { m_buffer = 0; }
    10699
     100private:
    107101    RefPtr<WebCore::SharedBuffer> m_buffer;
    108102};

  • trunk/Source/WebKit2/Shared/WebResourceBuffer.cpp

    r175490 r175491  
    11/*
    2  * Copyright (C) 2011 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 #ifndef CachedTextTrack_h
    27 #define CachedTextTrack_h
     26#include "config.h"
     27#include "WebResourceBuffer.h"
    2828
    29 #if ENABLE(VIDEO_TRACK)
     29#if ENABLE(SHAREABLE_RESOURCE)
    3030
    31 #include "CachedResource.h"
    32 #include "FontOrientation.h"
     31#include "Logging.h"
     32#include "ShareableResource.h"
    3333
    34 namespace WebCore {
     34namespace WebKit {
    3535
    36 class CachedTextTrack final : public CachedResource {
    37 public:
    38     CachedTextTrack(const ResourceRequest&, SessionID);
     36WebResourceBuffer::WebResourceBuffer(PassRefPtr<ShareableResource> resource)
     37    : m_resource(resource)
     38{
     39    ASSERT(m_resource);
     40}
    3941
    40 private:
    41     virtual bool mayTryReplaceEncodedData() const override { return true; }
    42     virtual void addDataBuffer(SharedBuffer&) override;
    43     virtual void finishLoading(SharedBuffer*) override;
     42WebResourceBuffer::~WebResourceBuffer()
     43{
     44}
    4445
    45     void updateData(SharedBuffer*);
    46 };
     46const char* WebResourceBuffer::data() const
     47{
     48    return reinterpret_cast<const char*>(m_resource->data());
     49}
    4750
    48 } // namespace WebCore
     51unsigned WebResourceBuffer::size() const
     52{
     53    return m_resource->size();
     54}
    4955
    50 SPECIALIZE_TYPE_TRAITS_CACHED_RESOURCE(CachedTextTrack, CachedResource::TextTrackResource)
     56bool WebResourceBuffer::isEmpty() const
     57{
     58    return !m_resource || !m_resource->size();
     59}
    5160
    52 #endif // ENABLE(VIDEO_TRACK)
     61} // namespace WebKit
    5362
    54 #endif // CachedTextTrack_h
     63#endif // ENABLE(SHAREABLE_RESOURCE)

  • trunk/Source/WebKit2/Shared/WebResourceBuffer.h

    r175490 r175491  
    11/*
    2  * Copyright (C) 2011 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 #ifndef CachedTextTrack_h
    27 #define CachedTextTrack_h
     26#ifndef WebResourceBuffer_h
     27#define WebResourceBuffer_h
    2828
    29 #if ENABLE(VIDEO_TRACK)
     29#if ENABLE(SHAREABLE_RESOURCE)
    3030
    31 #include "CachedResource.h"
    32 #include "FontOrientation.h"
     31#include <WebCore/ResourceBuffer.h>
    3332
    34 namespace WebCore {
     33namespace WebKit {
    3534
    36 class CachedTextTrack final : public CachedResource {
     35class ShareableResource;
     36
     37class WebResourceBuffer : public WebCore::ResourceBuffer {
    3738public:
    38     CachedTextTrack(const ResourceRequest&, SessionID);
     39    static PassRefPtr<WebResourceBuffer> create(PassRefPtr<ShareableResource> resource) { return adoptRef(new WebResourceBuffer(resource)); }
     40
     41    virtual ~WebResourceBuffer() override;
     42
     43    virtual const char* data() const override;
     44    virtual unsigned size() const override;
     45    virtual bool isEmpty() const override;
    3946
    4047private:
    41     virtual bool mayTryReplaceEncodedData() const override { return true; }
    42     virtual void addDataBuffer(SharedBuffer&) override;
    43     virtual void finishLoading(SharedBuffer*) override;
     48    WebResourceBuffer(PassRefPtr<ShareableResource>);
    4449
    45     void updateData(SharedBuffer*);
     50    RefPtr<ShareableResource> m_resource;
    4651};
    4752
    48 } // namespace WebCore
     53} // namespace WebKit
    4954
    50 SPECIALIZE_TYPE_TRAITS_CACHED_RESOURCE(CachedTextTrack, CachedResource::TextTrackResource)
     55#endif // ENABLE(SHAREABLE_RESOURCE)
    5156
    52 #endif // ENABLE(VIDEO_TRACK)
    53 
    54 #endif // CachedTextTrack_h
     57#endif // WebResourceBuffer_h

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

    r175476 r175491  
    822822                51217460164C20E30037A5C1 /* ShareableResource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5121745E164C20E30037A5C1 /* ShareableResource.cpp */; };
    823823                51217461164C20E30037A5C1 /* ShareableResource.h in Headers */ = {isa = PBXBuildFile; fileRef = 5121745F164C20E30037A5C1 /* ShareableResource.h */; };
     824                51217464164C21370037A5C1 /* WebResourceBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51217462164C21370037A5C1 /* WebResourceBuffer.cpp */; };
     825                51217465164C21370037A5C1 /* WebResourceBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 51217463164C21370037A5C1 /* WebResourceBuffer.h */; };
    824826                5123CF1B133D260A0056F800 /* WKIconDatabaseCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5123CF19133D260A0056F800 /* WKIconDatabaseCG.cpp */; };
    825827                5123CF1C133D260A0056F800 /* WKIconDatabaseCG.h in Headers */ = {isa = PBXBuildFile; fileRef = 5123CF1A133D260A0056F800 /* WKIconDatabaseCG.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    28512853                5121745E164C20E30037A5C1 /* ShareableResource.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ShareableResource.cpp; sourceTree = "<group>"; };
    28522854                5121745F164C20E30037A5C1 /* ShareableResource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ShareableResource.h; sourceTree = "<group>"; };
     2855                51217462164C21370037A5C1 /* WebResourceBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebResourceBuffer.cpp; sourceTree = "<group>"; };
     2856                51217463164C21370037A5C1 /* WebResourceBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebResourceBuffer.h; sourceTree = "<group>"; };
    28532857                5123CF19133D260A0056F800 /* WKIconDatabaseCG.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WKIconDatabaseCG.cpp; path = cg/WKIconDatabaseCG.cpp; sourceTree = "<group>"; };
    28542858                5123CF1A133D260A0056F800 /* WKIconDatabaseCG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WKIconDatabaseCG.h; path = cg/WKIconDatabaseCG.h; sourceTree = "<group>"; };
    … …  
    45224526                                3760881C150413E900FC82C7 /* WebRenderObject.cpp */,
    45234527                                3760881D150413E900FC82C7 /* WebRenderObject.h */,
     4528                                51217462164C21370037A5C1 /* WebResourceBuffer.cpp */,
     4529                                51217463164C21370037A5C1 /* WebResourceBuffer.h */,
    45244530                                F634445512A885C8000612D8 /* WebSecurityOrigin.h */,
    45254531                                A72D5D7F1236CBA800A88B15 /* WebSerializedScriptValue.h */,
    … …  
    75977603                                2D29ECD0192F2C2E00984B78 /* RemoteLayerTreeDisplayRefreshMonitor.h in Headers */,
    75987604                                3760881F150413E900FC82C7 /* WebRenderObject.h in Headers */,
     7605                                51217465164C21370037A5C1 /* WebResourceBuffer.h in Headers */,
    75997606                                33367630130C9998006C9DE2 /* WebResourceCacheManager.h in Headers */,
    76007607                                1AAF089B19267EE500B6390C /* WKUserScript.h in Headers */,
    … …  
    92789285                                2D28F3E61885CCC1004B9EAE /* WebEditorClientIOS.mm in Sources */,
    92799286                                3760881E150413E900FC82C7 /* WebRenderObject.cpp in Sources */,
     9287                                51217464164C21370037A5C1 /* WebResourceBuffer.cpp in Sources */,
    92809288                                3336762F130C9998006C9DE2 /* WebResourceCacheManager.cpp in Sources */,
    92819289                                E115C714190F89E400ECC516 /* DatabaseProcessIOS.mm in Sources */,

  • trunk/Source/WebKit2/WebProcess/Network/NetworkProcessConnection.cpp

    r175406 r175491  
    3131#include "WebCoreArgumentCoders.h"
    3232#include "WebProcess.h"
     33#include "WebResourceBuffer.h"
    3334#include "WebResourceLoadScheduler.h"
    3435#include "WebResourceLoaderMessages.h"
    3536#include <WebCore/CachedResource.h>
    3637#include <WebCore/MemoryCache.h>
     38#include <WebCore/ResourceBuffer.h>
    3739#include <WebCore/SessionID.h>
    3840#include <WebCore/SharedBuffer.h>
    … …  
    9496    }
    9597
    96     resource->tryReplaceEncodedData(*buffer);
     98    resource->tryReplaceEncodedData(buffer.release());
    9799}
    98100#endif

  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.cpp

    r175406 r175491  
    4747#include <WebCore/NetscapePlugInStreamLoader.h>
    4848#include <WebCore/ReferrerPolicy.h>
     49#include <WebCore/ResourceBuffer.h>
    4950#include <WebCore/ResourceLoader.h>
    5051#include <WebCore/SessionID.h>

  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp

    r175406 r175491  
    3939#include <WebCore/CertificateInfo.h>
    4040#include <WebCore/DocumentLoader.h>
     41#include <WebCore/ResourceBuffer.h>
    4142#include <WebCore/ResourceError.h>
    4243#include <WebCore/ResourceLoader.h>

  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoader.h

    r175406 r175491  
    4747class CertificateInfo;
    4848class ProtectionSpace;
     49class ResourceBuffer;
    4950class ResourceError;
    5051class ResourceLoader;

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

    r175406 r175491  
    7575#include <WebCore/PluginDocument.h>
    7676#include <WebCore/ProgressTracker.h>
     77#include <WebCore/ResourceBuffer.h>
    7778#include <WebCore/ResourceError.h>
    7879#include <WebCore/ScriptController.h>
    … …  
    919920                return;
    920921
    921             RefPtr<SharedBuffer> mainResourceData = loader->mainResourceData();
     922            RefPtr<ResourceBuffer> mainResourceData = loader->mainResourceData();
    922923            IPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(mainResourceData ? mainResourceData->data() : 0), mainResourceData ? mainResourceData->size() : 0);
    923924            webPage->send(Messages::WebPageProxy::DidFinishLoadingDataForCustomContentProvider(loader->response().suggestedFilename(), dataReference));

  • trunk/Source/WebKit2/WebProcess/WebPage/WebFrame.cpp

    r175406 r175491  
    6666#include <WebCore/PluginDocument.h>
    6767#include <WebCore/RenderTreeAsText.h>
     68#include <WebCore/ResourceBuffer.h>
    6869#include <WebCore/ResourceLoader.h>
    6970#include <WebCore/ScriptController.h>
    … …  
    305306    if (!documentLoader)
    306307        return String();
    307     RefPtr<SharedBuffer> mainResourceData = documentLoader->mainResourceData();
     308    RefPtr<ResourceBuffer> mainResourceData = documentLoader->mainResourceData();
    308309    if (!mainResourceData)
    309310        return String();

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r175473 r175491  
    138138#include <WebCore/RenderTreeAsText.h>
    139139#include <WebCore/RenderView.h>
     140#include <WebCore/ResourceBuffer.h>
    140141#include <WebCore/ResourceRequest.h>
    141142#include <WebCore/ResourceResponse.h>
    … …  
    24352436    // disappear during script execution.
    24362437
     2438    // Retain the SerializedScriptValue at this level so it (and the internal data) lives
     2439    // long enough for the DataReference to be encoded by the sent message.
    24372440    RefPtr<SerializedScriptValue> serializedResultValue;
     2441    IPC::DataReference dataReference;
     2442
    24382443    JSLockHolder lock(JSDOMWindow::commonVM());
    24392444    if (JSValue resultValue = m_mainFrame->coreFrame()->script().executeScript(script, true).jsValue()) {
    2440         serializedResultValue = SerializedScriptValue::create(m_mainFrame->jsContext(),
    2441             toRef(m_mainFrame->coreFrame()->script().globalObject(mainThreadNormalWorld())->globalExec(), resultValue), nullptr);
    2442     }
    2443 
    2444     IPC::DataReference dataReference;
    2445     if (serializedResultValue)
    2446         dataReference = serializedResultValue->data();
     2445        if ((serializedResultValue = SerializedScriptValue::create(m_mainFrame->jsContext(), toRef(m_mainFrame->coreFrame()->script().globalObject(mainThreadNormalWorld())->globalExec(), resultValue), 0)))
     2446            dataReference = serializedResultValue->data();
     2447    }
     2448
    24472449    send(Messages::WebPageProxy::ScriptValueCallback(dataReference, callbackID));
    24482450}
    … …  
    24572459void WebPage::getContentsAsMHTMLData(uint64_t callbackID, bool useBinaryEncoding)
    24582460{
     2461    IPC::DataReference dataReference;
     2462
    24592463    RefPtr<SharedBuffer> buffer = useBinaryEncoding
    24602464        ? MHTMLArchive::generateMHTMLDataUsingBinaryEncoding(m_page.get())
    24612465        : MHTMLArchive::generateMHTMLData(m_page.get());
    24622466
    2463     // FIXME: Use SharedBufferDataReference.
    2464     IPC::DataReference dataReference;
    24652467    if (buffer)
    24662468        dataReference = IPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
     2469
    24672470    send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
    24682471}
    … …  
    24872490void WebPage::getSelectionAsWebArchiveData(uint64_t callbackID)
    24882491{
     2492    IPC::DataReference dataReference;
     2493
    24892494#if PLATFORM(COCOA)
     2495    RefPtr<LegacyWebArchive> archive;
    24902496    RetainPtr<CFDataRef> data;
    2491     if (Frame* frame = frameWithSelection(m_page.get()))
    2492         data = LegacyWebArchive::createFromSelection(frame)->rawDataRepresentation();
    2493 #endif
    2494 
    2495     IPC::DataReference dataReference;
    2496 #if PLATFORM(COCOA)
    2497     if (data)
     2497
     2498    Frame* frame = frameWithSelection(m_page.get());
     2499    if (frame) {
     2500        archive = LegacyWebArchive::createFromSelection(frame);
     2501        data = archive->rawDataRepresentation();
    24982502        dataReference = IPC::DataReference(CFDataGetBytePtr(data.get()), CFDataGetLength(data.get()));
    2499 #endif
     2503    }
     2504#endif
     2505
    25002506    send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
    25012507}
    … …  
    25202526void WebPage::getMainResourceDataOfFrame(uint64_t frameID, uint64_t callbackID)
    25212527{
    2522     RefPtr<SharedBuffer> buffer;
     2528    IPC::DataReference dataReference;
     2529
     2530    RefPtr<ResourceBuffer> buffer;
     2531    RefPtr<SharedBuffer> pdfResource;
    25232532    if (WebFrame* frame = WebProcess::shared().webFrame(frameID)) {
    2524         if (PluginView* pluginView = pluginViewForFrame(frame->coreFrame()))
    2525             buffer = pluginView->liveResourceData();
    2526         if (!buffer) {
    2527             if (DocumentLoader* loader = frame->coreFrame()->loader().documentLoader())
    2528                 buffer = loader->mainResourceData();
     2533        if (PluginView* pluginView = pluginViewForFrame(frame->coreFrame())) {
     2534            if ((pdfResource = pluginView->liveResourceData()))
     2535                dataReference = IPC::DataReference(reinterpret_cast<const uint8_t*>(pdfResource->data()), pdfResource->size());
    25292536        }
    2530     }
    2531 
    2532     // FIXME: Use SharedBufferDataReference.
    2533     IPC::DataReference dataReference;
    2534     if (buffer)
    2535         dataReference = IPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
     2537
     2538        if (dataReference.isEmpty()) {
     2539            if (DocumentLoader* loader = frame->coreFrame()->loader().documentLoader()) {
     2540                if ((buffer = loader->mainResourceData()))
     2541                    dataReference = IPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
     2542            }
     2543        }
     2544    }
     2545
    25362546    send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
    25372547}
    … …  
    25522562void WebPage::getResourceDataFromFrame(uint64_t frameID, const String& resourceURLString, uint64_t callbackID)
    25532563{
     2564    IPC::DataReference dataReference;
     2565    URL resourceURL(URL(), resourceURLString);
     2566
    25542567    RefPtr<SharedBuffer> buffer;
    25552568    if (WebFrame* frame = WebProcess::shared().webFrame(frameID)) {
    2556         URL resourceURL(URL(), resourceURLString);
    25572569        buffer = resourceDataForFrame(frame->coreFrame(), resourceURL);
    25582570        if (!buffer) {
    … …  
    25602572            buffer = cachedResponseDataForURL(resourceURL);
    25612573        }
    2562     }
    2563 
    2564     // FIXME: Use SharedBufferDataReference.
     2574
     2575        if (buffer)
     2576            dataReference = IPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
     2577    }
     2578
     2579    send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
     2580}
     2581
     2582void WebPage::getWebArchiveOfFrame(uint64_t frameID, uint64_t callbackID)
     2583{
    25652584    IPC::DataReference dataReference;
    2566     if (buffer)
    2567         dataReference = IPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
    2568     send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
    2569 }
    2570 
    2571 void WebPage::getWebArchiveOfFrame(uint64_t frameID, uint64_t callbackID)
    2572 {
     2585
    25732586#if PLATFORM(COCOA)
    25742587    RetainPtr<CFDataRef> data;
    2575     if (WebFrame* frame = WebProcess::shared().webFrame(frameID))
    2576         data = frame->webArchiveData(nullptr, nullptr);
     2588    if (WebFrame* frame = WebProcess::shared().webFrame(frameID)) {
     2589        if ((data = frame->webArchiveData(0, 0)))
     2590            dataReference = IPC::DataReference(CFDataGetBytePtr(data.get()), CFDataGetLength(data.get()));
     2591    }
    25772592#else
    25782593    UNUSED_PARAM(frameID);
    25792594#endif
    25802595
    2581     IPC::DataReference dataReference;
    2582 #if PLATFORM(COCOA)
    2583     if (data)
    2584         dataReference = IPC::DataReference(CFDataGetBytePtr(data.get()), CFDataGetLength(data.get()));
    2585 #endif
    25862596    send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
    25872597}

  • trunk/Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

    r175413 r175491  
    5252#import <WebCore/DNS.h>
    5353#import <WebCore/Element.h>
    54 #import <WebCore/ElementAncestorIterator.h>
    5554#import <WebCore/EventHandler.h>
    5655#import <WebCore/FloatQuad.h>
    … …  
    8382#import <WebCore/RenderThemeIOS.h>
    8483#import <WebCore/RenderView.h>
     84#import <WebCore/ResourceBuffer.h>
    8585#import <WebCore/SharedBuffer.h>
    8686#import <WebCore/TextIterator.h>
    … …  
    18431843static Element* containingLinkElement(Element* element)
    18441844{
    1845     for (auto& currentElement : elementLineage(element)) {
    1846         if (currentElement.isLink())
    1847             return &currentElement;
    1848     }
    1849     return nullptr;
     1845    for (Element* currentElement = element; currentElement; currentElement = currentElement->parentElement())
     1846        if (currentElement->isLink())
     1847            return currentElement;
     1848    return 0;
    18501849}
    18511850
    … …  
    19511950        return;
    19521951
    1953     HTMLElement& element = downcast<HTMLElement>(*m_interactionNode);
    1954     if (!element.renderer())
     1952    HTMLElement* element = downcast<HTMLElement>(m_interactionNode.get());
     1953    if (!element->renderer())
    19551954        return;
    19561955
    19571956    if (static_cast<SheetAction>(action) == SheetAction::Copy) {
    1958         if (is<RenderImage>(*element.renderer())) {
    1959             Element* linkElement = containingLinkElement(&element);
     1957        if (is<RenderImage>(*element->renderer())) {
     1958            Element* linkElement = containingLinkElement(element);
     1959       
    19601960            if (!linkElement)
    1961                 m_interactionNode->document().frame()->editor().writeImageToPasteboard(*Pasteboard::createForCopyAndPaste(), element, downcast<RenderImage>(*element.renderer()).cachedImage()->url(), String());
     1961                m_interactionNode->document().frame()->editor().writeImageToPasteboard(*Pasteboard::createForCopyAndPaste(), *element, downcast<RenderImage>(*element->renderer()).cachedImage()->url(), String());
    19621962            else
    1963                 m_interactionNode->document().frame()->editor().copyURL(linkElement->document().completeURL(stripLeadingAndTrailingHTMLSpaces(linkElement->fastGetAttribute(HTMLNames::hrefAttr))), linkElement->textContent());
    1964         } else if (element.isLink()) {
    1965             m_interactionNode->document().frame()->editor().copyURL(element.document().completeURL(stripLeadingAndTrailingHTMLSpaces(element.fastGetAttribute(HTMLNames::hrefAttr))), element.textContent());
     1963                m_interactionNode->document().frame()->editor().copyURL(linkElement->document().completeURL(stripLeadingAndTrailingHTMLSpaces(linkElement->getAttribute(HTMLNames::hrefAttr))), linkElement->textContent());
     1964        } else if (element->isLink()) {
     1965            m_interactionNode->document().frame()->editor().copyURL(element->document().completeURL(stripLeadingAndTrailingHTMLSpaces(element->getAttribute(HTMLNames::hrefAttr))), element->textContent());
    19661966        }
    19671967    } else if (static_cast<SheetAction>(action) == SheetAction::SaveImage) {
    1968         if (!is<RenderImage>(*element.renderer()))
     1968        if (!is<RenderImage>(*element->renderer()))
    19691969            return;
    1970         CachedImage* cachedImage = downcast<RenderImage>(*element.renderer()).cachedImage();
    1971         if (!cachedImage)
    1972             return;
    1973         SharedBuffer* buffer = cachedImage->resourceBuffer();
    1974         if (!buffer)
    1975             return;
    1976         uint64_t bufferSize = buffer->size();
    1977         RefPtr<SharedMemory> sharedMemoryBuffer = SharedMemory::create(bufferSize);
    1978         memcpy(sharedMemoryBuffer->data(), buffer->data(), bufferSize);
    1979         SharedMemory::Handle handle;
    1980         sharedMemoryBuffer->createHandle(handle, SharedMemory::ReadOnly);
    1981         send(Messages::WebPageProxy::SaveImageToLibrary(handle, bufferSize));
    1982     }
    1983 }
    1984 
    1985 static inline bool isAssistableElement(Element& node)
    1986 {
    1987     if (is<HTMLSelectElement>(node))
     1970        if (CachedImage* cachedImage = downcast<RenderImage>(*element->renderer()).cachedImage()) {
     1971            SharedMemory::Handle handle;
     1972            RefPtr<SharedBuffer> buffer = cachedImage->resourceBuffer()->sharedBuffer();
     1973            if (buffer) {
     1974                uint64_t bufferSize = buffer->size();
     1975                RefPtr<SharedMemory> sharedMemoryBuffer = SharedMemory::create(bufferSize);
     1976                memcpy(sharedMemoryBuffer->data(), buffer->data(), bufferSize);
     1977                sharedMemoryBuffer->createHandle(handle, SharedMemory::ReadOnly);
     1978                send(Messages::WebPageProxy::SaveImageToLibrary(handle, bufferSize));
     1979            }
     1980        }
     1981    }
     1982}
     1983
     1984static inline bool isAssistableNode(Node* node)
     1985{
     1986    if (is<HTMLSelectElement>(*node))
    19881987        return true;
    1989     if (is<HTMLTextAreaElement>(node))
    1990         return !downcast<HTMLTextAreaElement>(node).isReadOnlyNode();
    1991     if (is<HTMLInputElement>(node)) {
    1992         HTMLInputElement& inputElement = downcast<HTMLInputElement>(node);
    1993         // FIXME: This laundry list of types is not a good way to factor this. Need a suitable function on HTMLInputElement itself.
    1994         return !inputElement.isReadOnlyNode() && (inputElement.isTextField() || inputElement.isDateField() || inputElement.isDateTimeLocalField() || inputElement.isMonthField() || inputElement.isTimeField());
    1995     }
    1996     return node.isContentEditable();
    1997 }
    1998 
    1999 static inline Element* nextAssistableElement(Node* startNode, Page& page, bool isForward)
    2000 {
    2001     if (!is<Element>(startNode))
    2002         return nullptr;
    2003 
     1988    if (is<HTMLTextAreaElement>(*node))
     1989        return !downcast<HTMLTextAreaElement>(*node).isReadOnlyNode();
     1990    if (is<HTMLInputElement>(*node)) {
     1991        HTMLInputElement& element = downcast<HTMLInputElement>(*node);
     1992        return !element.isReadOnlyNode() && (element.isTextField() || element.isDateField() || element.isDateTimeLocalField() || element.isMonthField() || element.isTimeField());
     1993    }
     1994
     1995    return node->isContentEditable();
     1996}
     1997
     1998static inline Element* nextFocusableElement(Node* startNode, Page* page, bool isForward)
     1999{
    20042000    RefPtr<KeyboardEvent> key = KeyboardEvent::create();
    20052001
    20062002    Element* nextElement = downcast<Element>(startNode);
    20072003    do {
    2008         nextElement = isForward
    2009             ? page.focusController().nextFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&nextElement->document()), nextElement, key.get())
    2010             : page.focusController().previousFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&nextElement->document()), nextElement, key.get());
    2011     } while (nextElement && !isAssistableElement(*nextElement));
     2004        nextElement = isForward ? page->focusController().nextFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&nextElement->document()), nextElement, key.get())
     2005            : page->focusController().previousFocusableElement(FocusNavigationScope::focusNavigationScopeOf(&nextElement->document()), nextElement, key.get());
     2006    } while (nextElement && !isAssistableNode(nextElement));
    20122007
    20132008    return nextElement;
    20142009}
    20152010
    2016 static inline bool hasAssistableElement(Node* startNode, Page& page, bool isForward)
    2017 {
    2018     return nextAssistableElement(startNode, page, isForward);
     2011static inline bool hasFocusableElement(Node* startNode, Page* page, bool isForward)
     2012{
     2013    return nextFocusableElement(startNode, page, isForward) != nil;
    20192014}
    20202015
    20212016void WebPage::focusNextAssistedNode(bool isForward)
    20222017{
    2023     Element* nextElement = nextAssistableElement(m_assistedNode.get(), *m_page, isForward);
     2018    Element* nextElement = nextFocusableElement(m_assistedNode.get(), m_page.get(), isForward);
    20242019    m_userIsInteracting = true;
    20252020    if (nextElement)
    … …  
    20622057    information.maximumScaleFactor = maximumPageScaleFactor();
    20632058    information.allowsUserScaling = m_viewportConfiguration.allowsUserScaling();
    2064     information.hasNextNode = hasAssistableElement(m_assistedNode.get(), *m_page, true);
    2065     information.hasPreviousNode = hasAssistableElement(m_assistedNode.get(), *m_page, false);
     2059    information.hasNextNode = hasFocusableElement(m_assistedNode.get(), m_page.get(), true);
     2060    information.hasPreviousNode = hasFocusableElement(m_assistedNode.get(), m_page.get(), false);
    20662061
    20672062    if (is<HTMLSelectElement>(*m_assistedNode)) {
Note: See TracChangeset for help on using the changeset viewer.