Changeset 164409 in webkit


Ignore:
Timestamp:
Feb 19, 2014, 7:21:41 PM (11 years ago)
Author:
ap@apple.com
Message:

[WK2] IPC callback classes should not be tightly coupled to C API
​https://bugs.webkit.org/show_bug.cgi?id=129030

Reviewed by Anders Carlsson.

Changed CallbackBase subclasses to take an std::function (with context captured inside).
Instead of C API objects, these callback functions take implementation ones.
There are VoidAPICallback and GenericAPICallback helpers for the common case of C API.

  • Shared/SecurityOriginData.h:
  • 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/WKPage.cpp:

(WKPageRunJavaScriptInMainFrame):
(WKPageRenderTreeExternalRepresentation):
(WKPageGetSourceForFrame):
(WKPageGetContentsAsString):
(WKPageGetSelectionAsWebArchiveData):
(WKPageGetContentsAsMHTMLData):
(WKPageForceRepaint):
(WKPageValidateCommand):
(WKPageComputePagesForPrinting):
(WKPageDrawPagesToPDF):

  • UIProcess/API/C/WKPluginSiteDataManager.cpp:

(WKPluginSiteDataManagerGetSitesWithData):
(WKPluginSiteDataManagerClearSiteData):
(WKPluginSiteDataManagerClearAllSiteData):

  • UIProcess/API/C/WKResourceCacheManager.cpp:

(WKResourceCacheManagerGetCacheOrigins):

  • UIProcess/API/gtk/WebKitCookieManager.cpp:

(webkit_cookie_manager_get_accept_policy):
(webkit_cookie_manager_get_domains_with_cookies):

  • UIProcess/API/gtk/WebKitPrintOperation.cpp:

(drawPagesForPrintingCompleted):
(webkitPrintOperationPrintPagesForFrame):

  • UIProcess/API/gtk/WebKitWebResource.cpp:

(resourceDataCallback):
(webkit_web_resource_get_data):

  • UIProcess/API/gtk/WebKitWebView.cpp:

(webkit_web_view_can_execute_editing_command):
(webkitWebViewRunJavaScriptCallback):
(webkit_web_view_run_javascript):
(resourcesStreamReadCallback):
(getContentsAsMHTMLDataCallback):
(webkit_web_view_save):
(webkit_web_view_save_to_file):

  • UIProcess/API/ios/WKInteractionView.mm:

(-[WKInteractionView _define:]):
(selectionChangedWithGesture):
(selectionChangedWithTouch):
(-[WKInteractionView changeSelectionWithGestureAt:withGesture:withState:]):
(-[WKInteractionView changeSelectionWithTouchAt:withSelectionTouch:baseIsStart:]):
(-[WKInteractionView changeSelectionWithTouchesFrom:to:withGesture:withState:]):
(-[WKInteractionView requestAutocorrectionRectsForString:withCompletionHandler:]):
(-[WKInteractionView applyAutocorrection:toString:withCompletionHandler:]):
(-[WKInteractionView requestAutocorrectionContextWithCompletionHandler:]):

  • UIProcess/API/mac/WKPrintingView.mm:

(pageDidDrawToImage):
(-[WKPrintingView _preparePDFDataForPrintingOnSecondaryThread]):
(pageDidComputePageRects):
(-[WKPrintingView _askPageToComputePageRects]):
(-[WKPrintingView _drawPreview:]):

  • UIProcess/API/mac/WKView.mm:

(-[WKView validateUserInterfaceItem:]):
(-[WKView startSpeaking:]):

  • UIProcess/AutoCorrectionCallback.h:

(WebKit::AutocorrectionDataCallback::create):
(WebKit::AutocorrectionDataCallback::performCallbackWithReturnValue):
(WebKit::AutocorrectionDataCallback::invalidate):
(WebKit::AutocorrectionDataCallback::AutocorrectionDataCallback):
(WebKit::AutocorrectionContextCallback::create):
(WebKit::AutocorrectionContextCallback::performCallbackWithReturnValue):
(WebKit::AutocorrectionContextCallback::invalidate):
(WebKit::AutocorrectionContextCallback::AutocorrectionContextCallback):

  • UIProcess/GenericCallback.h:

(WebKit::CallbackBase::CallbackBase):
(WebKit::CallbackBase::generateCallbackID):
(WebKit::VoidCallback::create):
(WebKit::VoidCallback::performCallback):
(WebKit::VoidCallback::invalidate):
(WebKit::VoidCallback::VoidCallback):
(WebKit::VoidAPICallback::create):
(WebKit::GenericCallback::create):
(WebKit::GenericCallback::performCallbackWithReturnValue):
(WebKit::GenericCallback::invalidate):
(WebKit::GenericCallback::GenericCallback):
(WebKit::GenericAPICallback::create):
(WebKit::ComputedPagesCallback::create):
(WebKit::ComputedPagesCallback::performCallbackWithReturnValue):
(WebKit::ComputedPagesCallback::invalidate):
(WebKit::ComputedPagesCallback::ComputedPagesCallback):
(WebKit::ImageCallback::create):
(WebKit::ImageCallback::performCallbackWithReturnValue):
(WebKit::ImageCallback::invalidate):
(WebKit::ImageCallback::ImageCallback):

  • UIProcess/Plugins/WebPluginSiteDataManager.h:
  • UIProcess/StatisticsRequest.h:
  • UIProcess/WebApplicationCacheManagerProxy.h:
  • UIProcess/WebContext.h:
  • UIProcess/WebCookieManagerProxy.h:
  • UIProcess/WebDatabaseManagerProxy.h:
  • UIProcess/WebFrameProxy.h:
  • UIProcess/WebKeyValueStorageManager.h:
  • UIProcess/WebMediaCacheManagerProxy.h:
  • UIProcess/WebOriginDataManagerProxy.h:
  • UIProcess/WebPageProxy.h:

(WebKit::ValidateCommandCallback::create):
(WebKit::ValidateCommandCallback::performCallbackWithReturnValue):
(WebKit::ValidateCommandCallback::invalidate):
(WebKit::ValidateCommandCallback::ValidateCommandCallback):
(WebKit::GestureCallback::create):
(WebKit::GestureCallback::performCallbackWithReturnValue):
(WebKit::GestureCallback::invalidate):
(WebKit::GestureCallback::GestureCallback):
(WebKit::TouchesCallback::create):
(WebKit::TouchesCallback::performCallbackWithReturnValue):
(WebKit::TouchesCallback::invalidate):
(WebKit::TouchesCallback::TouchesCallback):

  • UIProcess/WebResourceCacheManagerProxy.h:
  • UIProcess/mac/WKFullScreenWindowController.mm:

(-[WKFullScreenWindowController finishedExitFullScreenAnimation:]):

Location:
trunk/Source/WebKit2
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r164406 r164409  
     12014-02-18  Alexey Proskuryakov  <ap@apple.com>
     2
     3        [WK2] IPC callback classes should not be tightly coupled to C API
     4        https://bugs.webkit.org/show_bug.cgi?id=129030
     5
     6        Reviewed by Anders Carlsson.
     7
     8        Changed CallbackBase subclasses to take an std::function (with context captured inside).
     9        Instead of C API objects, these callback functions take implementation ones.
     10        There are VoidAPICallback and GenericAPICallback helpers for the common case of C API.
     11
     12        * Shared/SecurityOriginData.h:
     13        * UIProcess/API/C/WKApplicationCacheManager.cpp:
     14        (WKApplicationCacheManagerGetApplicationCacheOrigins):
     15        * UIProcess/API/C/WKContext.cpp:
     16        (WKContextGetStatistics):
     17        (WKContextGetStatisticsWithOptions):
     18        * UIProcess/API/C/WKCookieManager.cpp:
     19        (WKCookieManagerGetHostnamesWithCookies):
     20        (WKCookieManagerGetHTTPCookieAcceptPolicy):
     21        * UIProcess/API/C/WKDatabaseManager.cpp:
     22        (WKDatabaseManagerGetDatabasesByOrigin):
     23        (WKDatabaseManagerGetDatabaseOrigins):
     24        * UIProcess/API/C/WKFrame.cpp:
     25        (WKFrameGetMainResourceData):
     26        (WKFrameGetResourceData):
     27        (WKFrameGetWebArchive):
     28        * UIProcess/API/C/WKKeyValueStorageManager.cpp:
     29        (WKKeyValueStorageManagerGetKeyValueStorageOrigins):
     30        (WKKeyValueStorageManagerGetStorageDetailsByOrigin):
     31        * UIProcess/API/C/WKMediaCacheManager.cpp:
     32        (WKMediaCacheManagerGetHostnamesWithMediaCache):
     33        * UIProcess/API/C/WKOriginDataManager.cpp:
     34        (WKOriginDataManagerGetOrigins):
     35        * UIProcess/API/C/WKPage.cpp:
     36        (WKPageRunJavaScriptInMainFrame):
     37        (WKPageRenderTreeExternalRepresentation):
     38        (WKPageGetSourceForFrame):
     39        (WKPageGetContentsAsString):
     40        (WKPageGetSelectionAsWebArchiveData):
     41        (WKPageGetContentsAsMHTMLData):
     42        (WKPageForceRepaint):
     43        (WKPageValidateCommand):
     44        (WKPageComputePagesForPrinting):
     45        (WKPageDrawPagesToPDF):
     46        * UIProcess/API/C/WKPluginSiteDataManager.cpp:
     47        (WKPluginSiteDataManagerGetSitesWithData):
     48        (WKPluginSiteDataManagerClearSiteData):
     49        (WKPluginSiteDataManagerClearAllSiteData):
     50        * UIProcess/API/C/WKResourceCacheManager.cpp:
     51        (WKResourceCacheManagerGetCacheOrigins):
     52        * UIProcess/API/gtk/WebKitCookieManager.cpp:
     53        (webkit_cookie_manager_get_accept_policy):
     54        (webkit_cookie_manager_get_domains_with_cookies):
     55        * UIProcess/API/gtk/WebKitPrintOperation.cpp:
     56        (drawPagesForPrintingCompleted):
     57        (webkitPrintOperationPrintPagesForFrame):
     58        * UIProcess/API/gtk/WebKitWebResource.cpp:
     59        (resourceDataCallback):
     60        (webkit_web_resource_get_data):
     61        * UIProcess/API/gtk/WebKitWebView.cpp:
     62        (webkit_web_view_can_execute_editing_command):
     63        (webkitWebViewRunJavaScriptCallback):
     64        (webkit_web_view_run_javascript):
     65        (resourcesStreamReadCallback):
     66        (getContentsAsMHTMLDataCallback):
     67        (webkit_web_view_save):
     68        (webkit_web_view_save_to_file):
     69        * UIProcess/API/ios/WKInteractionView.mm:
     70        (-[WKInteractionView _define:]):
     71        (selectionChangedWithGesture):
     72        (selectionChangedWithTouch):
     73        (-[WKInteractionView changeSelectionWithGestureAt:withGesture:withState:]):
     74        (-[WKInteractionView changeSelectionWithTouchAt:withSelectionTouch:baseIsStart:]):
     75        (-[WKInteractionView changeSelectionWithTouchesFrom:to:withGesture:withState:]):
     76        (-[WKInteractionView requestAutocorrectionRectsForString:withCompletionHandler:]):
     77        (-[WKInteractionView applyAutocorrection:toString:withCompletionHandler:]):
     78        (-[WKInteractionView requestAutocorrectionContextWithCompletionHandler:]):
     79        * UIProcess/API/mac/WKPrintingView.mm:
     80        (pageDidDrawToImage):
     81        (-[WKPrintingView _preparePDFDataForPrintingOnSecondaryThread]):
     82        (pageDidComputePageRects):
     83        (-[WKPrintingView _askPageToComputePageRects]):
     84        (-[WKPrintingView _drawPreview:]):
     85        * UIProcess/API/mac/WKView.mm:
     86        (-[WKView validateUserInterfaceItem:]):
     87        (-[WKView startSpeaking:]):
     88        * UIProcess/AutoCorrectionCallback.h:
     89        (WebKit::AutocorrectionDataCallback::create):
     90        (WebKit::AutocorrectionDataCallback::performCallbackWithReturnValue):
     91        (WebKit::AutocorrectionDataCallback::invalidate):
     92        (WebKit::AutocorrectionDataCallback::AutocorrectionDataCallback):
     93        (WebKit::AutocorrectionContextCallback::create):
     94        (WebKit::AutocorrectionContextCallback::performCallbackWithReturnValue):
     95        (WebKit::AutocorrectionContextCallback::invalidate):
     96        (WebKit::AutocorrectionContextCallback::AutocorrectionContextCallback):
     97        * UIProcess/GenericCallback.h:
     98        (WebKit::CallbackBase::CallbackBase):
     99        (WebKit::CallbackBase::generateCallbackID):
     100        (WebKit::VoidCallback::create):
     101        (WebKit::VoidCallback::performCallback):
     102        (WebKit::VoidCallback::invalidate):
     103        (WebKit::VoidCallback::VoidCallback):
     104        (WebKit::VoidAPICallback::create):
     105        (WebKit::GenericCallback::create):
     106        (WebKit::GenericCallback::performCallbackWithReturnValue):
     107        (WebKit::GenericCallback::invalidate):
     108        (WebKit::GenericCallback::GenericCallback):
     109        (WebKit::GenericAPICallback::create):
     110        (WebKit::ComputedPagesCallback::create):
     111        (WebKit::ComputedPagesCallback::performCallbackWithReturnValue):
     112        (WebKit::ComputedPagesCallback::invalidate):
     113        (WebKit::ComputedPagesCallback::ComputedPagesCallback):
     114        (WebKit::ImageCallback::create):
     115        (WebKit::ImageCallback::performCallbackWithReturnValue):
     116        (WebKit::ImageCallback::invalidate):
     117        (WebKit::ImageCallback::ImageCallback):
     118        * UIProcess/Plugins/WebPluginSiteDataManager.h:
     119        * UIProcess/StatisticsRequest.h:
     120        * UIProcess/WebApplicationCacheManagerProxy.h:
     121        * UIProcess/WebContext.h:
     122        * UIProcess/WebCookieManagerProxy.h:
     123        * UIProcess/WebDatabaseManagerProxy.h:
     124        * UIProcess/WebFrameProxy.h:
     125        * UIProcess/WebKeyValueStorageManager.h:
     126        * UIProcess/WebMediaCacheManagerProxy.h:
     127        * UIProcess/WebOriginDataManagerProxy.h:
     128        * UIProcess/WebPageProxy.h:
     129        (WebKit::ValidateCommandCallback::create):
     130        (WebKit::ValidateCommandCallback::performCallbackWithReturnValue):
     131        (WebKit::ValidateCommandCallback::invalidate):
     132        (WebKit::ValidateCommandCallback::ValidateCommandCallback):
     133        (WebKit::GestureCallback::create):
     134        (WebKit::GestureCallback::performCallbackWithReturnValue):
     135        (WebKit::GestureCallback::invalidate):
     136        (WebKit::GestureCallback::GestureCallback):
     137        (WebKit::TouchesCallback::create):
     138        (WebKit::TouchesCallback::performCallbackWithReturnValue):
     139        (WebKit::TouchesCallback::invalidate):
     140        (WebKit::TouchesCallback::TouchesCallback):
     141        * UIProcess/WebResourceCacheManagerProxy.h:
     142        * UIProcess/mac/WKFullScreenWindowController.mm:
     143        (-[WKFullScreenWindowController finishedExitFullScreenAnimation:]):
     144
    11452014-02-19  Simon Fraser  <simon.fraser@apple.com>
    2146

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

    r161148 r164409  
    3838namespace WebKit {
    3939
    40 typedef GenericCallback<WKArrayRef> ArrayCallback;
     40typedef GenericCallback<API::Array*> ArrayCallback;
    4141
    4242struct SecurityOriginData {

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

    r95901 r164409  
    3232using namespace WebKit;
    3333
     34typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     35
    3436WKTypeID WKApplicationCacheManagerGetTypeID()
    3537{
    … …  
    3941void WKApplicationCacheManagerGetApplicationCacheOrigins(WKApplicationCacheManagerRef applicationCacheManagerRef, void* context, WKApplicationCacheManagerGetApplicationCacheOriginsFunction callback)
    4042{
    41     toImpl(applicationCacheManagerRef)->getApplicationCacheOrigins(ArrayCallback::create(context, callback));
     43    toImpl(applicationCacheManagerRef)->getApplicationCacheOrigins(ArrayAPICallback::create(context, callback));
    4244}
    4345

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

    r164230 r164409  
    6464using namespace WebKit;
    6565
     66typedef GenericAPICallback<WKDictionaryRef> DictionaryAPICallback;
     67
    6668WKTypeID WKContextGetTypeID()
    6769{
    … …  
    417419void WKContextGetStatistics(WKContextRef contextRef, void* context, WKContextGetStatisticsFunction callback)
    418420{
    419     toImpl(contextRef)->getStatistics(0xFFFFFFFF, DictionaryCallback::create(context, callback));
     421    toImpl(contextRef)->getStatistics(0xFFFFFFFF, DictionaryAPICallback::create(context, callback));
    420422}
    421423
    422424void WKContextGetStatisticsWithOptions(WKContextRef contextRef, WKStatisticsOptions optionsMask, void* context, WKContextGetStatisticsFunction callback)
    423425{
    424     toImpl(contextRef)->getStatistics(optionsMask, DictionaryCallback::create(context, callback));
     426    toImpl(contextRef)->getStatistics(optionsMask, DictionaryAPICallback::create(context, callback));
    425427}
    426428

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

    r164272 r164409  
    3232using namespace WebKit;
    3333
     34typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     35typedef GenericAPICallback<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy> HTTPCookieAcceptPolicyAPICallback;
     36
    3437WKTypeID WKCookieManagerGetTypeID()
    3538{
    … …  
    4447void WKCookieManagerGetHostnamesWithCookies(WKCookieManagerRef cookieManagerRef, void* context, WKCookieManagerGetCookieHostnamesFunction callback)
    4548{
    46     toImpl(cookieManagerRef)->getHostnamesWithCookies(ArrayCallback::create(context, callback));
     49    toImpl(cookieManagerRef)->getHostnamesWithCookies(ArrayAPICallback::create(context, callback));
    4750}
    4851
    … …  
    6972void WKCookieManagerGetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, void* context, WKCookieManagerGetHTTPCookieAcceptPolicyFunction callback)
    7073{
    71     toImpl(cookieManager)->getHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicyCallback::create(context, callback));
     74    toImpl(cookieManager)->getHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicyAPICallback::create(context, callback));
    7275}
    7376

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

    r162943 r164409  
    3232using namespace WebKit;
    3333
     34typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     35
    3436WKTypeID WKDatabaseManagerGetTypeID()
    3537{
    … …  
    156158{
    157159#if ENABLE(SQL_DATABASE)
    158     toImpl(databaseManagerRef)->getDatabasesByOrigin(ArrayCallback::create(context, callback));
     160    toImpl(databaseManagerRef)->getDatabasesByOrigin(ArrayAPICallback::create(context, callback));
    159161#else
    160162    UNUSED_PARAM(databaseManagerRef);
    … …  
    167169{
    168170#if ENABLE(SQL_DATABASE)
    169     toImpl(databaseManagerRef)->getDatabaseOrigins(ArrayCallback::create(context, callback));
     171    toImpl(databaseManagerRef)->getDatabaseOrigins(ArrayAPICallback::create(context, callback));
    170172#else
    171173    UNUSED_PARAM(databaseManagerRef);

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

    r159439 r164409  
    3131
    3232using namespace WebKit;
     33
     34typedef GenericAPICallback<WKDataRef> DataAPICallback;
    3335
    3436WKTypeID WKFrameGetTypeID()
    … …  
    125127void WKFrameGetMainResourceData(WKFrameRef frameRef, WKFrameGetResourceDataFunction callback, void* context)
    126128{
    127     toImpl(frameRef)->getMainResourceData(DataCallback::create(context, callback));
     129    toImpl(frameRef)->getMainResourceData(DataAPICallback::create(context, callback));
    128130}
    129131
    130132void WKFrameGetResourceData(WKFrameRef frameRef, WKURLRef resourceURL, WKFrameGetResourceDataFunction callback, void* context)
    131133{
    132     toImpl(frameRef)->getResourceData(toImpl(resourceURL), DataCallback::create(context, callback));
     134    toImpl(frameRef)->getResourceData(toImpl(resourceURL), DataAPICallback::create(context, callback));
    133135}
    134136
    135137void WKFrameGetWebArchive(WKFrameRef frameRef, WKFrameGetWebArchiveFunction callback, void* context)
    136138{
    137     toImpl(frameRef)->getWebArchive(DataCallback::create(context, callback));
     139    toImpl(frameRef)->getWebArchive(DataAPICallback::create(context, callback));
    138140}
    139141

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

    r163212 r164409  
    3232using namespace WebKit;
    3333
     34typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     35
    3436WKTypeID WKKeyValueStorageManagerGetTypeID()
    3537{
    … …  
    5759void WKKeyValueStorageManagerGetKeyValueStorageOrigins(WKKeyValueStorageManagerRef keyValueStorageManagerRef, void* context, WKKeyValueStorageManagerGetKeyValueStorageOriginsFunction callback)
    5860{
    59     toImpl(keyValueStorageManagerRef)->getKeyValueStorageOrigins(ArrayCallback::create(context, callback));
     61    toImpl(keyValueStorageManagerRef)->getKeyValueStorageOrigins(ArrayAPICallback::create(context, callback));
    6062}
    6163
    6264void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerRef keyValueStorageManagerRef, void* context, WKKeyValueStorageManagerGetStorageDetailsByOriginFunction callback)
    6365{
    64     toImpl(keyValueStorageManagerRef)->getStorageDetailsByOrigin(ArrayCallback::create(context, callback));
     66    toImpl(keyValueStorageManagerRef)->getStorageDetailsByOrigin(ArrayAPICallback::create(context, callback));
    6567}
    6668

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

    r95901 r164409  
    3232using namespace WebKit;
    3333
     34typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     35
    3436WKTypeID WKMediaCacheManagerGetTypeID()
    3537{
    … …  
    3941void WKMediaCacheManagerGetHostnamesWithMediaCache(WKMediaCacheManagerRef mediaCacheManagerRef, void* context, WKMediaCacheManagerGetHostnamesWithMediaCacheFunction callback)
    4042{
    41     toImpl(mediaCacheManagerRef)->getHostnamesWithMediaCache(ArrayCallback::create(context, callback));
     43    toImpl(mediaCacheManagerRef)->getHostnamesWithMediaCache(ArrayAPICallback::create(context, callback));
    4244}
    4345

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

    r160104 r164409  
    3232using namespace WebKit;
    3333
     34typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     35
    3436WKTypeID WKOriginDataManagerGetTypeID()
    3537{
    … …  
    3941void WKOriginDataManagerGetOrigins(WKOriginDataManagerRef originDataManagerRef, WKOriginDataTypes types, void* context, WKOriginDataManagerGetOriginsFunction callback)
    4042{
    41     toImpl(originDataManagerRef)->getOrigins(types, ArrayCallback::create(context, callback));
     43    toImpl(originDataManagerRef)->getOrigins(types, ArrayAPICallback::create(context, callback));
    4244}
    4345

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

    r164398 r164409  
    7575}
    7676
     77typedef GenericAPICallback<WKDataRef> DataAPICallback;
     78typedef GenericAPICallback<WKStringRef, StringImpl*> StringAPICallback;
     79typedef GenericAPICallback<WKSerializedScriptValueRef> ScriptValueAPICallback;
     80
    7781WKTypeID WKPageGetTypeID()
    7882{
    … …  
    14731477void WKPageRunJavaScriptInMainFrame(WKPageRef pageRef, WKStringRef scriptRef, void* context, WKPageRunJavaScriptFunction callback)
    14741478{
    1475     toImpl(pageRef)->runJavaScriptInMainFrame(toImpl(scriptRef)->string(), ScriptValueCallback::create(context, callback));
     1479    toImpl(pageRef)->runJavaScriptInMainFrame(toImpl(scriptRef)->string(), ScriptValueAPICallback::create(context, callback));
    14761480}
    14771481
    … …  
    14921496void WKPageRenderTreeExternalRepresentation(WKPageRef pageRef, void* context, WKPageRenderTreeExternalRepresentationFunction callback)
    14931497{
    1494     toImpl(pageRef)->getRenderTreeExternalRepresentation(StringCallback::create(context, callback));
     1498    toImpl(pageRef)->getRenderTreeExternalRepresentation(StringAPICallback::create(context, callback));
    14951499}
    14961500
    14971501void WKPageGetSourceForFrame(WKPageRef pageRef, WKFrameRef frameRef, void* context, WKPageGetSourceForFrameFunction callback)
    14981502{
    1499     toImpl(pageRef)->getSourceForFrame(toImpl(frameRef), StringCallback::create(context, callback));
     1503    toImpl(pageRef)->getSourceForFrame(toImpl(frameRef), StringAPICallback::create(context, callback));
    15001504}
    15011505
    15021506void WKPageGetContentsAsString(WKPageRef pageRef, void* context, WKPageGetContentsAsStringFunction callback)
    15031507{
    1504     toImpl(pageRef)->getContentsAsString(StringCallback::create(context, callback));
     1508    toImpl(pageRef)->getContentsAsString(StringAPICallback::create(context, callback));
    15051509}
    15061510
    … …  
    15121516void WKPageGetSelectionAsWebArchiveData(WKPageRef pageRef, void* context, WKPageGetSelectionAsWebArchiveDataFunction callback)
    15131517{
    1514     toImpl(pageRef)->getSelectionAsWebArchiveData(DataCallback::create(context, callback));
     1518    toImpl(pageRef)->getSelectionAsWebArchiveData(DataAPICallback::create(context, callback));
    15151519}
    15161520
    … …  
    15181522{
    15191523#if ENABLE(MHTML)
    1520     toImpl(pageRef)->getContentsAsMHTMLData(DataCallback::create(context, callback), useBinaryEncoding);
     1524    toImpl(pageRef)->getContentsAsMHTMLData(DataAPICallback::create(context, callback), useBinaryEncoding);
    15211525#else
    15221526    UNUSED_PARAM(pageRef);
    … …  
    15291533void WKPageForceRepaint(WKPageRef pageRef, void* context, WKPageForceRepaintFunction callback)
    15301534{
    1531     toImpl(pageRef)->forceRepaint(VoidCallback::create(context, callback));
     1535    toImpl(pageRef)->forceRepaint(VoidAPICallback::create(context, callback));
    15321536}
    15331537
    … …  
    15641568void WKPageValidateCommand(WKPageRef pageRef, WKStringRef command, void* context, WKPageValidateCommandCallback callback)
    15651569{
    1566     toImpl(pageRef)->validateCommand(toImpl(command)->string(), ValidateCommandCallback::create(context, callback));
     1570    toImpl(pageRef)->validateCommand(toImpl(command)->string(), ValidateCommandCallback::create([context, callback](bool error, StringImpl* commandName, bool isEnabled, int32_t state) {
     1571        callback(toAPI(commandName), isEnabled, state, error ? toAPI(API::Error::create().get()) : 0, context);
     1572    }));
    15671573}
    15681574
    … …  
    15731579
    15741580#if PLATFORM(COCOA)
    1575 struct ComputedPagesContext {
    1576     ComputedPagesContext(WKPageComputePagesForPrintingFunction callback, void* context)
    1577         : callback(callback)
    1578         , context(context)
    1579     {
    1580     }
    1581     WKPageComputePagesForPrintingFunction callback;
    1582     void* context;
    1583 };
    1584 
    1585 static void computedPagesCallback(const Vector<WebCore::IntRect>& rects, double scaleFactor, WKErrorRef error, void* untypedContext)
    1586 {
    1587     OwnPtr<ComputedPagesContext> context = adoptPtr(static_cast<ComputedPagesContext*>(untypedContext));
    1588     Vector<WKRect> wkRects(rects.size());
    1589     for (size_t i = 0; i < rects.size(); ++i)
    1590         wkRects[i] = toAPI(rects[i]);
    1591     context->callback(wkRects.data(), wkRects.size(), scaleFactor, error, context->context);
    1592 }
    1593 
    15941581static PrintInfo printInfoFromWKPrintInfo(const WKPrintInfo& printInfo)
    15951582{
    … …  
    16031590void WKPageComputePagesForPrinting(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo, WKPageComputePagesForPrintingFunction callback, void* context)
    16041591{
    1605     toImpl(page)->computePagesForPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo), ComputedPagesCallback::create(new ComputedPagesContext(callback, context), computedPagesCallback));
     1592    toImpl(page)->computePagesForPrinting(toImpl(frame), printInfoFromWKPrintInfo(printInfo), ComputedPagesCallback::create([context, callback](bool error, const Vector<WebCore::IntRect>& rects, double scaleFactor) {
     1593        Vector<WKRect> wkRects(rects.size());
     1594        for (size_t i = 0; i < rects.size(); ++i)
     1595            wkRects[i] = toAPI(rects[i]);
     1596        callback(wkRects.data(), wkRects.size(), scaleFactor, error ? toAPI(API::Error::create().get()) : 0, context);
     1597    }));
    16061598}
    16071599
    … …  
    16131605void WKPageDrawPagesToPDF(WKPageRef page, WKFrameRef frame, WKPrintInfo printInfo, uint32_t first, uint32_t count, WKPageDrawToPDFFunction callback, void* context)
    16141606{
    1615     toImpl(page)->drawPagesToPDF(toImpl(frame), printInfoFromWKPrintInfo(printInfo), first, count, DataCallback::create(context, callback));
     1607    toImpl(page)->drawPagesToPDF(toImpl(frame), printInfoFromWKPrintInfo(printInfo), first, count, DataAPICallback::create(context, callback));
    16161608}
    16171609

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

    r159788 r164409  
    3737using namespace WebKit;
    3838
     39#if ENABLE(NETSCAPE_PLUGIN_API)
     40typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     41#endif
     42
    3943WKTypeID WKPluginSiteDataManagerGetTypeID()
    4044{
    … …  
    4953{
    5054#if ENABLE(NETSCAPE_PLUGIN_API)
    51     toImpl(managerRef)->getSitesWithData(ArrayCallback::create(context, callback));
     55    toImpl(managerRef)->getSitesWithData(ArrayAPICallback::create(context, callback));
    5256#else
    5357    UNUSED_PARAM(managerRef);
    … …  
    7377{
    7478#if ENABLE(NETSCAPE_PLUGIN_API)
    75     toImpl(managerRef)->clearSiteData(toImpl(sitesRef), toNPClearSiteDataFlags(flags), maxAgeInSeconds, VoidCallback::create(context, function));
     79    toImpl(managerRef)->clearSiteData(toImpl(sitesRef), toNPClearSiteDataFlags(flags), maxAgeInSeconds, VoidAPICallback::create(context, function));
    7680#else
    7781    UNUSED_PARAM(managerRef);
    … …  
    8791{
    8892#if ENABLE(NETSCAPE_PLUGIN_API)
    89     toImpl(managerRef)->clearSiteData(0, NP_CLEAR_ALL, std::numeric_limits<uint64_t>::max(), VoidCallback::create(context, function));
     93    toImpl(managerRef)->clearSiteData(0, NP_CLEAR_ALL, std::numeric_limits<uint64_t>::max(), VoidAPICallback::create(context, function));
    9094#else
    9195    UNUSED_PARAM(managerRef);

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

    r95901 r164409  
    3232using namespace WebKit;
    3333
     34typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     35
    3436WKTypeID WKResourceCacheManagerGetTypeID()
    3537{
    … …  
    3941void WKResourceCacheManagerGetCacheOrigins(WKResourceCacheManagerRef cacheManagerRef, void* context, WKResourceCacheManagerGetCacheOriginsFunction callback)
    4042{
    41     toImpl(cacheManagerRef)->getCacheOrigins(ArrayCallback::create(context, callback));
     43    toImpl(cacheManagerRef)->getCacheOrigins(ArrayAPICallback::create(context, callback));
    4244}
    4345

  • trunk/Source/WebKit2/UIProcess/API/gtk/WebKitCookieManager.cpp

    r160632 r164409  
    3030
    3131using namespace WebKit;
     32
     33typedef GenericAPICallback<WKArrayRef> ArrayAPICallback;
     34typedef GenericAPICallback<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy> HTTPCookieAcceptPolicyAPICallback;
    3235
    3336/**
    … …  
    176179
    177180    GTask* task = g_task_new(manager, cancellable, callback, userData);
    178     manager->priv->webCookieManager->getHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicyCallback::create(task, webkitCookieManagerGetAcceptPolicyCallback));
     181    manager->priv->webCookieManager->getHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicyAPICallback::create(task, webkitCookieManagerGetAcceptPolicyCallback));
    179182}
    180183
    … …  
    234237
    235238    GTask* task = g_task_new(manager, cancellable, callback, userData);
    236     manager->priv->webCookieManager->getHostnamesWithCookies(ArrayCallback::create(task, webkitCookieManagerGetDomainsWithCookiesCallback));
     239    manager->priv->webCookieManager->getHostnamesWithCookies(ArrayAPICallback::create(task, webkitCookieManagerGetDomainsWithCookiesCallback));
    237240}
    238241

  • trunk/Source/WebKit2/UIProcess/API/gtk/WebKitPrintOperation.cpp

    r162599 r164409  
    253253#endif
    254254
    255 static void drawPagesForPrintingCompleted(WKErrorRef wkPrintError, WKErrorRef, void* context)
    256 {
    257     GRefPtr<WebKitPrintOperation> printOperation = adoptGRef(WEBKIT_PRINT_OPERATION(context));
    258 
     255static void drawPagesForPrintingCompleted(API::Error* wkPrintError, WebKitPrintOperation* printOperation)
     256{
    259257    // When running synchronously WebPageProxy::printFrame() calls endPrinting().
    260258    if (printOperation->priv->printMode == PrintInfo::PrintModeAsync && printOperation->priv->webView) {
    … …  
    263261    }
    264262
    265     const WebCore::ResourceError& resourceError = wkPrintError ? toImpl(wkPrintError)->platformError() : WebCore::ResourceError();
     263    const WebCore::ResourceError& resourceError = wkPrintError ? wkPrintError->platformError() : WebCore::ResourceError();
    266264    if (!resourceError.isNull()) {
    267265        GUniquePtr<GError> printError(g_error_new_literal(g_quark_from_string(resourceError.domain().utf8().data()),
    268266            resourceError.errorCode(), resourceError.localizedDescription().utf8().data()));
    269         g_signal_emit(printOperation.get(), signals[FAILED], 0, printError.get());
    270     }
    271     g_signal_emit(printOperation.get(), signals[FINISHED], 0, NULL);
     267        g_signal_emit(printOperation, signals[FAILED], 0, printError.get());
     268    }
     269    g_signal_emit(printOperation, signals[FINISHED], 0, NULL);
    272270}
    273271
    … …  
    276274    PrintInfo printInfo(printSettings, pageSetup, printOperation->priv->printMode);
    277275    WebPageProxy* page = webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(printOperation->priv->webView));
    278     page->drawPagesForPrinting(webFrame, printInfo, PrintFinishedCallback::create(g_object_ref(printOperation), &drawPagesForPrintingCompleted));
     276    g_object_ref(printOperation);
     277    page->drawPagesForPrinting(webFrame, printInfo, PrintFinishedCallback::create([printOperation](bool /*error*/, API::Error* printError) {
     278        drawPagesForPrintingCompleted(printError, adoptGRef(printOperation).get());
     279    }));
    279280}
    280281

  • trunk/Source/WebKit2/UIProcess/API/gtk/WebKitWebResource.cpp

    r160974 r164409  
    315315WEBKIT_DEFINE_ASYNC_DATA_STRUCT(ResourceGetDataAsyncData)
    316316
    317 static void resourceDataCallback(WKDataRef wkData, WKErrorRef, void* context)
    318 {
    319     GRefPtr<GTask> task = adoptGRef(G_TASK(context));
    320     ResourceGetDataAsyncData* data = static_cast<ResourceGetDataAsyncData*>(g_task_get_task_data(task.get()));
    321     data->webData = toImpl(wkData);
    322     g_task_return_boolean(task.get(), TRUE);
     317static void resourceDataCallback(API::Data* wkData, GTask* task)
     318{
     319    ResourceGetDataAsyncData* data = static_cast<ResourceGetDataAsyncData*>(g_task_get_task_data(task));
     320    data->webData = wkData;
     321    g_task_return_boolean(task, TRUE);
    323322}
    324323
    … …  
    342341    g_task_set_task_data(task, createResourceGetDataAsyncData(), reinterpret_cast<GDestroyNotify>(destroyResourceGetDataAsyncData));
    343342    if (resource->priv->isMainResource)
    344         resource->priv->frame->getMainResourceData(DataCallback::create(task, resourceDataCallback));
     343        resource->priv->frame->getMainResourceData(DataCallback::create([task](bool /*error*/, API::Data* data) {
     344            resourceDataCallback(data, adoptGRef(task).get());
     345        }));
    345346    else {
    346347        String url = String::fromUTF8(resource->priv->uri.data());
    347         resource->priv->frame->getResourceData(API::URL::create(url).get(), DataCallback::create(task, resourceDataCallback));
     348        resource->priv->frame->getResourceData(API::URL::create(url).get(), DataCallback::create([task](bool /*error*/, API::Data* data) {
     349            resourceDataCallback(data, adoptGRef(task).get());
     350        }));
    348351    }
    349352}

  • trunk/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp

    r164235 r164409  
    25112511}
    25122512
    2513 static void didValidateCommand(WKStringRef command, bool isEnabled, int32_t state, WKErrorRef, void* context)
    2514 {
    2515     GRefPtr<GTask> task = adoptGRef(G_TASK(context));
    2516     g_task_return_boolean(task.get(), isEnabled);
    2517 }
    2518 
    25192513/**
    25202514 * webkit_web_view_can_execute_editing_command:
    … …  
    25362530
    25372531    GTask* task = g_task_new(webView, cancellable, callback, userData);
    2538     getPage(webView)->validateCommand(String::fromUTF8(command), ValidateCommandCallback::create(task, didValidateCommand));
     2532    getPage(webView)->validateCommand(String::fromUTF8(command), ValidateCommandCallback::create([task](bool /*error*/, StringImpl* /*command*/, bool isEnabled, int32_t /*state*/) {
     2533        g_task_return_boolean(adoptGRef(task).get(), isEnabled);       
     2534    }));
    25392535}
    25402536
    … …  
    26132609}
    26142610
    2615 static void webkitWebViewRunJavaScriptCallback(WKSerializedScriptValueRef wkSerializedScriptValue, WKErrorRef, void* context)
    2616 {
    2617     GRefPtr<GTask> task = adoptGRef(G_TASK(context));
    2618     if (g_task_return_error_if_cancelled(task.get()))
     2611static void webkitWebViewRunJavaScriptCallback(WebSerializedScriptValue* wkSerializedScriptValue, GTask* task)
     2612{
     2613    if (g_task_return_error_if_cancelled(task))
    26192614        return;
    26202615
    26212616    if (!wkSerializedScriptValue) {
    2622         g_task_return_new_error(task.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED,
     2617        g_task_return_new_error(task, WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED,
    26232618            _("An exception was raised in JavaScript"));
    26242619        return;
    26252620    }
    26262621
    2627     WebKitWebView* webView = WEBKIT_WEB_VIEW(g_task_get_source_object(task.get()));
    2628     g_task_return_pointer(task.get(), webkitJavascriptResultCreate(webView, toImpl(wkSerializedScriptValue)),
     2622    WebKitWebView* webView = WEBKIT_WEB_VIEW(g_task_get_source_object(task));
     2623    g_task_return_pointer(task, webkitJavascriptResultCreate(webView, wkSerializedScriptValue),
    26292624        reinterpret_cast<GDestroyNotify>(webkit_javascript_result_unref));
    26302625}
    … …  
    26502645
    26512646    GTask* task = g_task_new(webView, cancellable, callback, userData);
    2652     getPage(webView)->runJavaScriptInMainFrame(String::fromUTF8(script), ScriptValueCallback::create(task, webkitWebViewRunJavaScriptCallback));
     2647    getPage(webView)->runJavaScriptInMainFrame(String::fromUTF8(script), ScriptValueCallback::create([task](bool /*error*/, WebSerializedScriptValue* serializedScriptValue) {
     2648        webkitWebViewRunJavaScriptCallback(serializedScriptValue, adoptGRef(task).get());
     2649    }));
    26532650}
    26542651
    … …  
    27392736    gpointer outputStreamData = g_memory_output_stream_get_data(G_MEMORY_OUTPUT_STREAM(object));
    27402737    getPage(webView)->runJavaScriptInMainFrame(String::fromUTF8(reinterpret_cast<const gchar*>(outputStreamData)),
    2741         ScriptValueCallback::create(task.leakRef(), webkitWebViewRunJavaScriptCallback));
     2738        ScriptValueCallback::create([task](bool /*error*/, WebSerializedScriptValue* serializedScriptValue) {
     2739        webkitWebViewRunJavaScriptCallback(serializedScriptValue, task.get());
     2740    }));
    27422741}
    27432742
    … …  
    28662865}
    28672866
    2868 static void getContentsAsMHTMLDataCallback(WKDataRef wkData, WKErrorRef, void* context)
    2869 {
    2870     GRefPtr<GTask> task = adoptGRef(G_TASK(context));
     2867static void getContentsAsMHTMLDataCallback(API::Data* wkData, GTask* taskPtr)
     2868{
     2869    GRefPtr<GTask> task = adoptGRef(taskPtr);
    28712870    if (g_task_return_error_if_cancelled(task.get()))
    28722871        return;
    … …  
    28752874    // We need to retain the data until the asyncronous process
    28762875    // initiated by the user has finished completely.
    2877     data->webData = toImpl(wkData);
     2876    data->webData = wkData;
    28782877
    28792878    // If we are saving to a file we need to write the data on disk before finishing.
    … …  
    29152914    g_task_set_source_tag(task, reinterpret_cast<gpointer>(webkit_web_view_save));
    29162915    g_task_set_task_data(task, createViewSaveAsyncData(), reinterpret_cast<GDestroyNotify>(destroyViewSaveAsyncData));
    2917     getPage(webView)->getContentsAsMHTMLData(DataCallback::create(task, getContentsAsMHTMLDataCallback), false);
     2916    getPage(webView)->getContentsAsMHTMLData(DataCallback::create([task](bool /*error*/, API::Data* data) {
     2917        getContentsAsMHTMLDataCallback(data, task);
     2918    }), false);
    29182919}
    29192920
    … …  
    29782979    g_task_set_task_data(task, data, reinterpret_cast<GDestroyNotify>(destroyViewSaveAsyncData));
    29792980
    2980     getPage(webView)->getContentsAsMHTMLData(DataCallback::create(task, getContentsAsMHTMLDataCallback), false);
     2981    getPage(webView)->getContentsAsMHTMLData(DataCallback::create([task](bool /*error*/, API::Data* data) {
     2982        getContentsAsMHTMLDataCallback(data, task);
     2983    }), false);
    29812984}
    29822985

  • trunk/Source/WebKit2/UIProcess/API/ios/WKInteractionView.mm

    r163919 r164409  
    908908}
    909909
    910 static void selectedString(WKStringRef string, WKErrorRef error, void* context)
    911 {
    912     if (error)
    913         return;
    914     if (!string)
    915         return;
    916 
    917     NSString *convertedString = toImpl(string)->string();
    918     WKInteractionView* view = static_cast<WKInteractionView*>(context);
    919     ASSERT(view);
    920     [view _showDictionary:convertedString];
    921 }
    922 
    923910- (void)_define:(id)sender
    924911{
    925     _page->getSelectionOrContentsAsString(StringCallback::create(self, selectedString));
     912    _page->getSelectionOrContentsAsString(StringCallback::create([self](bool error, StringImpl* string) {
     913        if (error)
     914            return;
     915        if (!string)
     916            return;
     917
     918        NSString *convertedString = *string;
     919        [self _showDictionary:convertedString];
     920    }));
    926921}
    927922
    … …  
    10841079}
    10851080
    1086 static void selectionChangedWithGesture(const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags, WKErrorRef error, void* context)
     1081static void selectionChangedWithGesture(bool error, WKInteractionView *view, const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags)
    10871082{
    10881083    if (error) {
    … …  
    10901085        return;
    10911086    }
    1092     WKInteractionView *view = static_cast<WKInteractionView*>(context);
    1093     ASSERT(view);
    10941087    if ([view webSelectionAssistant])
    10951088        [(UIWKSelectionAssistant *)[view webSelectionAssistant] selectionChangedWithGestureAt:(CGPoint)point withGesture:toUIWKGestureType((WKGestureType)gestureType) withState:toUIGestureRecognizerState(static_cast<WKGestureRecognizerState>(gestureState)) withFlags:(toUIWKSelectionFlags((WKSelectionFlags)flags))];
    … …  
    10981091}
    10991092
    1100 static void selectionChangedWithTouch(const WebCore::IntPoint& point, uint32_t touch, WKErrorRef error, void* context)
     1093static void selectionChangedWithTouch(bool error, WKInteractionView *view, const WebCore::IntPoint& point, uint32_t touch)
    11011094{
    11021095    if (error) {
    … …  
    11041097        return;
    11051098    }
    1106     WKInteractionView *view = static_cast<WKInteractionView*>(context);
    1107     ASSERT(view);
    11081099    if ([view webSelectionAssistant])
    11091100        [(UIWKSelectionAssistant *)[view webSelectionAssistant] selectionChangedWithTouchAt:(CGPoint)point withSelectionTouch:toUIWKSelectionTouch((WKSelectionTouch)touch)];
    … …  
    11141105- (void)changeSelectionWithGestureAt:(CGPoint)point withGesture:(UIWKGestureType)gestureType withState:(UIGestureRecognizerState)state
    11151106{
    1116     _page->selectWithGesture(WebCore::IntPoint(point), CharacterGranularity, toWKGestureType(gestureType), toWKGestureRecognizerState(state), GestureCallback::create(self, selectionChangedWithGesture));
     1107    _page->selectWithGesture(WebCore::IntPoint(point), CharacterGranularity, toWKGestureType(gestureType), toWKGestureRecognizerState(state), GestureCallback::create([self](bool error, const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags) {
     1108        selectionChangedWithGesture(error, self, point, gestureType, gestureState, flags);
     1109    }));
    11171110}
    11181111
    11191112- (void)changeSelectionWithTouchAt:(CGPoint)point withSelectionTouch:(UIWKSelectionTouch)touch baseIsStart:(BOOL)baseIsStart
    11201113{
    1121     _page->updateSelectionWithTouches(WebCore::IntPoint(point), toWKSelectionTouch(touch), baseIsStart, TouchesCallback::create(self, selectionChangedWithTouch));
     1114    _page->updateSelectionWithTouches(WebCore::IntPoint(point), toWKSelectionTouch(touch), baseIsStart, TouchesCallback::create([self](bool error, const WebCore::IntPoint& point, uint32_t touch) {
     1115        selectionChangedWithTouch(error, self, point, touch);
     1116    }));
    11221117}
    11231118
    11241119- (void)changeSelectionWithTouchesFrom:(CGPoint)from to:(CGPoint)to withGesture:(UIWKGestureType)gestureType withState:(UIGestureRecognizerState)gestureState
    11251120{
    1126     _page->selectWithTwoTouches(WebCore::IntPoint(from), WebCore::IntPoint(to), toWKGestureType(gestureType), toWKGestureRecognizerState(gestureState), GestureCallback::create(self, selectionChangedWithGesture));
     1121    _page->selectWithTwoTouches(WebCore::IntPoint(from), WebCore::IntPoint(to), toWKGestureType(gestureType), toWKGestureRecognizerState(gestureState), GestureCallback::create([self](bool error, const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags) {
     1122        selectionChangedWithGesture(error, self, point, gestureType, gestureState, flags);
     1123    }));
    11271124}
    11281125
    … …  
    11301127{
    11311128    return &_autocorrectionData;
    1132 }
    1133 
    1134 static void autocorrectionData(const Vector<FloatRect>& rects, const String& fontName, double fontSize, uint64_t traits, WKErrorRef error, void* context)
    1135 {
    1136     WKInteractionView* view = static_cast<WKInteractionView*>(context);
    1137     ASSERT(view);
    1138     CGRect firstRect = CGRectZero;
    1139     CGRect lastRect = CGRectZero;
    1140     if (rects.size()) {
    1141         firstRect = rects[0];
    1142         lastRect = rects[rects.size() - 1];
    1143     }
    1144 
    1145     WKAutoCorrectionData *autocorrectionData = view.autocorrectionData;
    1146     autocorrectionData->fontName = fontName;
    1147     autocorrectionData->fontSize = fontSize;
    1148     autocorrectionData->fontTraits = traits;
    1149     autocorrectionData->textFirstRect = firstRect;
    1150     autocorrectionData->textLastRect = lastRect;
    1151 
    1152     autocorrectionData->autocorrectionHandler(rects.size() ? [WKAutocorrectionRects autocorrectionRectsWithRects:firstRect lastRect:lastRect] : nil);
    1153     [autocorrectionData->autocorrectionHandler release];
    1154     autocorrectionData->autocorrectionHandler = nil;
    11551129}
    11561130
    … …  
    11631137    }
    11641138    _autocorrectionData.autocorrectionHandler = [completionHandler copy];
    1165     _page->requestAutocorrectionData(input, AutocorrectionDataCallback::create(self, autocorrectionData));
     1139    _page->requestAutocorrectionData(input, AutocorrectionDataCallback::create([self, completionHandler](bool, const Vector<FloatRect>& rects, const String& fontName, double fontSize, uint64_t traits) {
     1140        CGRect firstRect = CGRectZero;
     1141        CGRect lastRect = CGRectZero;
     1142        if (rects.size()) {
     1143            firstRect = rects[0];
     1144            lastRect = rects[rects.size() - 1];
     1145        }
     1146
     1147        WKAutoCorrectionData *autocorrectionData = self.autocorrectionData;
     1148        autocorrectionData->fontName = fontName;
     1149        autocorrectionData->fontSize = fontSize;
     1150        autocorrectionData->fontTraits = traits;
     1151        autocorrectionData->textFirstRect = firstRect;
     1152        autocorrectionData->textLastRect = lastRect;
     1153
     1154        autocorrectionData->autocorrectionHandler(rects.size() ? [WKAutocorrectionRects autocorrectionRectsWithRects:firstRect lastRect:lastRect] : nil);
     1155        [autocorrectionData->autocorrectionHandler release];
     1156        autocorrectionData->autocorrectionHandler = nil;
     1157    }));
    11661158}
    11671159
    … …  
    11741166{
    11751167    return (_page->editorState().hasComposition) ? _page->editorState().lastMarkedRect : _autocorrectionData.textLastRect;
    1176 }
    1177 
    1178 static void autocorrectionResult(WKStringRef correction, WKErrorRef error, void* context)
    1179 {
    1180     WKInteractionView* view = static_cast<WKInteractionView*>(context);
    1181     ASSERT(view);
    1182     WKAutoCorrectionData *autocorrectionData = view.autocorrectionData;
    1183 
    1184     autocorrectionData->autocorrectionHandler(correction ? [WKAutocorrectionRects autocorrectionRectsWithRects:autocorrectionData->textFirstRect lastRect:autocorrectionData->textLastRect] : nil);
    1185     [autocorrectionData->autocorrectionHandler release];
    1186     autocorrectionData->autocorrectionHandler = nil;
    11871168}
    11881169
    … …  
    11911172{
    11921173    _autocorrectionData.autocorrectionHandler = [completionHandler copy];
    1193     _page->applyAutocorrection(correction, input, StringCallback::create(self, autocorrectionResult));
    1194 }
    1195 
    1196 static void autocorrectionContext(const String& beforeText, const String& markedText, const String& selectedText, const String& afterText, uint64_t location, uint64_t length, WKErrorRef error, void* context)
    1197 {
    1198     WKInteractionView* view = static_cast<WKInteractionView*>(context);
    1199     ASSERT(view);
    1200     WKAutoCorrectionData *autocorrectionData = view.autocorrectionData;
    1201     autocorrectionData->autocorrectionContextHandler([WKAutocorrectionContext autocorrectionContextWithData:beforeText markedText:markedText selectedText:selectedText afterText:afterText selectedRangeInMarkedText:NSMakeRange(location, length)]);
     1174    _page->applyAutocorrection(correction, input, StringCallback::create([self](bool /*error*/, StringImpl* string) {
     1175        WKAutoCorrectionData *autocorrectionData = self.autocorrectionData;
     1176
     1177        autocorrectionData->autocorrectionHandler(string ? [WKAutocorrectionRects autocorrectionRectsWithRects:autocorrectionData->textFirstRect lastRect:autocorrectionData->textLastRect] : nil);
     1178        [autocorrectionData->autocorrectionHandler release];
     1179        autocorrectionData->autocorrectionHandler = nil;
     1180    }));
    12021181}
    12031182
    … …  
    12181197    } else {
    12191198        _autocorrectionData.autocorrectionContextHandler = [completionHandler copy];
    1220         _page->requestAutocorrectionContext(AutocorrectionContextCallback::create(self, autocorrectionContext));
     1199        _page->requestAutocorrectionContext(AutocorrectionContextCallback::create([self, completionHandler](bool /*error*/, const String& beforeText, const String& markedText, const String& selectedText, const String& afterText, uint64_t location, uint64_t length) {
     1200            WKAutoCorrectionData *autocorrectionData = self.autocorrectionData;
     1201            autocorrectionData->autocorrectionContextHandler([WKAutocorrectionContext autocorrectionContextWithData:beforeText markedText:markedText selectedText:selectedText afterText:afterText selectedRangeInMarkedText:NSMakeRange(location, length)]);
     1202        }));
    12211203    }
    12221204}

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

    r162505 r164409  
    208208};
    209209
    210 static void pageDidDrawToImage(const ShareableBitmap::Handle& imageHandle, WKErrorRef, void* untypedContext)
    211 {
    212     ASSERT(RunLoop::isMain());
    213 
    214     OwnPtr<IPCCallbackContext> context = adoptPtr(static_cast<IPCCallbackContext*>(untypedContext));
     210static void pageDidDrawToImage(const ShareableBitmap::Handle& imageHandle, IPCCallbackContext* context)
     211{
     212    ASSERT(RunLoop::isMain());
     213
    215214    WKPrintingView *view = context->view.get();
    216215
    … …  
    237236}
    238237
    239 static void pageDidDrawToPDF(WKDataRef dataRef, WKErrorRef, void* untypedContext)
    240 {
    241     ASSERT(RunLoop::isMain());
    242 
    243     OwnPtr<IPCCallbackContext> context = adoptPtr(static_cast<IPCCallbackContext*>(untypedContext));
    244     WKPrintingView *view = context->view.get();
    245     API::Data* data = toImpl(dataRef);
    246 
    247     if (context->callbackID == view->_expectedPrintCallback) {
    248         ASSERT(![view _isPrintingPreview]);
    249         ASSERT(view->_printedPagesData.isEmpty());
    250         ASSERT(!view->_printedPagesPDFDocument);
    251         if (data)
    252             view->_printedPagesData.append(data->bytes(), data->size());
    253         view->_expectedPrintCallback = 0;
    254         view->_printingCallbackCondition.notify_one();
    255     }
    256 }
    257 
    258238- (void)_preparePDFDataForPrintingOnSecondaryThread
    259239{
    … …  
    284264
    285265    IPCCallbackContext* context = new IPCCallbackContext;
    286     RefPtr<DataCallback> callback = DataCallback::create(context, pageDidDrawToPDF);
     266    RefPtr<DataCallback> callback = DataCallback::create([context](bool, API::Data* data) {
     267        ASSERT(RunLoop::isMain());
     268
     269        OwnPtr<IPCCallbackContext> contextDeleter = adoptPtr(context);
     270        WKPrintingView *view = context->view.get();
     271
     272        if (context->callbackID == view->_expectedPrintCallback) {
     273            ASSERT(![view _isPrintingPreview]);
     274            ASSERT(view->_printedPagesData.isEmpty());
     275            ASSERT(!view->_printedPagesPDFDocument);
     276            if (data)
     277                view->_printedPagesData.append(data->bytes(), data->size());
     278            view->_expectedPrintCallback = 0;
     279            view->_printingCallbackCondition.notify_one();
     280        }
     281    });
    287282    _expectedPrintCallback = callback->callbackID();
    288283
    … …  
    293288}
    294289
    295 static void pageDidComputePageRects(const Vector<WebCore::IntRect>& pageRects, double totalScaleFactorForPrinting, WKErrorRef, void* untypedContext)
    296 {
    297     ASSERT(RunLoop::isMain());
    298 
    299     OwnPtr<IPCCallbackContext> context = adoptPtr(static_cast<IPCCallbackContext*>(untypedContext));
     290static void pageDidComputePageRects(const Vector<WebCore::IntRect>& pageRects, double totalScaleFactorForPrinting, IPCCallbackContext* context)
     291{
     292    ASSERT(RunLoop::isMain());
     293
    300294    WKPrintingView *view = context->view.get();
    301295
    … …  
    345339
    346340    IPCCallbackContext* context = new IPCCallbackContext;
    347     RefPtr<ComputedPagesCallback> callback = ComputedPagesCallback::create(context, pageDidComputePageRects);
     341    RefPtr<ComputedPagesCallback> callback = ComputedPagesCallback::create([context](bool, const Vector<WebCore::IntRect>& pageRects, double totalScaleFactorForPrinting) {
     342        OwnPtr<IPCCallbackContext> contextDeleter = adoptPtr(context);
     343        pageDidComputePageRects(pageRects, totalScaleFactorForPrinting, context);
     344    });
    348345    _expectedComputedPagesCallback = callback->callbackID();
    349346    context->view = self;
    … …  
    494491
    495492                IPCCallbackContext* context = new IPCCallbackContext;
    496                 RefPtr<ImageCallback> callback = ImageCallback::create(context, pageDidDrawToImage);
     493                RefPtr<ImageCallback> callback = ImageCallback::create([context](bool, const ShareableBitmap::Handle& imageHandle) {
     494                    OwnPtr<IPCCallbackContext> contextDeleter = adoptPtr(context);
     495                    pageDidDrawToImage(imageHandle, context);
     496                });
    497497                _latestExpectedPreviewCallback = callback->callbackID();
    498498                _expectedPreviewCallbacks.add(_latestExpectedPreviewCallback, scaledPrintingRect);

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

    r164345 r164409  
    729729}
    730730
    731 static void validateCommandCallback(WKStringRef commandName, bool isEnabled, int32_t state, WKErrorRef error, void* context)
    732 {
    733     // If the process exits before the command can be validated, we'll be called back with an error.
    734     if (error)
    735         return;
    736    
    737     WKView* wkView = static_cast<WKView*>(context);
    738     ASSERT(wkView);
    739    
    740     [wkView _setUserInterfaceItemState:nsStringFromWebCoreString(toImpl(commandName)->string()) enabled:isEnabled state:state];
    741 }
    742 
    743731- (BOOL)validateUserInterfaceItem:(id <NSValidatedUserInterfaceItem>)item
    744732{
    … …  
    832820        // FIXME: Theoretically, there is a race here; when we get the answer it might be old, from a previous time
    833821        // we asked for the same command; there is no guarantee the answer is still valid.
    834         _data->_page->validateCommand(commandName, ValidateCommandCallback::create(self, validateCommandCallback));
     822        _data->_page->validateCommand(commandName, ValidateCommandCallback::create([self](bool error, StringImpl* commandName, bool isEnabled, int32_t state) {
     823            // If the process exits before the command can be validated, we'll be called back with an error.
     824            if (error)
     825                return;
     826           
     827            [self _setUserInterfaceItemState:nsStringFromWebCoreString(commandName) enabled:isEnabled state:state];
     828        }));
    835829    }
    836830
    … …  
    841835}
    842836
    843 static void speakString(WKStringRef string, WKErrorRef error, void*)
    844 {
    845     if (error)
    846         return;
    847     if (!string)
    848         return;
    849 
    850     NSString *convertedString = toImpl(string)->string();
    851     [NSApp speakString:convertedString];
    852 }
    853 
    854837- (IBAction)startSpeaking:(id)sender
    855838{
    856     _data->_page->getSelectionOrContentsAsString(StringCallback::create(0, speakString));
     839    _data->_page->getSelectionOrContentsAsString(StringCallback::create([self](bool error, StringImpl* string) {
     840        if (error)
     841            return;
     842        if (!string)
     843            return;
     844
     845        [NSApp speakString:*string];
     846    }));
    857847}
    858848

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

    r161358 r164409  
    3838class AutocorrectionDataCallback : public CallbackBase {
    3939public:
    40     typedef void (*CallbackFunction)(const Vector<WebCore::FloatRect>&, const String&, double, uint64_t, WKErrorRef, void*);
     40    typedef std::function<void (bool, const Vector<WebCore::FloatRect>&, const String&, double, uint64_t)> CallbackFunction;
    4141
    42     static PassRefPtr<AutocorrectionDataCallback> create(void* context, CallbackFunction callback)
     42    static PassRefPtr<AutocorrectionDataCallback> create(CallbackFunction callback)
    4343    {
    44         return adoptRef(new AutocorrectionDataCallback(context, callback));
     44        return adoptRef(new AutocorrectionDataCallback(callback));
    4545    }
    4646
    … …  
    5454        ASSERT(m_callback);
    5555
    56         m_callback(returnValue1, returnValue2, returnValue3, returnValue4, 0, context());
     56        m_callback(false, returnValue1, returnValue2, returnValue3, returnValue4);
    5757
    5858        m_callback = 0;
    … …  
    6363        ASSERT(m_callback);
    6464
    65         RefPtr<API::Error> error = API::Error::create();
    66         m_callback(Vector<WebCore::FloatRect>(), String(), 0, 0, toAPI(error.get()), context());
     65        m_callback(true, Vector<WebCore::FloatRect>(), String(), 0, 0);
    6766
    6867        m_callback = 0;
    … …  
    7069
    7170private:
    72     AutocorrectionDataCallback(void* context, CallbackFunction callback)
    73         : CallbackBase(context)
    74         , m_callback(callback)
     71    AutocorrectionDataCallback(CallbackFunction callback)
     72        : m_callback(callback)
    7573    {
    7674        ASSERT(m_callback);
    … …  
    8280class AutocorrectionContextCallback : public CallbackBase {
    8381public:
    84     typedef void (*CallbackFunction)(const String&, const String&, const String&, const String&, uint64_t, uint64_t, WKErrorRef, void*);
     82    typedef std::function<void (bool, const String&, const String&, const String&, const String&, uint64_t, uint64_t)> CallbackFunction;
    8583
    86     static PassRefPtr<AutocorrectionContextCallback> create(void* context, CallbackFunction callback)
     84    static PassRefPtr<AutocorrectionContextCallback> create(CallbackFunction callback)
    8785    {
    88         return adoptRef(new AutocorrectionContextCallback(context, callback));
     86        return adoptRef(new AutocorrectionContextCallback(callback));
    8987    }
    9088
    … …  
    9896        ASSERT(m_callback);
    9997
    100         m_callback(returnValue1, returnValue2, returnValue3, returnValue4, returnValue5, returnValue6, 0, context());
     98        m_callback(false, returnValue1, returnValue2, returnValue3, returnValue4, returnValue5, returnValue6);
    10199
    102100        m_callback = 0;
    … …  
    107105        ASSERT(m_callback);
    108106
    109         RefPtr<API::Error> error = API::Error::create();
    110         m_callback(String(), String(), String(), String(), 0, 0, toAPI(error.get()), context());
     107        m_callback(true, String(), String(), String(), String(), 0, 0);
    111108
    112109        m_callback = 0;
    … …  
    114111
    115112private:
    116     AutocorrectionContextCallback(void* context, CallbackFunction callback)
    117         : CallbackBase(context)
    118         , m_callback(callback)
     113    AutocorrectionContextCallback(CallbackFunction callback)
     114        : m_callback(callback)
    119115    {
    120116        ASSERT(m_callback);

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

    r160971 r164409  
    3030#include "ShareableBitmap.h"
    3131#include "WKAPICast.h"
     32#include <functional>
    3233#include <wtf/HashMap.h>
     34#include <wtf/MainThread.h>
    3335#include <wtf/PassRefPtr.h>
    3436#include <wtf/RefCounted.h>
    … …  
    4547
    4648protected:
    47     explicit CallbackBase(void* context)
    48         : m_context(context)
    49         , m_callbackID(generateCallbackID())
    50     {
    51     }
    52 
    53     void* context() const { return m_context; }
     49    explicit CallbackBase()
     50        : m_callbackID(generateCallbackID())
     51    {
     52    }
    5453
    5554private:
    5655    static uint64_t generateCallbackID()
    5756    {
     57        ASSERT(isMainThread());
    5858        static uint64_t uniqueCallbackID = 1;
    5959        return uniqueCallbackID++;
    6060    }
    6161
    62     void* m_context;
    6362    uint64_t m_callbackID;
    6463};
    … …  
    6665class VoidCallback : public CallbackBase {
    6766public:
     67    typedef std::function<void (bool)> CallbackFunction;
     68
     69    static PassRefPtr<VoidCallback> create(CallbackFunction callback)
     70    {
     71        return adoptRef(new VoidCallback(callback));
     72    }
     73
     74    virtual ~VoidCallback()
     75    {
     76        ASSERT(!m_callback);
     77    }
     78
     79    void performCallback()
     80    {
     81        if (!m_callback)
     82            return;
     83
     84        m_callback(false);
     85
     86        m_callback = nullptr;
     87    }
     88   
     89    void invalidate()
     90    {
     91        if (!m_callback)
     92            return;
     93
     94        m_callback(true);
     95
     96        m_callback = nullptr;
     97    }
     98
     99private:
     100    VoidCallback(CallbackFunction callback)
     101        : m_callback(callback)
     102    {
     103    }
     104
     105    CallbackFunction m_callback;
     106};
     107
     108class VoidAPICallback : public CallbackBase {
     109public:
    68110    typedef void (*CallbackFunction)(WKErrorRef, void*);
    69111
    70112    static PassRefPtr<VoidCallback> create(void* context, CallbackFunction callback)
    71113    {
    72         return adoptRef(new VoidCallback(context, callback));
    73     }
    74 
    75     virtual ~VoidCallback()
    76     {
    77         ASSERT(!m_callback);
    78     }
    79 
    80     void performCallback()
    81     {
    82         if (!m_callback)
    83             return;
    84 
    85         m_callback(0, context());
    86 
    87         m_callback = 0;
    88     }
    89    
    90     void invalidate()
    91     {
    92         if (!m_callback)
    93             return;
    94 
    95         RefPtr<API::Error> error = API::Error::create();
    96         m_callback(toAPI(error.get()), context());
     114        return VoidCallback::create([context, callback](bool error) {
     115            callback(error ? toAPI(API::Error::create().get()) : 0, context);
     116        });
     117    }
     118};
     119
     120template<typename T>
     121class GenericCallback : public CallbackBase {
     122public:
     123    typedef std::function<void (bool, T)> CallbackFunction;
     124
     125    static PassRefPtr<GenericCallback> create(CallbackFunction callback)
     126    {
     127        return adoptRef(new GenericCallback(callback));
     128    }
     129
     130    virtual ~GenericCallback()
     131    {
     132        ASSERT(!m_callback);
     133    }
     134
     135    void performCallbackWithReturnValue(T returnValue)
     136    {
     137        if (!m_callback)
     138            return;
     139
     140        m_callback(false, returnValue);
     141
     142        m_callback = nullptr;
     143    }
     144   
     145    void invalidate()
     146    {
     147        if (!m_callback)
     148            return;
     149
     150        m_callback(true, T());
     151
     152        m_callback = nullptr;
     153    }
     154
     155private:
     156    GenericCallback(CallbackFunction callback)
     157        : m_callback(callback)
     158    {
     159    }
     160
     161    CallbackFunction m_callback;
     162};
     163
     164template<typename APIReturnValueType, typename InternalReturnValueType = typename APITypeInfo<APIReturnValueType>::ImplType>
     165class GenericAPICallback : public CallbackBase {
     166public:
     167    typedef void (*CallbackFunction)(APIReturnValueType, WKErrorRef, void*);
     168
     169    static PassRefPtr<GenericCallback<InternalReturnValueType>> create(void* context, CallbackFunction callback)
     170    {
     171        return GenericCallback<InternalReturnValueType>::create([context, callback](bool error, InternalReturnValueType returnValue) {
     172            callback(toAPI(returnValue), error ? toAPI(API::Error::create().get()) : 0, context);
     173        });
     174    }
     175};
     176
     177// FIXME: Make a version of GenericCallback with two arguments, and define ComputedPagesCallback as a specialization.
     178class ComputedPagesCallback : public CallbackBase {
     179public:
     180    typedef std::function<void (bool, const Vector<WebCore::IntRect>&, double)> CallbackFunction;
     181
     182    static PassRefPtr<ComputedPagesCallback> create(CallbackFunction callback)
     183    {
     184        return adoptRef(new ComputedPagesCallback(callback));
     185    }
     186
     187    virtual ~ComputedPagesCallback()
     188    {
     189        ASSERT(!m_callback);
     190    }
     191
     192    void performCallbackWithReturnValue(const Vector<WebCore::IntRect>& returnValue1, double returnValue2)
     193    {
     194        ASSERT(m_callback);
     195
     196        m_callback(false, returnValue1, returnValue2);
     197
     198        m_callback = 0;
     199    }
     200   
     201    void invalidate()
     202    {
     203        ASSERT(m_callback);
     204
     205        m_callback(true, Vector<WebCore::IntRect>(), 0);
    97206       
    98207        m_callback = 0;
    … …  
    100209
    101210private:
    102     VoidCallback(void* context, CallbackFunction callback)
    103         : CallbackBase(context)
    104         , m_callback(callback)
    105     {
    106     }
    107 
    108     CallbackFunction m_callback;
    109 };
    110 
    111 template<typename APIReturnValueType, typename InternalReturnValueType = typename APITypeInfo<APIReturnValueType>::ImplType>
    112 class GenericCallback : public CallbackBase {
    113 public:
    114     typedef void (*CallbackFunction)(APIReturnValueType, WKErrorRef, void*);
    115 
    116     static PassRefPtr<GenericCallback> create(void* context, CallbackFunction callback)
    117     {
    118         return adoptRef(new GenericCallback(context, callback));
    119     }
    120 
    121     virtual ~GenericCallback()
    122     {
    123         ASSERT(!m_callback);
    124     }
    125 
    126     void performCallbackWithReturnValue(InternalReturnValueType returnValue)
    127     {
    128         ASSERT(m_callback);
    129 
    130         m_callback(toAPI(returnValue), 0, context());
    131 
    132         m_callback = 0;
    133     }
    134    
    135     void invalidate()
    136     {
    137         ASSERT(m_callback);
    138 
    139         RefPtr<API::Error> error = API::Error::create();
    140         m_callback(0, toAPI(error.get()), context());
    141        
    142         m_callback = 0;
    143     }
    144 
    145 private:
    146     GenericCallback(void* context, CallbackFunction callback)
    147         : CallbackBase(context)
    148         , m_callback(callback)
    149     {
    150     }
    151 
    152     CallbackFunction m_callback;
    153 };
    154 
    155 // FIXME: Make a version of CallbackBase with two arguments, and define ComputedPagesCallback as a specialization.
    156 class ComputedPagesCallback : public CallbackBase {
    157 public:
    158     typedef void (*CallbackFunction)(const Vector<WebCore::IntRect>&, double, WKErrorRef, void*);
    159 
    160     static PassRefPtr<ComputedPagesCallback> create(void* context, CallbackFunction callback)
    161     {
    162         return adoptRef(new ComputedPagesCallback(context, callback));
    163     }
    164 
    165     virtual ~ComputedPagesCallback()
    166     {
    167         ASSERT(!m_callback);
    168     }
    169 
    170     void performCallbackWithReturnValue(const Vector<WebCore::IntRect>& returnValue1, double returnValue2)
    171     {
    172         ASSERT(m_callback);
    173 
    174         m_callback(returnValue1, returnValue2, 0, context());
    175 
    176         m_callback = 0;
    177     }
    178    
    179     void invalidate()
    180     {
    181         ASSERT(m_callback);
    182 
    183         RefPtr<API::Error> error = API::Error::create();
    184         m_callback(Vector<WebCore::IntRect>(), 0, toAPI(error.get()), context());
    185        
    186         m_callback = 0;
    187     }
    188 
    189 private:
    190 
    191     ComputedPagesCallback(void* context, CallbackFunction callback)
    192         : CallbackBase(context)
    193         , m_callback(callback)
     211
     212    ComputedPagesCallback(CallbackFunction callback)
     213        : m_callback(callback)
    194214    {
    195215    }
    … …  
    200220class ImageCallback : public CallbackBase {
    201221public:
    202     typedef void (*CallbackFunction)(const ShareableBitmap::Handle&, WKErrorRef, void*);
    203 
    204     static PassRefPtr<ImageCallback> create(void* context, CallbackFunction callback)
    205     {
    206         return adoptRef(new ImageCallback(context, callback));
     222    typedef std::function<void (bool, const ShareableBitmap::Handle&)> CallbackFunction;
     223
     224    static PassRefPtr<ImageCallback> create(CallbackFunction callback)
     225    {
     226        return adoptRef(new ImageCallback(callback));
    207227    }
    208228
    … …  
    216236        ASSERT(m_callback);
    217237
    218         m_callback(returnValue1, 0, context());
     238        m_callback(true, returnValue1);
    219239
    220240        m_callback = 0;
    … …  
    227247        RefPtr<API::Error> error = API::Error::create();
    228248        ShareableBitmap::Handle handle;
    229         m_callback(handle, toAPI(error.get()), context());
    230 
    231         m_callback = 0;
    232     }
    233 
    234 private:
    235 
    236     ImageCallback(void* context, CallbackFunction callback)
    237         : CallbackBase(context)
    238         , m_callback(callback)
     249        m_callback(false, handle);
     250
     251        m_callback = 0;
     252    }
     253
     254private:
     255
     256    ImageCallback(CallbackFunction callback)
     257        : m_callback(callback)
    239258    {
    240259    }

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

    r160384 r164409  
    4040class WebProcessProxy;
    4141
    42 typedef GenericCallback<WKArrayRef> ArrayCallback;
     42typedef GenericCallback<API::Array*> ArrayCallback;
    4343
    4444class WebPluginSiteDataManager : public API::ObjectImpl<API::Object::Type::PluginSiteDataManager> {

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

    r142651 r164409  
    3636struct StatisticsData;
    3737
    38 typedef GenericCallback<WKDictionaryRef> DictionaryCallback;
     38typedef GenericCallback<ImmutableDictionary*> DictionaryCallback;
    3939
    4040enum StatisticsRequestType {

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

    r162139 r164409  
    4444struct SecurityOriginData;
    4545
    46 typedef GenericCallback<WKArrayRef> ArrayCallback;
     46typedef GenericCallback<API::Array*> ArrayCallback;
    4747
    4848class WebApplicationCacheManagerProxy : public API::ObjectImpl<API::Object::Type::ApplicationCacheManager>, public WebContextSupplement, private IPC::MessageReceiver {

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

    r164358 r164409  
    8181struct WebProcessCreationParameters;
    8282   
    83 typedef GenericCallback<WKDictionaryRef> DictionaryCallback;
     83typedef GenericCallback<ImmutableDictionary*> DictionaryCallback;
    8484
    8585#if ENABLE(NETWORK_INFO)

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

    r164272 r164409  
    4949class WebProcessProxy;
    5050
    51 typedef GenericCallback<WKArrayRef> ArrayCallback;
    52 typedef GenericCallback<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy> HTTPCookieAcceptPolicyCallback;
     51typedef GenericCallback<API::Array*> ArrayCallback;
     52typedef GenericCallback<HTTPCookieAcceptPolicy> HTTPCookieAcceptPolicyCallback;
    5353
    5454class WebCookieManagerProxy : public API::ObjectImpl<API::Object::Type::CookieManager>, public WebContextSupplement, private IPC::MessageReceiver {

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

    r162943 r164409  
    4545class WebSecurityOrigin;
    4646
    47 typedef GenericCallback<WKArrayRef> ArrayCallback;
     47typedef GenericCallback<API::Array*> ArrayCallback;
    4848
    4949class WebDatabaseManagerProxy : public API::ObjectImpl<API::Object::Type::DatabaseManager>, public WebContextSupplement, private IPC::MessageReceiver {

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

    r161148 r164409  
    5151class WebPageProxy;
    5252
    53 typedef GenericCallback<WKDataRef> DataCallback;
     53typedef GenericCallback<API::Data*> DataCallback;
    5454
    5555class WebFrameProxy : public API::ObjectImpl<API::Object::Type::Frame> {

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

    r163212 r164409  
    3737namespace WebKit {
    3838
    39 typedef GenericCallback<WKArrayRef> ArrayCallback;
     39typedef GenericCallback<API::Array*> ArrayCallback;
    4040
    4141class WebKeyValueStorageManager : public API::ObjectImpl<API::Object::Type::KeyValueStorageManager>, public WebContextSupplement {

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

    r162139 r164409  
    4040class WebProcessProxy;
    4141
    42 typedef GenericCallback<WKArrayRef> ArrayCallback;
     42typedef GenericCallback<API::Array*> ArrayCallback;
    4343
    4444class WebMediaCacheManagerProxy : public API::ObjectImpl<API::Object::Type::MediaCacheManager>, public WebContextSupplement, private IPC::MessageReceiver {

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

    r162139 r164409  
    4646struct SecurityOriginData;
    4747
    48 typedef GenericCallback<WKArrayRef> ArrayCallback;
     48typedef GenericCallback<API::Array*> ArrayCallback;
    4949
    5050class WebOriginDataManagerProxy : public API::ObjectImpl<API::Object::Type::OriginDataManager>, public WebContextSupplement, private IPC::MessageReceiver {

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

    r164398 r164409  
    167167#endif
    168168
    169 typedef GenericCallback<WKStringRef, StringImpl*> StringCallback;
    170 typedef GenericCallback<WKSerializedScriptValueRef, WebSerializedScriptValue*> ScriptValueCallback;
     169typedef GenericCallback<StringImpl*> StringCallback;
     170typedef GenericCallback<WebSerializedScriptValue*> ScriptValueCallback;
    171171
    172172#if PLATFORM(GTK)
    173 typedef GenericCallback<WKErrorRef> PrintFinishedCallback;
     173typedef GenericCallback<API::Error*> PrintFinishedCallback;
    174174#endif
    175175
    … …  
    188188class ValidateCommandCallback : public CallbackBase {
    189189public:
    190     typedef void (*CallbackFunction)(WKStringRef, bool, int32_t, WKErrorRef, void*);
    191 
    192     static PassRefPtr<ValidateCommandCallback> create(void* context, CallbackFunction callback)
    193     {
    194         return adoptRef(new ValidateCommandCallback(context, callback));
     190    typedef std::function<void (bool, StringImpl*, bool, int32_t)> CallbackFunction;
     191
     192    static PassRefPtr<ValidateCommandCallback> create(CallbackFunction callback)
     193    {
     194        return adoptRef(new ValidateCommandCallback(callback));
    195195    }
    196196
    … …  
    204204        ASSERT(m_callback);
    205205
    206         m_callback(toAPI(returnValue1), returnValue2, returnValue3, 0, context());
     206        m_callback(false, returnValue1, returnValue2, returnValue3);
    207207
    208208        m_callback = 0;
    … …  
    213213        ASSERT(m_callback);
    214214
    215         RefPtr<API::Error> error = API::Error::create();
    216         m_callback(0, 0, 0, toAPI(error.get()), context());
     215        m_callback(true, 0, 0, 0);
    217216       
    218217        m_callback = 0;
    … …  
    221220private:
    222221
    223     ValidateCommandCallback(void* context, CallbackFunction callback)
    224         : CallbackBase(context)
    225         , m_callback(callback)
     222    ValidateCommandCallback(CallbackFunction callback)
     223        : m_callback(callback)
    226224    {
    227225    }
    … …  
    233231class GestureCallback : public CallbackBase {
    234232public:
    235     typedef void (*CallbackFunction)(const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, WKErrorRef, void*);
    236 
    237     static PassRefPtr<GestureCallback> create(void* context, CallbackFunction callback)
    238     {
    239         return adoptRef(new GestureCallback(context, callback));
     233    typedef std::function<void (bool, const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t)> CallbackFunction;
     234
     235    static PassRefPtr<GestureCallback> create(CallbackFunction callback)
     236    {
     237        return adoptRef(new GestureCallback(callback));
    240238    }
    241239
    … …  
    249247        ASSERT(m_callback);
    250248
    251         m_callback(returnValue1, returnValue2, returnValue3, returnValue4, 0, context());
     249        m_callback(false, returnValue1, returnValue2, returnValue3, returnValue4);
    252250
    253251        m_callback = 0;
    … …  
    258256        ASSERT(m_callback);
    259257
    260         RefPtr<API::Error> error = API::Error::create();
    261         m_callback(WebCore::IntPoint(), 0, 0, 0, toAPI(error.get()), context());
     258        m_callback(true, WebCore::IntPoint(), 0, 0, 0);
    262259
    263260        m_callback = 0;
    … …  
    266263private:
    267264
    268     GestureCallback(void* context, CallbackFunction callback)
    269         : CallbackBase(context)
    270         , m_callback(callback)
     265    GestureCallback(CallbackFunction callback)
     266        : m_callback(callback)
    271267    {
    272268        ASSERT(m_callback);
    … …  
    278274class TouchesCallback : public CallbackBase {
    279275public:
    280     typedef void (*CallbackFunction)(const WebCore::IntPoint&, uint32_t, WKErrorRef, void*);
    281 
    282     static PassRefPtr<TouchesCallback> create(void* context, CallbackFunction callback)
    283     {
    284         return adoptRef(new TouchesCallback(context, callback));
     276    typedef std::function<void(bool, const WebCore::IntPoint&, uint32_t)> CallbackFunction;
     277
     278    static PassRefPtr<TouchesCallback> create(CallbackFunction callback)
     279    {
     280        return adoptRef(new TouchesCallback(callback));
    285281    }
    286282
    … …  
    294290        ASSERT(m_callback);
    295291
    296         m_callback(returnValue1, returnValue2, 0, context());
     292        m_callback(true, returnValue1, returnValue2);
    297293
    298294        m_callback = 0;
    … …  
    304300
    305301        RefPtr<API::Error> error = API::Error::create();
    306         m_callback(WebCore::IntPoint(), 0, toAPI(error.get()), context());
     302        m_callback(false, WebCore::IntPoint(), 0);
    307303       
    308304        m_callback = 0;
    … …  
    311307private:
    312308   
    313     TouchesCallback(void* context, CallbackFunction callback)
    314         : CallbackBase(context)
    315         , m_callback(callback)
     309    TouchesCallback(CallbackFunction callback)
     310        : m_callback(callback)
    316311    {
    317312        ASSERT(m_callback);

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

    r162139 r164409  
    4343class WebSecurityOrigin;
    4444
    45 typedef GenericCallback<WKArrayRef> ArrayCallback;
     45typedef GenericCallback<API::Array*> ArrayCallback;
    4646
    4747class WebResourceCacheManagerProxy : public API::ObjectImpl<API::Object::Type::CacheManager>, public WebContextSupplement, private IPC::MessageReceiver {

  • trunk/Source/WebKit2/UIProcess/mac/WKFullScreenWindowController.mm

    r162505 r164409  
    368368}
    369369
    370 static void completeFinishExitFullScreenAnimationAfterRepaint(WKErrorRef, void*);
    371 
    372370- (void)finishedExitFullScreenAnimation:(bool)completed
    373371{
    … …  
    412410        ASSERT(!_repaintCallback);
    413411    }
    414     _repaintCallback = VoidCallback::create(self, completeFinishExitFullScreenAnimationAfterRepaint);
     412    _repaintCallback = VoidCallback::create([self](bool) {
     413        [self completeFinishExitFullScreenAnimationAfterRepaint];
     414    });
    415415    [self _page]->forceRepaint(_repaintCallback);
    416416}
    … …  
    422422    [[_webView window] displayIfNeeded];
    423423    NSEnableScreenUpdates();
    424 }
    425 
    426 static void completeFinishExitFullScreenAnimationAfterRepaint(WKErrorRef, void* _self)
    427 {
    428     [(WKFullScreenWindowController*)_self completeFinishExitFullScreenAnimationAfterRepaint];
    429424}
    430425
Note: See TracChangeset for help on using the changeset viewer.