Changeset 170000 in webkit


Ignore:
Timestamp:
Jun 15, 2014, 9:09:25 PM (11 years ago)
Author:
mitz@apple.com
Message:

Part 1 of Change GenericCallback<> function parameters into std::function<>
​https://bugs.webkit.org/show_bug.cgi?id=133927

Reviewed by Sam Weinig.

  • UIProcess/API/C/WKApplicationCacheManager.cpp:

(WKApplicationCacheManagerGetApplicationCacheOrigins):

  • UIProcess/API/C/WKContext.cpp:

(WKContextGetStatistics):
(WKContextGetStatisticsWithOptions):

  • UIProcess/API/C/WKCookieManager.cpp:

(WKCookieManagerGetHostnamesWithCookies):
(WKCookieManagerGetHTTPCookieAcceptPolicy):

  • UIProcess/API/C/WKDatabaseManager.cpp:

(WKDatabaseManagerGetDatabasesByOrigin):
(WKDatabaseManagerGetDatabaseOrigins):

  • UIProcess/API/C/WKFrame.cpp:

(WKFrameGetMainResourceData):
(WKFrameGetResourceData):
(WKFrameGetWebArchive):

  • UIProcess/API/C/WKKeyValueStorageManager.cpp:

(WKKeyValueStorageManagerGetKeyValueStorageOrigins):
(WKKeyValueStorageManagerGetStorageDetailsByOrigin):

  • UIProcess/API/C/WKMediaCacheManager.cpp:

(WKMediaCacheManagerGetHostnamesWithMediaCache):

  • UIProcess/API/C/WKOriginDataManager.cpp:

(WKOriginDataManagerGetOrigins):

  • UIProcess/API/C/WKPluginSiteDataManager.cpp:

(WKPluginSiteDataManagerGetSitesWithData):

  • UIProcess/API/C/WKResourceCacheManager.cpp:

(WKResourceCacheManagerGetCacheOrigins):

  • UIProcess/API/Cocoa/WKWebView.mm:

(-[WKWebView _getWebArchiveDataWithCompletionHandler:]):

  • UIProcess/API/mac/WKView.mm:

(-[WKView attributedSubstringForProposedRange:completionHandler:]):

  • UIProcess/Plugins/WebPluginSiteDataManager.cpp:

(WebKit::WebPluginSiteDataManager::getSitesWithData):

  • UIProcess/Plugins/WebPluginSiteDataManager.h:
  • UIProcess/WebApplicationCacheManagerProxy.cpp:

(WebKit::WebApplicationCacheManagerProxy::getApplicationCacheOrigins):

  • UIProcess/WebApplicationCacheManagerProxy.h:
  • UIProcess/WebContext.cpp:

(WebKit::WebContext::getStatistics):

  • UIProcess/WebContext.h:
  • UIProcess/WebCookieManagerProxy.cpp:

(WebKit::WebCookieManagerProxy::getHostnamesWithCookies):
(WebKit::WebCookieManagerProxy::getHTTPCookieAcceptPolicy):

  • UIProcess/WebCookieManagerProxy.h:
  • UIProcess/WebDatabaseManagerProxy.cpp:

(WebKit::WebDatabaseManagerProxy::getDatabasesByOrigin):
(WebKit::WebDatabaseManagerProxy::getDatabaseOrigins):

  • UIProcess/WebDatabaseManagerProxy.h:
  • UIProcess/WebFrameProxy.cpp:

(WebKit::WebFrameProxy::getWebArchive):
(WebKit::WebFrameProxy::getMainResourceData):
(WebKit::WebFrameProxy::getResourceData):

  • UIProcess/WebFrameProxy.h:
  • UIProcess/WebKeyValueStorageManager.cpp:

(WebKit::WebKeyValueStorageManager::getKeyValueStorageOrigins):
(WebKit::WebKeyValueStorageManager::getStorageDetailsByOrigin):

  • UIProcess/WebKeyValueStorageManager.h:
  • UIProcess/WebMediaCacheManagerProxy.cpp:

(WebKit::WebMediaCacheManagerProxy::getHostnamesWithMediaCache):

  • UIProcess/WebMediaCacheManagerProxy.h:
  • UIProcess/WebOriginDataManagerProxy.cpp:

(WebKit::WebOriginDataManagerProxy::getOrigins):

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

(WebKit::WebPageProxy::getMainResourceDataOfFrame):
(WebKit::WebPageProxy::getResourceDataFromFrame):
(WebKit::WebPageProxy::getWebArchiveOfFrame):

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

(WebKit::WebResourceCacheManagerProxy::getCacheOrigins):

  • UIProcess/WebResourceCacheManagerProxy.h:
  • UIProcess/ios/WKContentViewInteraction.mm:

(-[WKContentView changeSelectionWithGestureAt:withGesture:withState:]):
(-[WKContentView changeSelectionWithTouchesFrom:to:withGesture:withState:]):

  • UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::selectWithGesture):
(WebKit::WebPageProxy::selectWithTwoTouches):

  • UIProcess/mac/WebPageProxyMac.mm:

(WebKit::WebPageProxy::attributedSubstringForCharacterRangeAsync):

Location:
trunk/Source/WebKit2
Files:
38 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/Source/WebKit2/ChangeLog

    r169998 r170000  
     12014-06-15  Dan Bernstein  <mitz@apple.com>
     2
     3        Part 1 of Change GenericCallback<> function parameters into std::function<>
     4        https://bugs.webkit.org/show_bug.cgi?id=133927
     5
     6        Reviewed by Sam Weinig.
     7
     8        * UIProcess/API/C/WKApplicationCacheManager.cpp:
     9        (WKApplicationCacheManagerGetApplicationCacheOrigins):
     10        * UIProcess/API/C/WKContext.cpp:
     11        (WKContextGetStatistics):
     12        (WKContextGetStatisticsWithOptions):
     13        * UIProcess/API/C/WKCookieManager.cpp:
     14        (WKCookieManagerGetHostnamesWithCookies):
     15        (WKCookieManagerGetHTTPCookieAcceptPolicy):
     16        * UIProcess/API/C/WKDatabaseManager.cpp:
     17        (WKDatabaseManagerGetDatabasesByOrigin):
     18        (WKDatabaseManagerGetDatabaseOrigins):
     19        * UIProcess/API/C/WKFrame.cpp:
     20        (WKFrameGetMainResourceData):
     21        (WKFrameGetResourceData):
     22        (WKFrameGetWebArchive):
     23        * UIProcess/API/C/WKKeyValueStorageManager.cpp:
     24        (WKKeyValueStorageManagerGetKeyValueStorageOrigins):
     25        (WKKeyValueStorageManagerGetStorageDetailsByOrigin):
     26        * UIProcess/API/C/WKMediaCacheManager.cpp:
     27        (WKMediaCacheManagerGetHostnamesWithMediaCache):
     28        * UIProcess/API/C/WKOriginDataManager.cpp:
     29        (WKOriginDataManagerGetOrigins):
     30        * UIProcess/API/C/WKPluginSiteDataManager.cpp:
     31        (WKPluginSiteDataManagerGetSitesWithData):
     32        * UIProcess/API/C/WKResourceCacheManager.cpp:
     33        (WKResourceCacheManagerGetCacheOrigins):
     34        * UIProcess/API/Cocoa/WKWebView.mm:
     35        (-[WKWebView _getWebArchiveDataWithCompletionHandler:]):
     36        * UIProcess/API/mac/WKView.mm:
     37        (-[WKView attributedSubstringForProposedRange:completionHandler:]):
     38        * UIProcess/Plugins/WebPluginSiteDataManager.cpp:
     39        (WebKit::WebPluginSiteDataManager::getSitesWithData):
     40        * UIProcess/Plugins/WebPluginSiteDataManager.h:
     41        * UIProcess/WebApplicationCacheManagerProxy.cpp:
     42        (WebKit::WebApplicationCacheManagerProxy::getApplicationCacheOrigins):
     43        * UIProcess/WebApplicationCacheManagerProxy.h:
     44        * UIProcess/WebContext.cpp:
     45        (WebKit::WebContext::getStatistics):
     46        * UIProcess/WebContext.h:
     47        * UIProcess/WebCookieManagerProxy.cpp:
     48        (WebKit::WebCookieManagerProxy::getHostnamesWithCookies):
     49        (WebKit::WebCookieManagerProxy::getHTTPCookieAcceptPolicy):
     50        * UIProcess/WebCookieManagerProxy.h:
     51        * UIProcess/WebDatabaseManagerProxy.cpp:
     52        (WebKit::WebDatabaseManagerProxy::getDatabasesByOrigin):
     53        (WebKit::WebDatabaseManagerProxy::getDatabaseOrigins):
     54        * UIProcess/WebDatabaseManagerProxy.h:
     55        * UIProcess/WebFrameProxy.cpp:
     56        (WebKit::WebFrameProxy::getWebArchive):
     57        (WebKit::WebFrameProxy::getMainResourceData):
     58        (WebKit::WebFrameProxy::getResourceData):
     59        * UIProcess/WebFrameProxy.h:
     60        * UIProcess/WebKeyValueStorageManager.cpp:
     61        (WebKit::WebKeyValueStorageManager::getKeyValueStorageOrigins):
     62        (WebKit::WebKeyValueStorageManager::getStorageDetailsByOrigin):
     63        * UIProcess/WebKeyValueStorageManager.h:
     64        * UIProcess/WebMediaCacheManagerProxy.cpp:
     65        (WebKit::WebMediaCacheManagerProxy::getHostnamesWithMediaCache):
     66        * UIProcess/WebMediaCacheManagerProxy.h:
     67        * UIProcess/WebOriginDataManagerProxy.cpp:
     68        (WebKit::WebOriginDataManagerProxy::getOrigins):
     69        * UIProcess/WebOriginDataManagerProxy.h:
     70        * UIProcess/WebPageProxy.cpp:
     71        (WebKit::WebPageProxy::getMainResourceDataOfFrame):
     72        (WebKit::WebPageProxy::getResourceDataFromFrame):
     73        (WebKit::WebPageProxy::getWebArchiveOfFrame):
     74        * UIProcess/WebPageProxy.h:
     75        * UIProcess/WebResourceCacheManagerProxy.cpp:
     76        (WebKit::WebResourceCacheManagerProxy::getCacheOrigins):
     77        * UIProcess/WebResourceCacheManagerProxy.h:
     78        * UIProcess/ios/WKContentViewInteraction.mm:
     79        (-[WKContentView changeSelectionWithGestureAt:withGesture:withState:]):
     80        (-[WKContentView changeSelectionWithTouchesFrom:to:withGesture:withState:]):
     81        * UIProcess/ios/WebPageProxyIOS.mm:
     82        (WebKit::WebPageProxy::selectWithGesture):
     83        (WebKit::WebPageProxy::selectWithTwoTouches):
     84        * UIProcess/mac/WebPageProxyMac.mm:
     85        (WebKit::WebPageProxy::attributedSubstringForCharacterRangeAsync):
     86
    1872014-06-15  Dan Bernstein  <mitz@apple.com>
    288

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKApplicationCacheManager.cpp

    r169984 r170000  
    3939void WKApplicationCacheManagerGetApplicationCacheOrigins(WKApplicationCacheManagerRef applicationCacheManagerRef, void* context, WKApplicationCacheManagerGetApplicationCacheOriginsFunction callback)
    4040{
    41     toImpl(applicationCacheManagerRef)->getApplicationCacheOrigins(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     41    toImpl(applicationCacheManagerRef)->getApplicationCacheOrigins(toGenericCallbackFunction(context, callback));
    4242}
    4343

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKContext.cpp

    r169984 r170000  
    518518void WKContextGetStatistics(WKContextRef contextRef, void* context, WKContextGetStatisticsFunction callback)
    519519{
    520     toImpl(contextRef)->getStatistics(0xFFFFFFFF, DictionaryCallback::create(toGenericCallbackFunction(context, callback)));
     520    toImpl(contextRef)->getStatistics(0xFFFFFFFF, toGenericCallbackFunction(context, callback));
    521521}
    522522
    523523void WKContextGetStatisticsWithOptions(WKContextRef contextRef, WKStatisticsOptions optionsMask, void* context, WKContextGetStatisticsFunction callback)
    524524{
    525     toImpl(contextRef)->getStatistics(optionsMask, DictionaryCallback::create(toGenericCallbackFunction(context, callback)));
     525    toImpl(contextRef)->getStatistics(optionsMask, toGenericCallbackFunction(context, callback));
    526526}
    527527

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKCookieManager.cpp

    r169984 r170000  
    4444void WKCookieManagerGetHostnamesWithCookies(WKCookieManagerRef cookieManagerRef, void* context, WKCookieManagerGetCookieHostnamesFunction callback)
    4545{
    46     toImpl(cookieManagerRef)->getHostnamesWithCookies(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     46    toImpl(cookieManagerRef)->getHostnamesWithCookies(toGenericCallbackFunction(context, callback));
    4747}
    4848
    … …  
    6969void WKCookieManagerGetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, void* context, WKCookieManagerGetHTTPCookieAcceptPolicyFunction callback)
    7070{
    71     toImpl(cookieManager)->getHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicyCallback::create(toGenericCallbackFunction<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy>(context, callback)));
     71    toImpl(cookieManager)->getHTTPCookieAcceptPolicy(toGenericCallbackFunction<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy>(context, callback));
    7272}
    7373

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKDatabaseManager.cpp

    r169984 r170000  
    156156{
    157157#if ENABLE(SQL_DATABASE)
    158     toImpl(databaseManagerRef)->getDatabasesByOrigin(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     158    toImpl(databaseManagerRef)->getDatabasesByOrigin(toGenericCallbackFunction(context, callback));
    159159#else
    160160    UNUSED_PARAM(databaseManagerRef);
    … …  
    167167{
    168168#if ENABLE(SQL_DATABASE)
    169     toImpl(databaseManagerRef)->getDatabaseOrigins(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     169    toImpl(databaseManagerRef)->getDatabaseOrigins(toGenericCallbackFunction(context, callback));
    170170#else
    171171    UNUSED_PARAM(databaseManagerRef);

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKFrame.cpp

    r169984 r170000  
    125125void WKFrameGetMainResourceData(WKFrameRef frameRef, WKFrameGetResourceDataFunction callback, void* context)
    126126{
    127     toImpl(frameRef)->getMainResourceData(DataCallback::create(toGenericCallbackFunction(context, callback)));
     127    toImpl(frameRef)->getMainResourceData(toGenericCallbackFunction(context, callback));
    128128}
    129129
    130130void WKFrameGetResourceData(WKFrameRef frameRef, WKURLRef resourceURL, WKFrameGetResourceDataFunction callback, void* context)
    131131{
    132     toImpl(frameRef)->getResourceData(toImpl(resourceURL), DataCallback::create(toGenericCallbackFunction(context, callback)));
     132    toImpl(frameRef)->getResourceData(toImpl(resourceURL), toGenericCallbackFunction(context, callback));
    133133}
    134134
    135135void WKFrameGetWebArchive(WKFrameRef frameRef, WKFrameGetWebArchiveFunction callback, void* context)
    136136{
    137     toImpl(frameRef)->getWebArchive(DataCallback::create(toGenericCallbackFunction(context, callback)));
     137    toImpl(frameRef)->getWebArchive(toGenericCallbackFunction(context, callback));
    138138}
    139139

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKKeyValueStorageManager.cpp

    r169984 r170000  
    5757void WKKeyValueStorageManagerGetKeyValueStorageOrigins(WKKeyValueStorageManagerRef keyValueStorageManagerRef, void* context, WKKeyValueStorageManagerGetKeyValueStorageOriginsFunction callback)
    5858{
    59     toImpl(keyValueStorageManagerRef)->getKeyValueStorageOrigins(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     59    toImpl(keyValueStorageManagerRef)->getKeyValueStorageOrigins(toGenericCallbackFunction(context, callback));
    6060}
    6161
    6262void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerRef keyValueStorageManagerRef, void* context, WKKeyValueStorageManagerGetStorageDetailsByOriginFunction callback)
    6363{
    64     toImpl(keyValueStorageManagerRef)->getStorageDetailsByOrigin(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     64    toImpl(keyValueStorageManagerRef)->getStorageDetailsByOrigin(toGenericCallbackFunction(context, callback));
    6565}
    6666

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKMediaCacheManager.cpp

    r169984 r170000  
    3939void WKMediaCacheManagerGetHostnamesWithMediaCache(WKMediaCacheManagerRef mediaCacheManagerRef, void* context, WKMediaCacheManagerGetHostnamesWithMediaCacheFunction callback)
    4040{
    41     toImpl(mediaCacheManagerRef)->getHostnamesWithMediaCache(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     41    toImpl(mediaCacheManagerRef)->getHostnamesWithMediaCache(toGenericCallbackFunction(context, callback));
    4242}
    4343

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKOriginDataManager.cpp

    r169984 r170000  
    3939void WKOriginDataManagerGetOrigins(WKOriginDataManagerRef originDataManagerRef, WKOriginDataTypes types, void* context, WKOriginDataManagerGetOriginsFunction callback)
    4040{
    41     toImpl(originDataManagerRef)->getOrigins(types, ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     41    toImpl(originDataManagerRef)->getOrigins(types, toGenericCallbackFunction(context, callback));
    4242}
    4343

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKPluginSiteDataManager.cpp

    r169994 r170000  
    4949{
    5050#if ENABLE(NETSCAPE_PLUGIN_API)
    51     toImpl(managerRef)->getSitesWithData(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     51    toImpl(managerRef)->getSitesWithData(toGenericCallbackFunction(context, callback));
    5252#else
    5353    UNUSED_PARAM(managerRef);

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/C/WKResourceCacheManager.cpp

    r169984 r170000  
    3939void WKResourceCacheManagerGetCacheOrigins(WKResourceCacheManagerRef cacheManagerRef, void* context, WKResourceCacheManagerGetCacheOriginsFunction callback)
    4040{
    41     toImpl(cacheManagerRef)->getCacheOrigins(ArrayCallback::create(toGenericCallbackFunction(context, callback)));
     41    toImpl(cacheManagerRef)->getCacheOrigins(toGenericCallbackFunction(context, callback));
    4242}
    4343

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/Cocoa/WKWebView.mm

    r169995 r170000  
    15211521    auto handler = adoptNS([completionHandler copy]);
    15221522
    1523     _page->getWebArchiveOfFrame(_page->mainFrame(), WebKit::DataCallback::create([handler](API::Data* data, WebKit::CallbackBase::Error error) {
     1523    _page->getWebArchiveOfFrame(_page->mainFrame(), [handler](API::Data* data, WebKit::CallbackBase::Error error) {
    15241524        void (^completionHandlerBlock)(NSData *, NSError *) = (void (^)(NSData *, NSError *))handler.get();
    15251525        if (error != WebKit::CallbackBase::Error::None) {
    … …  
    15291529        } else
    15301530            completionHandlerBlock(wrapper(*data), nil);
    1531     }));
     1531    });
    15321532}
    15331533

  • TabularUnified trunk/Source/WebKit2/UIProcess/API/mac/WKView.mm

    r169987 r170000  
    15251525
    15261526    LOG(TextInput, "attributedSubstringFromRange:(%u, %u)", nsRange.location, nsRange.length);
    1527     _data->_page->attributedSubstringForCharacterRangeAsync(nsRange, AttributedStringForCharacterRangeCallback::create([completionHandler](const AttributedString& string, const EditingRange& actualRange, CallbackBase::Error error) {
     1527    _data->_page->attributedSubstringForCharacterRangeAsync(nsRange, [completionHandler](const AttributedString& string, const EditingRange& actualRange, CallbackBase::Error error) {
    15281528        void (^completionHandlerBlock)(NSAttributedString *, NSRange) = (void (^)(NSAttributedString *, NSRange))completionHandler.get();
    15291529        if (error != CallbackBase::Error::None) {
    … …  
    15341534        LOG(TextInput, "    -> attributedSubstringFromRange returned %@", [string.string.get() string]);
    15351535        completionHandlerBlock([[string.string.get() retain] autorelease], actualRange);
    1536     }));
     1536    });
    15371537}
    15381538

  • TabularUnified trunk/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.cpp

    r169990 r170000  
    139139}
    140140
    141 void WebPluginSiteDataManager::getSitesWithData(PassRefPtr<ArrayCallback> prpCallback)
    142 {
    143     RefPtr<ArrayCallback> callback = prpCallback;
     141void WebPluginSiteDataManager::getSitesWithData(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
     142{
     143    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
    144144
    145145    if (!m_webContext) {

  • TabularUnified trunk/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.h

    r167854 r170000  
    5151    void clearContext() { m_webContext = 0; }
    5252
    53     void getSitesWithData(PassRefPtr<ArrayCallback>);
     53    void getSitesWithData(std::function<void (API::Array*, CallbackBase::Error)>);
    5454    void didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID);
    5555

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebApplicationCacheManagerProxy.cpp

    r169990 r170000  
    8181}
    8282
    83 void WebApplicationCacheManagerProxy::getApplicationCacheOrigins(PassRefPtr<ArrayCallback> prpCallback)
     83void WebApplicationCacheManagerProxy::getApplicationCacheOrigins(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    8484{
    85     if (!context())
     85    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
     86
     87    if (!context()) {
     88        callback->invalidate();
    8689        return;
     90    }
    8791
    88     RefPtr<ArrayCallback> callback = prpCallback;
    89    
    9092    uint64_t callbackID = callback->callbackID();
    9193    m_arrayCallbacks.set(callbackID, callback.release());

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebApplicationCacheManagerProxy.h

    r164409 r170000  
    5353    virtual ~WebApplicationCacheManagerProxy();
    5454
    55     void getApplicationCacheOrigins(PassRefPtr<ArrayCallback>);
     55    void getApplicationCacheOrigins(std::function<void (API::Array*, CallbackBase::Error)>);
    5656    void deleteEntriesForOrigin(WebSecurityOrigin*);
    5757    void deleteAllEntries();

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebContext.cpp

    r169990 r170000  
    12171217}
    12181218
    1219 void WebContext::getStatistics(uint32_t statisticsMask, PassRefPtr<DictionaryCallback> callback)
     1219void WebContext::getStatistics(uint32_t statisticsMask, std::function<void (ImmutableDictionary*, CallbackBase::Error)> callbackFunction)
    12201220{
    12211221    if (!statisticsMask) {
    1222         callback->invalidate();
    1223         return;
    1224     }
    1225 
    1226     RefPtr<StatisticsRequest> request = StatisticsRequest::create(callback);
     1222        callbackFunction(nullptr, CallbackBase::Error::Unknown);
     1223        return;
     1224    }
     1225
     1226    RefPtr<StatisticsRequest> request = StatisticsRequest::create(DictionaryCallback::create(std::move(callbackFunction)));
    12271227
    12281228    if (statisticsMask & StatisticsRequestTypeWebContent)

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebContext.h

    r168999 r170000  
    268268    bool httpPipeliningEnabled() const;
    269269
    270     void getStatistics(uint32_t statisticsMask, PassRefPtr<DictionaryCallback>);
     270    void getStatistics(uint32_t statisticsMask, std::function<void (ImmutableDictionary*, CallbackBase::Error)>);
    271271   
    272272    void garbageCollectJavaScriptObjects();

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebCookieManagerProxy.cpp

    r169990 r170000  
    100100}
    101101
    102 void WebCookieManagerProxy::getHostnamesWithCookies(PassRefPtr<ArrayCallback> prpCallback)
     102void WebCookieManagerProxy::getHostnamesWithCookies(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    103103{
    104     RefPtr<ArrayCallback> callback = prpCallback;
     104    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
    105105    uint64_t callbackID = callback->callbackID();
    106106    m_arrayCallbacks.set(callbackID, callback.release());
    … …  
    162162}
    163163
    164 void WebCookieManagerProxy::getHTTPCookieAcceptPolicy(PassRefPtr<HTTPCookieAcceptPolicyCallback> prpCallback)
     164void WebCookieManagerProxy::getHTTPCookieAcceptPolicy(std::function<void (HTTPCookieAcceptPolicy, CallbackBase::Error)> callbackFunction)
    165165{
    166     RefPtr<HTTPCookieAcceptPolicyCallback> callback = prpCallback;
     166    RefPtr<HTTPCookieAcceptPolicyCallback> callback = HTTPCookieAcceptPolicyCallback::create(std::move(callbackFunction));
    167167
    168168    uint64_t callbackID = callback->callbackID();

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebCookieManagerProxy.h

    r164409 r170000  
    6161    void initializeClient(const WKCookieManagerClientBase*);
    6262   
    63     void getHostnamesWithCookies(PassRefPtr<ArrayCallback>);
     63    void getHostnamesWithCookies(std::function<void (API::Array*, CallbackBase::Error)>);
    6464    void deleteCookiesForHostname(const String& hostname);
    6565    void deleteAllCookies();
    … …  
    6767
    6868    void setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy);
    69     void getHTTPCookieAcceptPolicy(PassRefPtr<HTTPCookieAcceptPolicyCallback>);
     69    void getHTTPCookieAcceptPolicy(std::function<void (HTTPCookieAcceptPolicy, CallbackBase::Error)>);
    7070
    7171    void startObservingCookieChanges();

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebDatabaseManagerProxy.cpp

    r169990 r170000  
    153153}
    154154
    155 void WebDatabaseManagerProxy::getDatabasesByOrigin(PassRefPtr<ArrayCallback> prpCallback)
    156 {
    157     RefPtr<ArrayCallback> callback = prpCallback;
     155void WebDatabaseManagerProxy::getDatabasesByOrigin(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
     156{
     157    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
    158158    uint64_t callbackID = callback->callbackID();
    159159    m_arrayCallbacks.set(callbackID, callback.release());
    … …  
    206206}
    207207
    208 void WebDatabaseManagerProxy::getDatabaseOrigins(PassRefPtr<ArrayCallback> prpCallback)
    209 {
    210     RefPtr<ArrayCallback> callback = prpCallback;
     208void WebDatabaseManagerProxy::getDatabaseOrigins(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
     209{
     210    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
    211211    uint64_t callbackID = callback->callbackID();
    212212    m_arrayCallbacks.set(callbackID, callback.release());

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebDatabaseManagerProxy.h

    r164409 r170000  
    5656    void initializeClient(const WKDatabaseManagerClientBase*);
    5757
    58     void getDatabasesByOrigin(PassRefPtr<ArrayCallback>);
    59     void getDatabaseOrigins(PassRefPtr<ArrayCallback>);
     58    void getDatabasesByOrigin(std::function<void (API::Array*, CallbackBase::Error)>);
     59    void getDatabaseOrigins(std::function<void (API::Array*, CallbackBase::Error)>);
    6060    void deleteDatabaseWithNameForOrigin(const String& databaseIdentifier, WebSecurityOrigin*);
    6161    void deleteDatabasesForOrigin(WebSecurityOrigin*);

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebFrameProxy.cpp

    r160969 r170000  
    196196}
    197197
    198 void WebFrameProxy::getWebArchive(PassRefPtr<DataCallback> callback)
     198void WebFrameProxy::getWebArchive(std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
    199199{
    200200    if (!m_page) {
    201         callback->invalidate();
    202         return;
    203     }
    204 
    205     m_page->getWebArchiveOfFrame(this, callback);
    206 }
    207 
    208 void WebFrameProxy::getMainResourceData(PassRefPtr<DataCallback> callback)
     201        callbackFunction(nullptr, CallbackBase::Error::Unknown);
     202        return;
     203    }
     204
     205    m_page->getWebArchiveOfFrame(this, callbackFunction);
     206}
     207
     208void WebFrameProxy::getMainResourceData(std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
    209209{
    210210    if (!m_page) {
    211         callback->invalidate();
    212         return;
    213     }
    214 
    215     m_page->getMainResourceDataOfFrame(this, callback);
    216 }
    217 
    218 void WebFrameProxy::getResourceData(API::URL* resourceURL, PassRefPtr<DataCallback> callback)
     211        callbackFunction(nullptr, CallbackBase::Error::Unknown);
     212        return;
     213    }
     214
     215    m_page->getMainResourceDataOfFrame(this, callbackFunction);
     216}
     217
     218void WebFrameProxy::getResourceData(API::URL* resourceURL, std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
    219219{
    220220    if (!m_page) {
    221         callback->invalidate();
    222         return;
    223     }
    224 
    225     m_page->getResourceDataFromFrame(this, resourceURL, callback);
     221        callbackFunction(nullptr, CallbackBase::Error::Unknown);
     222        return;
     223    }
     224
     225    m_page->getResourceDataFromFrame(this, resourceURL, callbackFunction);
    226226}
    227227

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebFrameProxy.h

    r164409 r170000  
    9696    bool isDisplayingPDFDocument() const;
    9797
    98     void getWebArchive(PassRefPtr<DataCallback>);
    99     void getMainResourceData(PassRefPtr<DataCallback>);
    100     void getResourceData(API::URL*, PassRefPtr<DataCallback>);
     98    void getWebArchive(std::function<void (API::Data*, CallbackBase::Error)>);
     99    void getMainResourceData(std::function<void (API::Data*, CallbackBase::Error)>);
     100    void getResourceData(API::URL*, std::function<void (API::Data*, CallbackBase::Error)>);
    101101
    102102    void didStartProvisionalLoad(const String& url);

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebKeyValueStorageManager.cpp

    r163212 r170000  
    100100}
    101101
    102 void WebKeyValueStorageManager::getKeyValueStorageOrigins(PassRefPtr<ArrayCallback> prpCallback)
     102void WebKeyValueStorageManager::getKeyValueStorageOrigins(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    103103{
    104     context()->storageManager().getOrigins(RunLoop::main(), prpCallback.leakRef(), didGetKeyValueStorageOrigins);
     104    context()->storageManager().getOrigins(RunLoop::main(), ArrayCallback::create(std::move(callbackFunction)).leakRef(), didGetKeyValueStorageOrigins);
    105105}
    106106
    … …  
    129129}
    130130
    131 void WebKeyValueStorageManager::getStorageDetailsByOrigin(PassRefPtr<ArrayCallback> prpCallback)
     131void WebKeyValueStorageManager::getStorageDetailsByOrigin(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    132132{
    133     context()->storageManager().getStorageDetailsByOrigin(RunLoop::main(), prpCallback.leakRef(), didGetStorageDetailsByOrigin);
     133    context()->storageManager().getStorageDetailsByOrigin(RunLoop::main(), ArrayCallback::create(std::move(callbackFunction)).leakRef(), didGetStorageDetailsByOrigin);
    134134}
    135135

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebKeyValueStorageManager.h

    r164409 r170000  
    4646    virtual ~WebKeyValueStorageManager();
    4747
    48     void getKeyValueStorageOrigins(PassRefPtr<ArrayCallback>);
    49     void getStorageDetailsByOrigin(PassRefPtr<ArrayCallback>);
     48    void getKeyValueStorageOrigins(std::function<void (API::Array*, CallbackBase::Error)>);
     49    void getStorageDetailsByOrigin(std::function<void (API::Array*, CallbackBase::Error)>);
    5050    void deleteEntriesForOrigin(WebSecurityOrigin*);
    5151    void deleteAllEntries();

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebMediaCacheManagerProxy.cpp

    r169990 r170000  
    8282}
    8383
    84 void WebMediaCacheManagerProxy::getHostnamesWithMediaCache(PassRefPtr<ArrayCallback> prpCallback)
     84void WebMediaCacheManagerProxy::getHostnamesWithMediaCache(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    8585{
    86     RefPtr<ArrayCallback> callback = prpCallback;
     86    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
    8787    uint64_t callbackID = callback->callbackID();
    8888    m_arrayCallbacks.set(callbackID, callback.release());

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebMediaCacheManagerProxy.h

    r164409 r170000  
    4949    virtual ~WebMediaCacheManagerProxy();
    5050   
    51     void getHostnamesWithMediaCache(PassRefPtr<ArrayCallback>);
     51    void getHostnamesWithMediaCache(std::function<void (API::Array*, CallbackBase::Error)>);
    5252    void clearCacheForHostname(const String&);
    5353    void clearCacheForAllHostnames();

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebOriginDataManagerProxy.cpp

    r169990 r170000  
    8181}
    8282
    83 void WebOriginDataManagerProxy::getOrigins(WKOriginDataTypes types, PassRefPtr<ArrayCallback> prpCallback)
     83void WebOriginDataManagerProxy::getOrigins(WKOriginDataTypes types, std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    8484{
    85     if (!context())
     85    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
     86
     87    if (!context()) {
     88        callback->invalidate();
    8689        return;
    87 
    88     RefPtr<ArrayCallback> callback = prpCallback;
     90    }
    8991
    9092    uint64_t callbackID = callback->callbackID();

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebOriginDataManagerProxy.h

    r164409 r170000  
    5555    virtual ~WebOriginDataManagerProxy();
    5656
    57     void getOrigins(WKOriginDataTypes, PassRefPtr<ArrayCallback>);
     57    void getOrigins(WKOriginDataTypes, std::function<void (API::Array*, CallbackBase::Error)>);
    5858    void deleteEntriesForOrigin(WKOriginDataTypes, WebSecurityOrigin*);
    5959    void deleteAllEntries(WKOriginDataTypes);

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

    r169993 r170000  
    22932293}
    22942294
    2295 void WebPageProxy::getMainResourceDataOfFrame(WebFrameProxy* frame, PassRefPtr<DataCallback> prpCallback)
    2296 {
    2297     RefPtr<DataCallback> callback = prpCallback;
     2295void WebPageProxy::getMainResourceDataOfFrame(WebFrameProxy* frame, std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
     2296{
     2297    RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    22982298    if (!isValid()) {
    22992299        callback->invalidate();
    … …  
    23062306}
    23072307
    2308 void WebPageProxy::getResourceDataFromFrame(WebFrameProxy* frame, API::URL* resourceURL, PassRefPtr<DataCallback> prpCallback)
    2309 {
    2310     RefPtr<DataCallback> callback = prpCallback;
     2308void WebPageProxy::getResourceDataFromFrame(WebFrameProxy* frame, API::URL* resourceURL, std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
     2309{
     2310    RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    23112311    if (!isValid()) {
    23122312        callback->invalidate();
    … …  
    23192319}
    23202320
    2321 void WebPageProxy::getWebArchiveOfFrame(WebFrameProxy* frame, PassRefPtr<DataCallback> prpCallback)
    2322 {
    2323     RefPtr<DataCallback> callback = prpCallback;
     2321void WebPageProxy::getWebArchiveOfFrame(WebFrameProxy* frame, std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
     2322{
     2323    RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    23242324    if (!isValid()) {
    23252325        callback->invalidate();

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

    r169987 r170000  
    398398    void didCommitLayerTree(const WebKit::RemoteLayerTreeTransaction&);
    399399
    400     void selectWithGesture(const WebCore::IntPoint, WebCore::TextGranularity, uint32_t gestureType, uint32_t gestureState, PassRefPtr<GestureCallback>);
     400    void selectWithGesture(const WebCore::IntPoint, WebCore::TextGranularity, uint32_t gestureType, uint32_t gestureState, std::function<void (const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, CallbackBase::Error)>);
    401401    void updateSelectionWithTouches(const WebCore::IntPoint, uint32_t touches, bool baseIsStart, PassRefPtr<TouchesCallback>);
    402     void selectWithTwoTouches(const WebCore::IntPoint from, const WebCore::IntPoint to, uint32_t gestureType, uint32_t gestureState, PassRefPtr<GestureCallback>);
     402    void selectWithTwoTouches(const WebCore::IntPoint from, const WebCore::IntPoint to, uint32_t gestureType, uint32_t gestureState, std::function<void (const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, CallbackBase::Error)>);
    403403    void updateBlockSelectionWithTouch(const WebCore::IntPoint, uint32_t touch, uint32_t handlePosition);
    404404    void extendSelection(WebCore::TextGranularity);
    … …  
    481481#if PLATFORM(MAC)
    482482    void insertDictatedTextAsync(const String& text, const EditingRange& replacementRange, const Vector<WebCore::TextAlternativeWithRange>& dictationAlternatives);
    483     void attributedSubstringForCharacterRangeAsync(const EditingRange&, PassRefPtr<AttributedStringForCharacterRangeCallback>);
     483    void attributedSubstringForCharacterRangeAsync(const EditingRange&, std::function<void (const AttributedString&, const EditingRange&, CallbackBase::Error)>);
    484484
    485485#if !USE(ASYNC_NSTEXTINPUTCLIENT)
    … …  
    658658    void getContentsAsMHTMLData(PassRefPtr<DataCallback>, bool useBinaryEncoding);
    659659#endif
    660     void getMainResourceDataOfFrame(WebFrameProxy*, PassRefPtr<DataCallback>);
    661     void getResourceDataFromFrame(WebFrameProxy*, API::URL*, PassRefPtr<DataCallback>);
     660    void getMainResourceDataOfFrame(WebFrameProxy*, std::function<void (API::Data*, CallbackBase::Error)>);
     661    void getResourceDataFromFrame(WebFrameProxy*, API::URL*, std::function<void (API::Data*, CallbackBase::Error)>);
    662662    void getRenderTreeExternalRepresentation(PassRefPtr<StringCallback>);
    663663    void getSelectionOrContentsAsString(PassRefPtr<StringCallback>);
    664664    void getSelectionAsWebArchiveData(PassRefPtr<DataCallback>);
    665665    void getSourceForFrame(WebFrameProxy*, PassRefPtr<StringCallback>);
    666     void getWebArchiveOfFrame(WebFrameProxy*, PassRefPtr<DataCallback>);
     666    void getWebArchiveOfFrame(WebFrameProxy*, std::function<void (API::Data*, CallbackBase::Error)>);
    667667    void runJavaScriptInMainFrame(const String&, PassRefPtr<ScriptValueCallback>);
    668668    void forceRepaint(PassRefPtr<VoidCallback>);

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebResourceCacheManagerProxy.cpp

    r169990 r170000  
    8989}
    9090
    91 void WebResourceCacheManagerProxy::getCacheOrigins(PassRefPtr<ArrayCallback> prpCallback)
     91void WebResourceCacheManagerProxy::getCacheOrigins(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    9292{
    93     RefPtr<ArrayCallback> callback = prpCallback;
     93    RefPtr<ArrayCallback> callback = ArrayCallback::create(std::move(callbackFunction));
    9494    uint64_t callbackID = callback->callbackID();
    9595    m_arrayCallbacks.set(callbackID, callback.release());

  • TabularUnified trunk/Source/WebKit2/UIProcess/WebResourceCacheManagerProxy.h

    r164409 r170000  
    5252    virtual ~WebResourceCacheManagerProxy();
    5353
    54     void getCacheOrigins(PassRefPtr<ArrayCallback>);
     54    void getCacheOrigins(std::function<void (API::Array*, CallbackBase::Error)>);
    5555    void clearCacheForOrigin(WebSecurityOrigin*, ResourceCachesToClear);
    5656    void clearCacheForAllOrigins(ResourceCachesToClear);

  • TabularUnified trunk/Source/WebKit2/UIProcess/ios/WKContentViewInteraction.mm

    r169987 r170000  
    14301430{
    14311431    _usingGestureForSelection = YES;
    1432     _page->selectWithGesture(WebCore::IntPoint(point), CharacterGranularity, static_cast<uint32_t>(toGestureType(gestureType)), static_cast<uint32_t>(toGestureRecognizerState(state)), GestureCallback::create([self, state](const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags, CallbackBase::Error error) {
     1432    _page->selectWithGesture(WebCore::IntPoint(point), CharacterGranularity, static_cast<uint32_t>(toGestureType(gestureType)), static_cast<uint32_t>(toGestureRecognizerState(state)), [self, state](const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags, CallbackBase::Error error) {
    14331433        selectionChangedWithGesture(self, point, gestureType, gestureState, flags, error);
    14341434        if (state == UIGestureRecognizerStateEnded || state == UIGestureRecognizerStateCancelled)
    14351435            _usingGestureForSelection = NO;
    1436     }));
     1436    });
    14371437}
    14381438
    … …  
    14501450{
    14511451    _usingGestureForSelection = YES;
    1452     _page->selectWithTwoTouches(WebCore::IntPoint(from), WebCore::IntPoint(to), static_cast<uint32_t>(toGestureType(gestureType)), static_cast<uint32_t>(toGestureRecognizerState(gestureState)), GestureCallback::create([self, gestureState](const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags, CallbackBase::Error error) {
     1452    _page->selectWithTwoTouches(WebCore::IntPoint(from), WebCore::IntPoint(to), static_cast<uint32_t>(toGestureType(gestureType)), static_cast<uint32_t>(toGestureRecognizerState(gestureState)), [self, gestureState](const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags, CallbackBase::Error error) {
    14531453        selectionChangedWithGesture(self, point, gestureType, gestureState, flags, error);
    14541454        if (gestureState == UIGestureRecognizerStateEnded || gestureState == UIGestureRecognizerStateCancelled)
    14551455            _usingGestureForSelection = NO;
    1456     }));
     1456    });
    14571457}
    14581458

  • TabularUnified trunk/Source/WebKit2/UIProcess/ios/WebPageProxyIOS.mm

    r169791 r170000  
    304304}
    305305
    306 void WebPageProxy::selectWithGesture(const WebCore::IntPoint point, WebCore::TextGranularity granularity, uint32_t gestureType, uint32_t gestureState, PassRefPtr<GestureCallback> callback)
    307 {
     306void WebPageProxy::selectWithGesture(const WebCore::IntPoint point, WebCore::TextGranularity granularity, uint32_t gestureType, uint32_t gestureState, std::function<void (const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, CallbackBase::Error)> callbackFunction)
     307{
     308    RefPtr<GestureCallback> callback = GestureCallback::create(std::move(callbackFunction));
     309
    308310    if (!isValid()) {
    309311        callback->invalidate();
    … …  
    398400}
    399401
    400 void WebPageProxy::selectWithTwoTouches(const WebCore::IntPoint from, const WebCore::IntPoint to, uint32_t gestureType, uint32_t gestureState, PassRefPtr<GestureCallback> callback)
    401 {
     402void WebPageProxy::selectWithTwoTouches(const WebCore::IntPoint from, const WebCore::IntPoint to, uint32_t gestureType, uint32_t gestureState, std::function<void (const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, CallbackBase::Error)> callbackFunction)
     403{
     404    RefPtr<GestureCallback> callback = GestureCallback::create(std::move(callbackFunction));
     405
    402406    if (!isValid()) {
    403407        callback->invalidate();

  • TabularUnified trunk/Source/WebKit2/UIProcess/mac/WebPageProxyMac.mm

    r169170 r170000  
    326326}
    327327
    328 void WebPageProxy::attributedSubstringForCharacterRangeAsync(const EditingRange& range, PassRefPtr<AttributedStringForCharacterRangeCallback> callback)
    329 {
     328void WebPageProxy::attributedSubstringForCharacterRangeAsync(const EditingRange& range, std::function<void (const AttributedString&, const EditingRange&, CallbackBase::Error)> callbackFunction)
     329{
     330    RefPtr<AttributedStringForCharacterRangeCallback> callback = AttributedStringForCharacterRangeCallback::create(std::move(callbackFunction));
     331
    330332    if (!isValid()) {
    331333        callback->invalidate();
Note: See TracChangeset for help on using the changeset viewer.