Changeset 160653 in webkit


Ignore:
Timestamp:
Dec 16, 2013 12:21:24 PM (10 years ago)
Author:
andersca@apple.com
Message:

Rename WebData to API::Data
​https://bugs.webkit.org/show_bug.cgi?id=125797

Reviewed by Beth Dakin.

  • Shared/API/Cocoa/WKRemoteObjectCoder.mm:

(-[WKRemoteObjectEncoder encodeBytes:length:forKey:]):
(-[WKRemoteObjectDecoder decodeBytesForKey:returnedLength:]):

  • Shared/API/c/WKData.cpp:

(WKDataGetTypeID):
(WKDataCreate):

  • Shared/API/c/WKSharedAPICast.h:
  • Shared/API/c/mac/WKWebArchive.cpp:

(WKWebArchiveCopyData):

  • Shared/API/c/mac/WKWebArchiveResource.cpp:

(WKWebArchiveResourceCopyData):

  • Shared/APIData.h: Renamed from Source/WebKit2/Shared/WebData.h.

(API::Data::createWithoutCopying):
(API::Data::create):
(API::Data::~Data):
(API::Data::bytes):
(API::Data::size):
(API::Data::dataReference):
(API::Data::Data):
(API::Data::fastFreeBytes):

  • Shared/Cocoa/WKNSData.h:

(WebKit::wrapper):

  • Shared/Cocoa/WKNSData.mm:

(-[WKNSData dealloc]):

  • Shared/UserMessageCoders.h:

(WebKit::UserMessageEncoder::baseEncode):
(WebKit::UserMessageDecoder::baseDecode):

  • Shared/WebArchive.cpp:

(WebKit::WebArchive::create):
(WebKit::WebArchive::WebArchive):
(WebKit::WebArchive::data):

  • Shared/WebArchive.h:
  • Shared/WebArchiveResource.cpp:

(WebKit::WebArchiveResource::create):
(WebKit::WebArchiveResource::WebArchiveResource):
(WebKit::WebArchiveResource::data):

  • Shared/WebArchiveResource.h:
  • UIProcess/API/C/WKPage.cpp:
  • UIProcess/API/Cocoa/WKBrowsingContextController.mm:

(-[WKBrowsingContextController loadData:MIMEType:textEncodingName:baseURL:userData:]):

  • UIProcess/API/mac/WKPrintingView.mm:

(pageDidDrawToPDF):

  • UIProcess/Downloads/DownloadProxy.cpp:

(WebKit::createData):
(WebKit::DownloadProxy::didFail):
(WebKit::DownloadProxy::didCancel):

  • UIProcess/Downloads/DownloadProxy.h:

(WebKit::DownloadProxy::resumeData):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::loadData):
(WebKit::WebPageProxy::loadWebArchiveData):
(WebKit::WebPageProxy::dataCallback):
(WebKit::WebPageProxy::saveDataToFileInDownloadsFolder):
(WebKit::WebPageProxy::savePDFToFileInDownloadsFolder):

  • UIProcess/WebPageProxy.h:
  • UIProcess/WebUIClient.cpp:

(WebKit::WebUIClient::saveDataToFileInDownloadsFolder):

  • UIProcess/WebUIClient.h:
  • UIProcess/cf/WebPageProxyCF.cpp:

(WebKit::WebPageProxy::sessionStateData):
(WebKit::WebPageProxy::restoreFromSessionStateData):

  • WebKit2.xcodeproj/project.pbxproj:
  • WebProcess/InjectedBundle/API/c/WKBundle.cpp:

(WKBundleCreateWKDataFromUInt8Array):

  • WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::InjectedBundle::createWebDataFromUint8Array):

  • WebProcess/InjectedBundle/InjectedBundle.h:
  • WebProcess/InjectedBundle/InjectedBundlePageEditorClient.cpp:

(WebKit::InjectedBundlePageEditorClient::getPasteboardDataForRange):

  • WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp:

(WebKit::InjectedBundlePageLoaderClient::willLoadDataRequest):

  • WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h:
  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::loadDataImpl):

Location:
trunk/Source/WebKit2
Files:
31 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r160643 r160653  
     12013-12-16  Anders Carlsson  <andersca@apple.com>
     2
     3        Rename WebData to API::Data
     4        https://bugs.webkit.org/show_bug.cgi?id=125797
     5
     6        Reviewed by Beth Dakin.
     7
     8        * Shared/API/Cocoa/WKRemoteObjectCoder.mm:
     9        (-[WKRemoteObjectEncoder encodeBytes:length:forKey:]):
     10        (-[WKRemoteObjectDecoder decodeBytesForKey:returnedLength:]):
     11        * Shared/API/c/WKData.cpp:
     12        (WKDataGetTypeID):
     13        (WKDataCreate):
     14        * Shared/API/c/WKSharedAPICast.h:
     15        * Shared/API/c/mac/WKWebArchive.cpp:
     16        (WKWebArchiveCopyData):
     17        * Shared/API/c/mac/WKWebArchiveResource.cpp:
     18        (WKWebArchiveResourceCopyData):
     19        * Shared/APIData.h: Renamed from Source/WebKit2/Shared/WebData.h.
     20        (API::Data::createWithoutCopying):
     21        (API::Data::create):
     22        (API::Data::~Data):
     23        (API::Data::bytes):
     24        (API::Data::size):
     25        (API::Data::dataReference):
     26        (API::Data::Data):
     27        (API::Data::fastFreeBytes):
     28        * Shared/Cocoa/WKNSData.h:
     29        (WebKit::wrapper):
     30        * Shared/Cocoa/WKNSData.mm:
     31        (-[WKNSData dealloc]):
     32        * Shared/UserMessageCoders.h:
     33        (WebKit::UserMessageEncoder::baseEncode):
     34        (WebKit::UserMessageDecoder::baseDecode):
     35        * Shared/WebArchive.cpp:
     36        (WebKit::WebArchive::create):
     37        (WebKit::WebArchive::WebArchive):
     38        (WebKit::WebArchive::data):
     39        * Shared/WebArchive.h:
     40        * Shared/WebArchiveResource.cpp:
     41        (WebKit::WebArchiveResource::create):
     42        (WebKit::WebArchiveResource::WebArchiveResource):
     43        (WebKit::WebArchiveResource::data):
     44        * Shared/WebArchiveResource.h:
     45        * UIProcess/API/C/WKPage.cpp:
     46        * UIProcess/API/Cocoa/WKBrowsingContextController.mm:
     47        (-[WKBrowsingContextController loadData:MIMEType:textEncodingName:baseURL:userData:]):
     48        * UIProcess/API/mac/WKPrintingView.mm:
     49        (pageDidDrawToPDF):
     50        * UIProcess/Downloads/DownloadProxy.cpp:
     51        (WebKit::createData):
     52        (WebKit::DownloadProxy::didFail):
     53        (WebKit::DownloadProxy::didCancel):
     54        * UIProcess/Downloads/DownloadProxy.h:
     55        (WebKit::DownloadProxy::resumeData):
     56        * UIProcess/WebPageProxy.cpp:
     57        (WebKit::WebPageProxy::loadData):
     58        (WebKit::WebPageProxy::loadWebArchiveData):
     59        (WebKit::WebPageProxy::dataCallback):
     60        (WebKit::WebPageProxy::saveDataToFileInDownloadsFolder):
     61        (WebKit::WebPageProxy::savePDFToFileInDownloadsFolder):
     62        * UIProcess/WebPageProxy.h:
     63        * UIProcess/WebUIClient.cpp:
     64        (WebKit::WebUIClient::saveDataToFileInDownloadsFolder):
     65        * UIProcess/WebUIClient.h:
     66        * UIProcess/cf/WebPageProxyCF.cpp:
     67        (WebKit::WebPageProxy::sessionStateData):
     68        (WebKit::WebPageProxy::restoreFromSessionStateData):
     69        * WebKit2.xcodeproj/project.pbxproj:
     70        * WebProcess/InjectedBundle/API/c/WKBundle.cpp:
     71        (WKBundleCreateWKDataFromUInt8Array):
     72        * WebProcess/InjectedBundle/InjectedBundle.cpp:
     73        (WebKit::InjectedBundle::createWebDataFromUint8Array):
     74        * WebProcess/InjectedBundle/InjectedBundle.h:
     75        * WebProcess/InjectedBundle/InjectedBundlePageEditorClient.cpp:
     76        (WebKit::InjectedBundlePageEditorClient::getPasteboardDataForRange):
     77        * WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp:
     78        (WebKit::InjectedBundlePageLoaderClient::willLoadDataRequest):
     79        * WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h:
     80        * WebProcess/WebPage/WebPage.cpp:
     81        (WebKit::WebPage::loadDataImpl):
     82
    1832013-12-16  Michał Pakuła vel Rutka  <m.pakula@samsung.com>
    284

  • trunk/Source/WebKit2/Shared/API/Cocoa/WKRemoteObjectCoder.mm

    r160608 r160653  
    3030
    3131#import "APIArray.h"
     32#import "APIData.h"
    3233#import "APINumber.h"
    3334#import "APIString.h"
    3435#import "MutableDictionary.h"
    3536#import "WKRemoteObjectInterfaceInternal.h"
    36 #import "WebData.h"
    3737#import <objc/runtime.h>
    3838#import <wtf/RetainPtr.h>
    … …  
    238238- (void)encodeBytes:(const uint8_t *)bytes length:(NSUInteger)length forKey:(NSString *)key
    239239{
    240     _currentDictionary->set(escapeKey(key), WebData::create(bytes, length));
     240    _currentDictionary->set(escapeKey(key), API::Data::create(bytes, length));
    241241}
    242242
    … …  
    506506- (const uint8_t *)decodeBytesForKey:(NSString *)key returnedLength:(NSUInteger *)length
    507507{
    508     WebData* data = _currentDictionary->get<WebData>(escapeKey(key));
     508    auto* data = _currentDictionary->get<API::Data>(escapeKey(key));
    509509    if (!data || !data->size())
    510510        return nullptr;

  • trunk/Source/WebKit2/Shared/API/c/WKData.cpp

    r99239 r160653  
    2727#include "WKData.h"
    2828
    29 #include "WebData.h"
     29#include "APIData.h"
    3030#include "WKAPICast.h"
    3131
    … …  
    3434WKTypeID WKDataGetTypeID()
    3535{
    36     return toAPI(WebData::APIType);
     36    return toAPI(API::Data::APIType);
    3737}
    3838
    3939WKDataRef WKDataCreate(const unsigned char* bytes, size_t size)
    4040{
    41     RefPtr<WebData> data = WebData::create(bytes, size);
    42     return toAPI(data.release().leakRef());
     41    return toAPI(API::Data::create(bytes, size).leakRef());
    4342}
    4443

  • trunk/Source/WebKit2/Shared/API/c/WKSharedAPICast.h

    r160608 r160653  
    6161namespace API {
    6262class Array;
     63class Data;
    6364class Point;
    6465class Rect;
    … …  
    7677class WebConnection;
    7778class WebContextMenuItem;
    78 class WebData;
    7979class WebGraphicsContext;
    8080class WebImage;
    … …  
    9797WK_ADD_API_MAPPING(WKConnectionRef, WebConnection)
    9898WK_ADD_API_MAPPING(WKContextMenuItemRef, WebContextMenuItem)
    99 WK_ADD_API_MAPPING(WKDataRef, WebData)
     99WK_ADD_API_MAPPING(WKDataRef, API::Data)
    100100WK_ADD_API_MAPPING(WKDictionaryRef, ImmutableDictionary)
    101101WK_ADD_API_MAPPING(WKDoubleRef, API::Double)

  • trunk/Source/WebKit2/Shared/API/c/mac/WKWebArchive.cpp

    r159234 r160653  
    2828
    2929#include "APIArray.h"
     30#include "APIData.h"
    3031#include "InjectedBundleRangeHandle.h"
    3132#include "WKBundleAPICast.h"
    … …  
    3334#include "WebArchive.h"
    3435#include "WebArchiveResource.h"
    35 #include "WebData.h"
    3636
    3737using namespace WebKit;
    … …  
    8080WKDataRef WKWebArchiveCopyData(WKWebArchiveRef webArchiveRef)
    8181{
    82     RefPtr<WebData> data = toImpl(webArchiveRef)->data();
    83     return toAPI(data.release().leakRef());
     82    return toAPI(toImpl(webArchiveRef)->data().leakRef());
    8483}

  • trunk/Source/WebKit2/Shared/API/c/mac/WKWebArchiveResource.cpp

    r141473 r160653  
    2727#include "WKWebArchiveResource.h"
    2828
     29#include "APIData.h"
    2930#include "WKSharedAPICast.h"
    3031#include "WebArchiveResource.h"
    31 #include "WebData.h"
    3232
    3333using namespace WebKit;
    … …  
    4646WKDataRef WKWebArchiveResourceCopyData(WKWebArchiveResourceRef webArchiveResourceRef)
    4747{
    48     RefPtr<WebData> data = toImpl(webArchiveResourceRef)->data();
    49     return toAPI(data.release().leakRef());
     48    return toAPI(toImpl(webArchiveResourceRef)->data().leakRef());
    5049}
    5150

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

    r160649 r160653  
    2424 */
    2525
    26 #ifndef WebData_h
    27 #define WebData_h
     26#ifndef APIData_h
     27#define APIData_h
    2828
    2929#include "APIObject.h"
    … …  
    3232#include <wtf/Vector.h>
    3333
    34 namespace WebKit {
     34namespace API {
    3535
    36 // WebData - A data buffer type suitable for vending to an API.
    37 
    38 class WebData : public API::ObjectImpl<API::Object::Type::Data> {
     36class Data : public ObjectImpl<API::Object::Type::Data> {
    3937public:
    4038    typedef void (*FreeDataFunction)(unsigned char*, const void* context);
    4139
    42     static PassRefPtr<WebData> createWithoutCopying(const unsigned char* bytes, size_t size, FreeDataFunction freeDataFunction, const void* context)
     40    static PassRefPtr<Data> createWithoutCopying(const unsigned char* bytes, size_t size, FreeDataFunction freeDataFunction, const void* context)
    4341    {
    44         return adoptRef(new WebData(bytes, size, freeDataFunction, context));
     42        return adoptRef(new Data(bytes, size, freeDataFunction, context));
    4543    }
    4644
    47     static PassRefPtr<WebData> create(const unsigned char* bytes, size_t size)
     45    static PassRefPtr<Data> create(const unsigned char* bytes, size_t size)
    4846    {
    4947        unsigned char *copiedBytes = 0;
    … …  
    5755    }
    5856   
    59     static PassRefPtr<WebData> create(const Vector<unsigned char>& buffer)
     57    static PassRefPtr<Data> create(const Vector<unsigned char>& buffer)
    6058    {
    6159        return create(buffer.data(), buffer.size());
    6260    }
    6361
    64     ~WebData()
     62    ~Data()
    6563    {
    6664        m_freeDataFunction(const_cast<unsigned char*>(m_bytes), m_context);
    … …  
    7068    size_t size() const { return m_size; }
    7169
    72     CoreIPC::DataReference dataReference() const { return CoreIPC::DataReference(m_bytes, m_size); }
     70    IPC::DataReference dataReference() const { return IPC::DataReference(m_bytes, m_size); }
    7371
    7472private:
    75     WebData(const unsigned char* bytes, size_t size, FreeDataFunction freeDataFunction, const void* context)
     73    Data(const unsigned char* bytes, size_t size, FreeDataFunction freeDataFunction, const void* context)
    7674        : m_bytes(bytes)
    7775        , m_size(size)
    … …  
    9492};
    9593
    96 } // namespace WebKit
     94} // namespace API
    9795
    98 #endif // WebData_h
     96#endif // APIData_h

  • trunk/Source/WebKit2/Shared/Cocoa/WKNSData.h

    r160278 r160653  
    2828#if WK_API_ENABLED
    2929
     30#import "APIData.h"
    3031#import "WKObject.h"
    31 #import "WebData.h"
    3232
    33 namespace WebKit {
    34 
    35 inline NSData *wrapper(WebData& data)
     33inline NSData *wrapper(API::Data& data)
    3634{
    3735    ASSERT([data.wrapper() isKindOfClass:[NSData self]]);
    3836    return (NSData *)data.wrapper();
    39 }
    40 
    4137}
    4238

  • trunk/Source/WebKit2/Shared/Cocoa/WKNSData.mm

    r160278 r160653  
    2929#if WK_API_ENABLED
    3030
    31 using namespace WebKit;
    32 
    3331@implementation WKNSData {
    34     API::ObjectStorage<WebData> _data;
     32    API::ObjectStorage<API::Data> _data;
    3533}
    3634
    3735- (void)dealloc
    3836{
    39     _data->~WebData();
     37    _data->~Data();
    4038
    4139    [super dealloc];

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

    r160608 r160653  
    2828
    2929#include "APIArray.h"
     30#include "APIData.h"
    3031#include "APIGeometry.h"
    3132#include "APINumber.h"
    … …  
    3839#include "WebCertificateInfo.h"
    3940#include "WebCoreArgumentCoders.h"
    40 #include "WebData.h"
    4141#include "WebError.h"
    4242#include "WebImage.h"
    … …  
    5858//   - UserContentURLPattern -> UserContentURLPattern
    5959//   - WebCertificateInfo -> WebCertificateInfo
    60 //   - WebData -> WebData
     60//   - API::Data -> API::Data
    6161//   - API::Double -> API::Double
    6262//   - WebImage -> WebImage
    … …  
    210210        }
    211211        case API::Object::Type::Data: {
    212             WebData* data = static_cast<WebData*>(m_root);
     212            API::Data* data = static_cast<API::Data*>(m_root);
    213213            encoder << data->dataReference();
    214214            return true;
    … …  
    501501            if (!decoder.decode(dataReference))
    502502                return false;
    503             coder.m_root = WebData::create(dataReference.data(), dataReference.size());
     503            coder.m_root = API::Data::create(dataReference.data(), dataReference.size());
    504504            break;
    505505        }

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

    r159234 r160653  
    3030
    3131#include "APIArray.h"
     32#include "APIData.h"
    3233#include "WebArchiveResource.h"
    33 #include "WebData.h"
    3434#include <WebCore/LegacyWebArchive.h>
    3535#include <wtf/RetainPtr.h>
    … …  
    4444}
    4545
    46 PassRefPtr<WebArchive> WebArchive::create(WebData* data)
     46PassRefPtr<WebArchive> WebArchive::create(API::Data* data)
    4747{
    4848    return adoptRef(new WebArchive(data));
    … …  
    8383}
    8484
    85 WebArchive::WebArchive(WebData* data)
     85WebArchive::WebArchive(API::Data* data)
    8686{
    8787    RefPtr<SharedBuffer> buffer = SharedBuffer::create(data->bytes(), data->size());
    … …  
    141141}
    142142
    143 PassRefPtr<WebData> WebArchive::data()
     143PassRefPtr<API::Data> WebArchive::data()
    144144{
    145145    RetainPtr<CFDataRef> rawDataRepresentation = m_legacyWebArchive->rawDataRepresentation();
    … …  
    148148    CFRetain(rawDataRepresentation.get());
    149149
    150     return WebData::createWithoutCopying(CFDataGetBytePtr(rawDataRepresentation.get()), CFDataGetLength(rawDataRepresentation.get()), releaseCFData, rawDataRepresentation.get());
     150    return API::Data::createWithoutCopying(CFDataGetBytePtr(rawDataRepresentation.get()), CFDataGetLength(rawDataRepresentation.get()), releaseCFData, rawDataRepresentation.get());
    151151}
    152152

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

    r160384 r160653  
    3535namespace API {
    3636class Array;
     37class Data;
    3738}
    3839
    … …  
    4546
    4647class WebArchiveResource;
    47 class WebData;
    4848
    4949class WebArchive : public API::ObjectImpl<API::Object::Type::WebArchive> {
    … …  
    5252
    5353    static PassRefPtr<WebArchive> create(WebArchiveResource* mainResource, PassRefPtr<API::Array> subresources, PassRefPtr<API::Array> subframeArchives);
    54     static PassRefPtr<WebArchive> create(WebData*);
     54    static PassRefPtr<WebArchive> create(API::Data*);
    5555    static PassRefPtr<WebArchive> create(PassRefPtr<WebCore::LegacyWebArchive>);
    5656    static PassRefPtr<WebArchive> create(WebCore::Range*);
    … …  
    6060    API::Array* subframeArchives();
    6161
    62     PassRefPtr<WebData> data();
     62    PassRefPtr<API::Data> data();
    6363
    6464    WebCore::LegacyWebArchive* coreLegacyWebArchive();
    … …  
    6666private:
    6767    WebArchive(WebArchiveResource* mainResource, PassRefPtr<API::Array> subresources, PassRefPtr<API::Array> subframeArchives);
    68     WebArchive(WebData*);
     68    WebArchive(API::Data*);
    6969    WebArchive(PassRefPtr<WebCore::LegacyWebArchive>);
    7070

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

    r156550 r160653  
    2929#if PLATFORM(MAC)
    3030
    31 #include "WebData.h"
     31#include "APIData.h"
    3232#include <WebCore/ArchiveResource.h>
    3333#include <WebCore/URL.h>
    … …  
    3838namespace WebKit {
    3939
    40 PassRefPtr<WebArchiveResource> WebArchiveResource::create(WebData* data, const String& URL, const String& MIMEType, const String& textEncoding)
     40PassRefPtr<WebArchiveResource> WebArchiveResource::create(API::Data* data, const String& URL, const String& MIMEType, const String& textEncoding)
    4141{
    4242    return adoptRef(new WebArchiveResource(data, URL, MIMEType, textEncoding));
    … …  
    4848}
    4949
    50 WebArchiveResource::WebArchiveResource(WebData* data, const String& URL, const String& MIMEType, const String& textEncoding)
     50WebArchiveResource::WebArchiveResource(API::Data* data, const String& URL, const String& MIMEType, const String& textEncoding)
    5151    : m_archiveResource(ArchiveResource::create(SharedBuffer::create(data->bytes(), data->size()), WebCore::URL(WebCore::URL(), URL), MIMEType, textEncoding, String()))
    5252{
    … …  
    6868}
    6969
    70 PassRefPtr<WebData> WebArchiveResource::data()
     70PassRefPtr<API::Data> WebArchiveResource::data()
    7171{
    7272    RetainPtr<CFDataRef> cfData = m_archiveResource->data()->createCFData();
    … …  
    7575    CFRetain(cfData.get());
    7676
    77     return WebData::createWithoutCopying(CFDataGetBytePtr(cfData.get()), CFDataGetLength(cfData.get()), releaseCFData, cfData.get());
     77    return API::Data::createWithoutCopying(CFDataGetBytePtr(cfData.get()), CFDataGetLength(cfData.get()), releaseCFData, cfData.get());
    7878}
    7979

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

    r160608 r160653  
    3434#include <wtf/RefPtr.h>
    3535
     36namespace API {
     37class Data;
     38}
     39
    3640namespace WebCore {
    3741class ArchiveResource;
    … …  
    4044namespace WebKit {
    4145
    42 class WebData;
    4346class WebURL;
    4447
    … …  
    4750    virtual ~WebArchiveResource();
    4851
    49     static PassRefPtr<WebArchiveResource> create(WebData*, const String& URL, const String& MIMEType, const String& textEncoding);
     52    static PassRefPtr<WebArchiveResource> create(API::Data*, const String& URL, const String& MIMEType, const String& textEncoding);
    5053    static PassRefPtr<WebArchiveResource> create(PassRefPtr<WebCore::ArchiveResource>);
    5154
    52     PassRefPtr<WebData> data();
     55    PassRefPtr<API::Data> data();
    5356    String URL();
    5457    String MIMEType();
    … …  
    5861
    5962private:
    60     WebArchiveResource(WebData*, const String& URL, const String& MIMEType, const String& textEncoding);
     63    WebArchiveResource(API::Data*, const String& URL, const String& MIMEType, const String& textEncoding);
    6164    WebArchiveResource(PassRefPtr<WebCore::ArchiveResource>);
    6265

  • trunk/Source/WebKit2/UIProcess/API/C/WKPage.cpp

    r160608 r160653  
    2929
    3030#include "APIArray.h"
     31#include "APIData.h"
    3132#include "PrintInfo.h"
    3233#include "WKAPICast.h"
    3334#include "WKPluginInformation.h"
    3435#include "WebBackForwardList.h"
    35 #include "WebData.h"
    3636#include "WebPageProxy.h"
    3737#include "WebProcessProxy.h"

  • trunk/Source/WebKit2/UIProcess/API/Cocoa/WKBrowsingContextController.mm

    r160626 r160653  
    2929#if WK_API_ENABLED
    3030
    31 #import "WeakObjCPtr.h"
     31#import "APIData.h"
    3232#import "ObjCObjectGraph.h"
    3333#import "WKBackForwardListInternal.h"
    3434#import "WKBackForwardListItemInternal.h"
     35#import "WKBrowsingContextGroupInternal.h"
     36#import "WKBrowsingContextHandleInternal.h"
     37#import "WKBrowsingContextLoadDelegatePrivate.h"
     38#import "WKBrowsingContextPolicyDelegate.h"
    3539#import "WKErrorRecoveryAttempting.h"
    3640#import "WKFrame.h"
    … …  
    4145#import "WKNSURLExtras.h"
    4246#import "WKNSURLProtectionSpace.h"
     47#import "WKProcessGroupInternal.h"
    4348#import "WKRetainPtr.h"
    4449#import "WKURLRequestNS.h"
    4550#import "WKURLResponseNS.h"
     51#import "WeakObjCPtr.h"
    4652#import "WebCertificateInfo.h"
    4753#import "WebContext.h"
    48 #import "WebData.h"
    4954#import "WebPageProxy.h"
    50 
    51 #import "WKBrowsingContextGroupInternal.h"
    52 #import "WKBrowsingContextHandleInternal.h"
    53 #import "WKBrowsingContextLoadDelegatePrivate.h"
    54 #import "WKBrowsingContextPolicyDelegate.h"
    55 #import "WKProcessGroupInternal.h"
    5655
    5756using namespace WebCore;
    … …  
    243242- (void)loadData:(NSData *)data MIMEType:(NSString *)MIMEType textEncodingName:(NSString *)encodingName baseURL:(NSURL *)baseURL userData:(id)userData
    244243{
    245     RefPtr<WebData> wkData;
     244    RefPtr<API::Data> apiData;
    246245    if (data) {
     246        // FIXME: This should copy the data.
    247247        [data retain];
    248         wkData = WebData::createWithoutCopying((const unsigned char*)[data bytes], [data length], releaseNSData, data);
     248        apiData = API::Data::createWithoutCopying((const unsigned char*)[data bytes], [data length], releaseNSData, data);
    249249    }
    250250
    … …  
    253253        wkUserData = ObjCObjectGraph::create(userData);
    254254
    255     _page->loadData(wkData.get(), MIMEType, encodingName, [baseURL _web_originalDataAsWTFString], wkUserData.get());
     255    _page->loadData(apiData.get(), MIMEType, encodingName, [baseURL _web_originalDataAsWTFString], wkUserData.get());
    256256}
    257257

  • trunk/Source/WebKit2/UIProcess/API/mac/WKPrintingView.mm

    r159001 r160653  
    2727#import "WKPrintingView.h"
    2828
     29#import "APIData.h"
    2930#import "Logging.h"
    3031#import "PDFKitImports.h"
    3132#import "PrintInfo.h"
    3233#import "ShareableBitmap.h"
    33 #import "WebData.h"
    3434#import "WebPageProxy.h"
    3535#import <PDFKit/PDFKit.h>
    … …  
    243243    OwnPtr<IPCCallbackContext> context = adoptPtr(static_cast<IPCCallbackContext*>(untypedContext));
    244244    WKPrintingView *view = context->view.get();
    245     WebData* data = toImpl(dataRef);
     245    API::Data* data = toImpl(dataRef);
    246246
    247247    if (context->callbackID == view->_expectedPrintCallback) {

  • trunk/Source/WebKit2/UIProcess/Downloads/DownloadProxy.cpp

    r159903 r160653  
    2727#include "DownloadProxy.h"
    2828
     29#include "APIData.h"
    2930#include "AuthenticationChallengeProxy.h"
    3031#include "DataReference.h"
    3132#include "DownloadProxyMap.h"
    3233#include "WebContext.h"
    33 #include "WebData.h"
    3434#include "WebProcessMessages.h"
    3535#include <wtf/text/CString.h>
    … …  
    176176}
    177177
    178 static PassRefPtr<WebData> createWebData(const CoreIPC::DataReference& data)
     178static PassRefPtr<API::Data> createData(const CoreIPC::DataReference& data)
    179179{
    180180    if (data.isEmpty())
    181181        return 0;
    182182
    183     return WebData::create(data.data(), data.size());
     183    return API::Data::create(data.data(), data.size());
    184184}
    185185
    … …  
    189189        return;
    190190
    191     m_resumeData = createWebData(resumeData);
     191    m_resumeData = createData(resumeData);
    192192
    193193    m_webContext->downloadClient().didFail(m_webContext.get(), this, error);
    … …  
    199199void DownloadProxy::didCancel(const CoreIPC::DataReference& resumeData)
    200200{
    201     m_resumeData = createWebData(resumeData);
     201    m_resumeData = createData(resumeData);
    202202
    203203    m_webContext->downloadClient().didCancel(m_webContext.get(), this);

  • trunk/Source/WebKit2/UIProcess/Downloads/DownloadProxy.h

    r160384 r160653  
    3434#include <wtf/PassRefPtr.h>
    3535
     36namespace API {
     37class Data;
     38}
     39
    3640namespace WebCore {
    3741    class AuthenticationChallenge;
    … …  
    4448class DownloadProxyMap;
    4549class WebContext;
    46 class WebData;
    4750class WebPageProxy;
    4851
    … …  
    5457    uint64_t downloadID() const { return m_downloadID; }
    5558    const WebCore::ResourceRequest& request() const { return m_request; }
    56     WebData* resumeData() const { return m_resumeData.get(); }
     59    API::Data* resumeData() const { return m_resumeData.get(); }
    5760
    5861    void cancel();
    … …  
    8790    uint64_t m_downloadID;
    8891
    89     RefPtr<WebData> m_resumeData;
     92    RefPtr<API::Data> m_resumeData;
    9093    WebCore::ResourceRequest m_request;
    9194};

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r160566 r160653  
    5959#include "WebContextUserMessageCoders.h"
    6060#include "WebCoreArgumentCoders.h"
    61 #include "WebData.h"
    6261#include "WebEditCommandProxy.h"
    6362#include "WebEvent.h"
    … …  
    660659}
    661660
    662 void WebPageProxy::loadData(WebData* data, const String& MIMEType, const String& encoding, const String& baseURL, API::Object* userData)
     661void WebPageProxy::loadData(API::Data* data, const String& MIMEType, const String& encoding, const String& baseURL, API::Object* userData)
    663662{
    664663    if (!isValid())
    … …  
    706705}
    707706
    708 void WebPageProxy::loadWebArchiveData(const WebData* webArchiveData, API::Object* userData)
     707void WebPageProxy::loadWebArchiveData(API::Data* webArchiveData, API::Object* userData)
    709708{
    710709    if (!isValid())
    … …  
    36063605    }
    36073606
    3608     callback->performCallbackWithReturnValue(WebData::create(dataReference.data(), dataReference.size()).get());
     3607    callback->performCallbackWithReturnValue(API::Data::create(dataReference.data(), dataReference.size()).get());
    36093608}
    36103609
    … …  
    42594258}
    42604259
    4261 void WebPageProxy::saveDataToFileInDownloadsFolder(const String& suggestedFilename, const String& mimeType, const String& originatingURLString, WebData* data)
     4260void WebPageProxy::saveDataToFileInDownloadsFolder(const String& suggestedFilename, const String& mimeType, const String& originatingURLString, API::Data* data)
    42624261{
    42634262    m_uiClient.saveDataToFileInDownloadsFolder(this, suggestedFilename, mimeType, originatingURLString, data);
    42644263}
    42654264
    4266 void WebPageProxy::savePDFToFileInDownloadsFolder(const String& suggestedFilename, const String& originatingURLString, const CoreIPC::DataReference& data)
     4265void WebPageProxy::savePDFToFileInDownloadsFolder(const String& suggestedFilename, const String& originatingURLString, const CoreIPC::DataReference& dataReference)
    42674266{
    42684267    if (!suggestedFilename.endsWith(".pdf", false))
    42694268        return;
    42704269
    4271     RefPtr<WebData> webData = WebData::create(data.data(), data.size());
    4272 
    4273     saveDataToFileInDownloadsFolder(suggestedFilename, "application/pdf", originatingURLString, webData.get());
     4270    RefPtr<API::Data> data = API::Data::create(dataReference.data(), dataReference.size());
     4271
     4272    saveDataToFileInDownloadsFolder(suggestedFilename, "application/pdf", originatingURLString, data.get());
    42744273}
    42754274

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.h

    r160566 r160653  
    138138class WebColorPickerResultListenerProxy;
    139139class WebContextMenuProxy;
    140 class WebData;
    141140class WebEditCommandProxy;
    142141class WebFullScreenManagerProxy;
    … …  
    371370    void loadURLRequest(WebURLRequest*, API::Object* userData = nullptr);
    372371    void loadFile(const String& fileURL, const String& resourceDirectoryURL, API::Object* userData = nullptr);
    373     void loadData(WebData*, const String& MIMEType, const String& encoding, const String& baseURL, API::Object* userData = nullptr);
     372    void loadData(API::Data*, const String& MIMEType, const String& encoding, const String& baseURL, API::Object* userData = nullptr);
    374373    void loadHTMLString(const String& htmlString, const String& baseURL, API::Object* userData = nullptr);
    375374    void loadAlternateHTMLString(const String& htmlString, const String& baseURL, const String& unreachableURL, API::Object* userData = nullptr);
    376375    void loadPlainTextString(const String&, API::Object* userData = nullptr);
    377     void loadWebArchiveData(const WebData*, API::Object* userData = nullptr);
     376    void loadWebArchiveData(API::Data*, API::Object* userData = nullptr);
    378377
    379378    void stopLoading();
    … …  
    536535
    537536    typedef bool (*WebPageProxySessionStateFilterCallback)(WKPageRef, WKStringRef type, WKTypeRef object, void* context);
    538     PassRefPtr<WebData> sessionStateData(WebPageProxySessionStateFilterCallback, void* context) const;
    539     void restoreFromSessionStateData(WebData*);
     537    PassRefPtr<API::Data> sessionStateData(WebPageProxySessionStateFilterCallback, void* context) const;
     538    void restoreFromSessionStateData(API::Data*);
    540539
    541540    bool supportsTextZoom() const;
    … …  
    779778#endif
    780779
    781     void saveDataToFileInDownloadsFolder(const String& suggestedFilename, const String& mimeType, const String& originatingURLString, WebData*);
     780    void saveDataToFileInDownloadsFolder(const String& suggestedFilename, const String& mimeType, const String& originatingURLString, API::Data*);
    782781    void savePDFToFileInDownloadsFolder(const String& suggestedFilename, const String& originatingURLString, const CoreIPC::DataReference&);
    783782#if PLATFORM(MAC)

  • trunk/Source/WebKit2/UIProcess/WebUIClient.cpp

    r160608 r160653  
    421421}
    422422
    423 void WebUIClient::saveDataToFileInDownloadsFolder(WebPageProxy* page, const String& suggestedFilename, const String& mimeType, const String& originatingURLString, WebData* data)
     423void WebUIClient::saveDataToFileInDownloadsFolder(WebPageProxy* page, const String& suggestedFilename, const String& mimeType, const String& originatingURLString, API::Data* data)
    424424{
    425425    if (!m_client.saveDataToFileInDownloadsFolder)

  • trunk/Source/WebKit2/UIProcess/WebUIClient.h

    r159994 r160653  
    3636
    3737namespace API {
     38class Data;
     39
    3840template<> struct ClientTraits<WKPageUIClientBase> {
    3941    typedef std::tuple<WKPageUIClientV0, WKPageUIClientV1, WKPageUIClientV2> Versions;
    … …  
    5658class NotificationPermissionRequest;
    5759class WebColorPickerResultListenerProxy;
    58 class WebData;
    5960class WebFrameProxy;
    6061class WebPageProxy;
    … …  
    122123    void runModal(WebPageProxy*);
    123124
    124     void saveDataToFileInDownloadsFolder(WebPageProxy*, const String& suggestedFilename, const String& mimeType, const String& originatingURLString, WebData*);
     125    void saveDataToFileInDownloadsFolder(WebPageProxy*, const String& suggestedFilename, const String& mimeType, const String& originatingURLString, API::Data*);
    125126
    126127    bool shouldInterruptJavaScript(WebPageProxy*);

  • trunk/Source/WebKit2/UIProcess/cf/WebPageProxyCF.cpp

    r160405 r160653  
    2727#include "WebPageProxy.h"
    2828
     29#include "APIData.h"
    2930#include "DataReference.h"
    3031#include "Logging.h"
    3132#include "SessionState.h"
    3233#include "WebBackForwardList.h"
    33 #include "WebData.h"
    3434#include "WebPageMessages.h"
    3535#include "WebProcessProxy.h"
    … …  
    4747static const UInt32 CurrentSessionStateDataVersion = 2;
    4848
    49 PassRefPtr<WebData> WebPageProxy::sessionStateData(WebPageProxySessionStateFilterCallback filter, void* context) const
     49PassRefPtr<API::Data> WebPageProxy::sessionStateData(WebPageProxySessionStateFilterCallback filter, void* context) const
    5050{
    5151    const void* keys[2];
    … …  
    102102    CFDataGetBytes(stateCFData.get(), CFRangeMake(0, length), stateVector.data() + sizeof(UInt32));
    103103   
    104     return WebData::create(stateVector);
    105 }
    106 
    107 void WebPageProxy::restoreFromSessionStateData(WebData* webData)
    108 {
    109     if (!webData || webData->size() < sizeof(UInt32))
    110         return;
    111 
    112     const unsigned char* buffer = webData->bytes();
     104    return API::Data::create(stateVector);
     105}
     106
     107void WebPageProxy::restoreFromSessionStateData(API::Data* apiData)
     108{
     109    if (!apiData || apiData->size() < sizeof(UInt32))
     110        return;
     111
     112    const unsigned char* buffer = apiData->bytes();
    113113    UInt32 versionHeader = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
    114114   
    … …  
    118118    }
    119119   
    120     RetainPtr<CFDataRef> data = adoptCF(CFDataCreate(0, webData->bytes() + sizeof(UInt32), webData->size() - sizeof(UInt32)));
     120    RetainPtr<CFDataRef> data = adoptCF(CFDataCreate(0, apiData->bytes() + sizeof(UInt32), apiData->size() - sizeof(UInt32)));
    121121
    122122    CFErrorRef propertyListError = 0;

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

    r160616 r160653  
    584584                5153569C1291B1D2000749DC /* WebPageContextMenuClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5153569A1291B1D2000749DC /* WebPageContextMenuClient.cpp */; };
    585585                5153569D1291B1D2000749DC /* WebPageContextMenuClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 5153569B1291B1D2000749DC /* WebPageContextMenuClient.h */; };
    586                 51578B831209ECEF00A37C4A /* WebData.h in Headers */ = {isa = PBXBuildFile; fileRef = 51578B821209ECEF00A37C4A /* WebData.h */; };
     586                51578B831209ECEF00A37C4A /* APIData.h in Headers */ = {isa = PBXBuildFile; fileRef = 51578B821209ECEF00A37C4A /* APIData.h */; };
    587587                515E7727183DD6F60007203F /* AsyncRequest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 515E7725183DD6F60007203F /* AsyncRequest.cpp */; };
    588588                515E7728183DD6F60007203F /* AsyncRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E7726183DD6F60007203F /* AsyncRequest.h */; };
    … …  
    21712171                5153569A1291B1D2000749DC /* WebPageContextMenuClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPageContextMenuClient.cpp; sourceTree = "<group>"; };
    21722172                5153569B1291B1D2000749DC /* WebPageContextMenuClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPageContextMenuClient.h; sourceTree = "<group>"; };
    2173                 51578B821209ECEF00A37C4A /* WebData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebData.h; sourceTree = "<group>"; };
     2173                51578B821209ECEF00A37C4A /* APIData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = APIData.h; sourceTree = "<group>"; };
    21742174                515E7725183DD6F60007203F /* AsyncRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AsyncRequest.cpp; sourceTree = "<group>"; };
    21752175                515E7726183DD6F60007203F /* AsyncRequest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AsyncRequest.h; sourceTree = "<group>"; };
    … …  
    34693469                                BC64696E11DBE603006455B0 /* APIArray.h */,
    34703470                                1A3DD205125E5A2F004515E6 /* APIClient.h */,
     3471                                51578B821209ECEF00A37C4A /* APIData.h */,
    34713472                                1AC1336F18566C7C00F3EC05 /* APIFrameHandle.cpp */,
    34723473                                1AC1337018566C7C00F3EC05 /* APIFrameHandle.h */,
    … …  
    35643565                                51BA24451858F41500EA2811 /* WebCrossThreadCopier.cpp */,
    35653566                                516311861858446600534647 /* WebCrossThreadCopier.h */,
    3566                                 51578B821209ECEF00A37C4A /* WebData.h */,
    35673567                                BC575612126E0138006F0F12 /* WebError.cpp */,
    35683568                                516A4A5B120A2CCD00C05B7F /* WebError.h */,
    … …  
    60006000                                1A9E329718219BEA00F5D04C /* WKRemoteObjectRegistryPrivate.h in Headers */,
    60016001                                512F589B12A8838800629530 /* WebCredential.h in Headers */,
    6002                                 51578B831209ECEF00A37C4A /* WebData.h in Headers */,
     6002                                51578B831209ECEF00A37C4A /* APIData.h in Headers */,
    60036003                                F6A25FDD12ADC6CC00DC40CC /* WebDatabaseManager.h in Headers */,
    60046004                                F62A76B712B1B25F0005F1B6 /* WebDatabaseManagerMessages.h in Headers */,

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/API/c/WKBundle.cpp

    r160104 r160653  
    2828
    2929#include "APIArray.h"
     30#include "APIData.h"
    3031#include "InjectedBundle.h"
    3132#include "WKAPICast.h"
    3233#include "WKBundleAPICast.h"
    3334#include "WKBundlePrivate.h"
    34 #include "WebData.h"
    3535
    3636using namespace WebKit;
    … …  
    267267WKDataRef WKBundleCreateWKDataFromUInt8Array(WKBundleRef bundle, JSContextRef context, JSValueRef data)
    268268{
    269     RefPtr<WebData> webData = toImpl(bundle)->createWebDataFromUint8Array(context, data);
    270     return toAPI(webData.release().leakRef());
     269    return toAPI(toImpl(bundle)->createWebDataFromUint8Array(context, data).leakRef());
    271270}
    272271

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

    r160608 r160653  
    4040#include "WebCookieManager.h"
    4141#include "WebCoreArgumentCoders.h"
    42 #include "WebData.h"
    4342#include "WebDatabaseManager.h"
    4443#include "WebFrame.h"
    … …  
    627626}
    628627
    629 PassRefPtr<WebData> InjectedBundle::createWebDataFromUint8Array(JSContextRef context, JSValueRef data)
     628// FIXME Get rid of this function and move it into WKBundle.cpp.
     629PassRefPtr<API::Data> InjectedBundle::createWebDataFromUint8Array(JSContextRef context, JSValueRef data)
    630630{
    631631    JSC::ExecState* execState = toJS(context);
    632632    RefPtr<Uint8Array> arrayData = WebCore::toUint8Array(toJS(execState, data));
    633     return WebData::create(static_cast<unsigned char*>(arrayData->baseAddress()), arrayData->byteLength());
     633    return API::Data::create(static_cast<unsigned char*>(arrayData->baseAddress()), arrayData->byteLength());
    634634}
    635635

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundle.h

    r160384 r160653  
    5050namespace API {
    5151class Array;
     52class Data;
    5253}
    5354
    54 namespace CoreIPC {
    55     class ArgumentDecoder;
    56     class Connection;
     55namespace IPC {
     56class ArgumentDecoder;
     57class Connection;
    5758}
    5859
    … …  
    7071class WebCertificateInfo;
    7172class WebConnection;
    72 class WebData;
    7373class WebFrame;
    7474class WebPage;
    … …  
    123123    void removeAllWebNotificationPermissions(WebPage*);
    124124    uint64_t webNotificationID(JSContextRef, JSValueRef);
    125     PassRefPtr<WebData> createWebDataFromUint8Array(JSContextRef, JSValueRef);
     125    PassRefPtr<API::Data> createWebDataFromUint8Array(JSContextRef, JSValueRef);
    126126
    127127    // UserContent API

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundlePageEditorClient.cpp

    r160608 r160653  
    2828
    2929#include "APIArray.h"
     30#include "APIData.h"
    3031#include "InjectedBundleNodeHandle.h"
    3132#include "InjectedBundleRangeHandle.h"
    … …  
    3334#include "WKBundleAPICast.h"
    3435#include "WKString.h"
    35 #include "WebData.h"
    3636#include <wtf/text/WTFString.h>
    3737
    … …  
    158158            pasteboardTypes.append(type->string());
    159159
    160         for (const auto& item : dataArray->elementsOfType<WebData>()) {
     160        for (const auto& item : dataArray->elementsOfType<API::Data>()) {
    161161            RefPtr<SharedBuffer> buffer = SharedBuffer::create(item->bytes(), item->size());
    162162            pasteboardData.append(buffer);

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp

    r159988 r160653  
    2828
    2929#include "APIArray.h"
     30#include "APIData.h"
    3031#include "InjectedBundleDOMWindowExtension.h"
    3132#include "InjectedBundleScriptWorld.h"
    3233#include "WKAPICast.h"
    3334#include "WKBundleAPICast.h"
    34 #include "WebData.h"
    3535#include "WebError.h"
    3636#include "WebURLRequest.h"
    … …  
    5656}
    5757
    58 void InjectedBundlePageLoaderClient::willLoadDataRequest(WebPage* page, const ResourceRequest& request, const SharedBuffer* data, const String& MIMEType, const String& encodingName, const URL& unreachableURL, API::Object* userData)
     58void InjectedBundlePageLoaderClient::willLoadDataRequest(WebPage* page, const ResourceRequest& request, SharedBuffer* sharedBuffer, const String& MIMEType, const String& encodingName, const URL& unreachableURL, API::Object* userData)
    5959{
    6060    if (!m_client.willLoadDataRequest)
    6161        return;
    6262
    63     RefPtr<WebData> webData;
     63    RefPtr<API::Data> data;
    6464    if (data) {
    65         const_cast<SharedBuffer*>(data)->ref();
    66         webData = WebData::createWithoutCopying((const unsigned char*)data->data(), data->size(), releaseSharedBuffer, data);
     65        sharedBuffer->ref();
     66        data = API::Data::createWithoutCopying((const unsigned char*)sharedBuffer->data(), sharedBuffer->size(), releaseSharedBuffer, sharedBuffer);
    6767    }
    6868
    69     m_client.willLoadDataRequest(toAPI(page), toAPI(request), toAPI(webData.get()), toAPI(MIMEType.impl()), toAPI(encodingName.impl()), toURLRef(unreachableURL.string().impl()), toAPI(userData), m_client.base.clientInfo);
     69    m_client.willLoadDataRequest(toAPI(page), toAPI(request), toAPI(data.get()), toAPI(MIMEType.impl()), toAPI(encodingName.impl()), toURLRef(unreachableURL.string().impl()), toAPI(userData), m_client.base.clientInfo);
    7070}
    7171

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h

    r159994 r160653  
    6262public:
    6363    void willLoadURLRequest(WebPage*, const WebCore::ResourceRequest&, API::Object*);
    64     void willLoadDataRequest(WebPage*, const WebCore::ResourceRequest&, const WebCore::SharedBuffer*, const String&, const String&, const WebCore::URL&, API::Object*);
     64    void willLoadDataRequest(WebPage*, const WebCore::ResourceRequest&, WebCore::SharedBuffer*, const String&, const String&, const WebCore::URL&, API::Object*);
    6565
    6666    bool shouldGoToBackForwardListItem(WebPage*, InjectedBundleBackForwardListItem*, RefPtr<API::Object>& userData);

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

    r160572 r160653  
    912912    // Let the InjectedBundle know we are about to start the load, passing the user data from the UIProcess
    913913    // to all the client to set up any needed state.
    914     m_loaderClient.willLoadDataRequest(this, request, substituteData.content(), substituteData.mimeType(), substituteData.textEncoding(), substituteData.failingURL(), userData.get());
     914    m_loaderClient.willLoadDataRequest(this, request, const_cast<SharedBuffer*>(substituteData.content()), substituteData.mimeType(), substituteData.textEncoding(), substituteData.failingURL(), userData.get());
    915915
    916916    // Initate the load in WebCore.
Note: See TracChangeset for help on using the changeset viewer.