Changeset 170041 in webkit


Ignore:
Timestamp:
Jun 16, 2014 8:52:21 PM (10 years ago)
Author:
mitz@apple.com
Message:

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

Reviewed by Sam Weinig.

  • UIProcess/API/C/WKPage.cpp:

(WKPageRunJavaScriptInMainFrame):
(WKPageRenderTreeExternalRepresentation):
(WKPageGetSourceForFrame):
(WKPageGetContentsAsString):
(WKPageGetBytecodeProfile):
(WKPageGetSelectionAsWebArchiveData):
(WKPageValidateCommand):

  • UIProcess/API/C/WKPluginSiteDataManager.cpp:

(WKPluginSiteDataManagerClearSiteData):
(WKPluginSiteDataManagerClearAllSiteData):

  • UIProcess/API/Cocoa/WKWebView.mm:

(-[WKWebView evaluateJavaScript:completionHandler:]):

  • UIProcess/API/mac/WKView.mm:

(-[WKView validateUserInterfaceItem:]):
(-[WKView startSpeaking:]):
(-[WKView selectedRangeWithCompletionHandler:]):
(-[WKView markedRangeWithCompletionHandler:]):
(-[WKView hasMarkedTextWithCompletionHandler:]):
(-[WKView firstRectForCharacterRange:completionHandler:]):
(-[WKView characterIndexForPoint:completionHandler:]):

  • UIProcess/Plugins/WebPluginSiteDataManager.cpp:

(WebKit::WebPluginSiteDataManager::clearSiteData):

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

(WebKit::WebPageProxy::validateCommand):
(WebKit::WebPageProxy::runJavaScriptInMainFrame):
(WebKit::WebPageProxy::getRenderTreeExternalRepresentation):
(WebKit::WebPageProxy::getSourceForFrame):
(WebKit::WebPageProxy::getContentsAsString):
(WebKit::WebPageProxy::getBytecodeProfile):
(WebKit::WebPageProxy::getContentsAsMHTMLData):
(WebKit::WebPageProxy::getSelectionOrContentsAsString):
(WebKit::WebPageProxy::getSelectionAsWebArchiveData):
(WebKit::WebPageProxy::getMarkedRangeAsync):
(WebKit::WebPageProxy::getSelectedRangeAsync):
(WebKit::WebPageProxy::characterIndexForPointAsync):
(WebKit::WebPageProxy::firstRectForCharacterRangeAsync):
(WebKit::WebPageProxy::takeSnapshot):

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

(-[WKContentView _define:]):
(-[WKContentView changeSelectionWithTouchAt:withSelectionTouch:baseIsStart:]):
(-[WKContentView requestAutocorrectionRectsForString:withCompletionHandler:]):
(-[WKContentView requestDictationContext:]):
(-[WKContentView applyAutocorrection:toString:withCompletionHandler:]):
(-[WKContentView requestAutocorrectionContextWithCompletionHandler:]):

  • UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::updateSelectionWithTouches):
(WebKit::WebPageProxy::requestAutocorrectionData):
(WebKit::WebPageProxy::applyAutocorrection):
(WebKit::WebPageProxy::requestDictationContext):
(WebKit::WebPageProxy::requestAutocorrectionContext):

Location:
trunk/Source/WebKit2
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r170038 r170041  
     12014-06-16  Dan Bernstein  <mitz@apple.com>
     2
     3        Part 2 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/WKPage.cpp:
     9        (WKPageRunJavaScriptInMainFrame):
     10        (WKPageRenderTreeExternalRepresentation):
     11        (WKPageGetSourceForFrame):
     12        (WKPageGetContentsAsString):
     13        (WKPageGetBytecodeProfile):
     14        (WKPageGetSelectionAsWebArchiveData):
     15        (WKPageValidateCommand):
     16        * UIProcess/API/C/WKPluginSiteDataManager.cpp:
     17        (WKPluginSiteDataManagerClearSiteData):
     18        (WKPluginSiteDataManagerClearAllSiteData):
     19        * UIProcess/API/Cocoa/WKWebView.mm:
     20        (-[WKWebView evaluateJavaScript:completionHandler:]):
     21        * UIProcess/API/mac/WKView.mm:
     22        (-[WKView validateUserInterfaceItem:]):
     23        (-[WKView startSpeaking:]):
     24        (-[WKView selectedRangeWithCompletionHandler:]):
     25        (-[WKView markedRangeWithCompletionHandler:]):
     26        (-[WKView hasMarkedTextWithCompletionHandler:]):
     27        (-[WKView firstRectForCharacterRange:completionHandler:]):
     28        (-[WKView characterIndexForPoint:completionHandler:]):
     29        * UIProcess/Plugins/WebPluginSiteDataManager.cpp:
     30        (WebKit::WebPluginSiteDataManager::clearSiteData):
     31        * UIProcess/Plugins/WebPluginSiteDataManager.h:
     32        * UIProcess/WebPageProxy.cpp:
     33        (WebKit::WebPageProxy::validateCommand):
     34        (WebKit::WebPageProxy::runJavaScriptInMainFrame):
     35        (WebKit::WebPageProxy::getRenderTreeExternalRepresentation):
     36        (WebKit::WebPageProxy::getSourceForFrame):
     37        (WebKit::WebPageProxy::getContentsAsString):
     38        (WebKit::WebPageProxy::getBytecodeProfile):
     39        (WebKit::WebPageProxy::getContentsAsMHTMLData):
     40        (WebKit::WebPageProxy::getSelectionOrContentsAsString):
     41        (WebKit::WebPageProxy::getSelectionAsWebArchiveData):
     42        (WebKit::WebPageProxy::getMarkedRangeAsync):
     43        (WebKit::WebPageProxy::getSelectedRangeAsync):
     44        (WebKit::WebPageProxy::characterIndexForPointAsync):
     45        (WebKit::WebPageProxy::firstRectForCharacterRangeAsync):
     46        (WebKit::WebPageProxy::takeSnapshot):
     47        * UIProcess/WebPageProxy.h:
     48        * UIProcess/ios/WKContentViewInteraction.mm:
     49        (-[WKContentView _define:]):
     50        (-[WKContentView changeSelectionWithTouchAt:withSelectionTouch:baseIsStart:]):
     51        (-[WKContentView requestAutocorrectionRectsForString:withCompletionHandler:]):
     52        (-[WKContentView requestDictationContext:]):
     53        (-[WKContentView applyAutocorrection:toString:withCompletionHandler:]):
     54        (-[WKContentView requestAutocorrectionContextWithCompletionHandler:]):
     55        * UIProcess/ios/WebPageProxyIOS.mm:
     56        (WebKit::WebPageProxy::updateSelectionWithTouches):
     57        (WebKit::WebPageProxy::requestAutocorrectionData):
     58        (WebKit::WebPageProxy::applyAutocorrection):
     59        (WebKit::WebPageProxy::requestDictationContext):
     60        (WebKit::WebPageProxy::requestAutocorrectionContext):
     61
    1622014-06-16  Jaehun Lim  <ljaehun.lim@samsung.com>
    263
    … …  
    1762372014-06-15  Dan Bernstein  <mitz@apple.com>
    177238
    178         Part 1 of Change GenericCallback<> function parameters into std::function<>
     239        Part 1 of: Change GenericCallback<> function parameters into std::function<>
    179240        https://bugs.webkit.org/show_bug.cgi?id=133927
    180241

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

    r169994 r170041  
    15631563void WKPageRunJavaScriptInMainFrame(WKPageRef pageRef, WKStringRef scriptRef, void* context, WKPageRunJavaScriptFunction callback)
    15641564{
    1565     toImpl(pageRef)->runJavaScriptInMainFrame(toImpl(scriptRef)->string(), ScriptValueCallback::create(toGenericCallbackFunction(context, callback)));
     1565    toImpl(pageRef)->runJavaScriptInMainFrame(toImpl(scriptRef)->string(), toGenericCallbackFunction(context, callback));
    15661566}
    15671567
    … …  
    15751575void WKPageRenderTreeExternalRepresentation(WKPageRef pageRef, void* context, WKPageRenderTreeExternalRepresentationFunction callback)
    15761576{
    1577     toImpl(pageRef)->getRenderTreeExternalRepresentation(StringCallback::create(toGenericCallbackFunction(context, callback)));
     1577    toImpl(pageRef)->getRenderTreeExternalRepresentation(toGenericCallbackFunction(context, callback));
    15781578}
    15791579
    15801580void WKPageGetSourceForFrame(WKPageRef pageRef, WKFrameRef frameRef, void* context, WKPageGetSourceForFrameFunction callback)
    15811581{
    1582     toImpl(pageRef)->getSourceForFrame(toImpl(frameRef), StringCallback::create(toGenericCallbackFunction(context, callback)));
     1582    toImpl(pageRef)->getSourceForFrame(toImpl(frameRef), toGenericCallbackFunction(context, callback));
    15831583}
    15841584
    15851585void WKPageGetContentsAsString(WKPageRef pageRef, void* context, WKPageGetContentsAsStringFunction callback)
    15861586{
    1587     toImpl(pageRef)->getContentsAsString(StringCallback::create(toGenericCallbackFunction(context, callback)));
     1587    toImpl(pageRef)->getContentsAsString(toGenericCallbackFunction(context, callback));
    15881588}
    15891589
    15901590void WKPageGetBytecodeProfile(WKPageRef pageRef, void* context, WKPageGetBytecodeProfileFunction callback)
    15911591{
    1592     toImpl(pageRef)->getBytecodeProfile(StringCallback::create(toGenericCallbackFunction(context, callback)));
     1592    toImpl(pageRef)->getBytecodeProfile(toGenericCallbackFunction(context, callback));
    15931593}
    15941594
    15951595void WKPageGetSelectionAsWebArchiveData(WKPageRef pageRef, void* context, WKPageGetSelectionAsWebArchiveDataFunction callback)
    15961596{
    1597     toImpl(pageRef)->getSelectionAsWebArchiveData(DataCallback::create(toGenericCallbackFunction(context, callback)));
     1597    toImpl(pageRef)->getSelectionAsWebArchiveData(toGenericCallbackFunction(context, callback));
    15981598}
    15991599
    … …  
    16491649void WKPageValidateCommand(WKPageRef pageRef, WKStringRef command, void* context, WKPageValidateCommandCallback callback)
    16501650{
    1651     toImpl(pageRef)->validateCommand(toImpl(command)->string(), ValidateCommandCallback::create([context, callback](const String& commandName, bool isEnabled, int32_t state, CallbackBase::Error error) {
     1651    toImpl(pageRef)->validateCommand(toImpl(command)->string(), [context, callback](const String& commandName, bool isEnabled, int32_t state, CallbackBase::Error error) {
    16521652        callback(toAPI(API::String::create(commandName).get()), isEnabled, state, error != CallbackBase::Error::None ? toAPI(API::Error::create().get()) : 0, context);
    1653     }));
     1653    });
    16541654}
    16551655

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

    r170002 r170041  
    7676{
    7777#if ENABLE(NETSCAPE_PLUGIN_API)
    78     toImpl(managerRef)->clearSiteData(toImpl(sitesRef), toNPClearSiteDataFlags(flags), maxAgeInSeconds, VoidCallback::create([context, function](CallbackBase::Error error) {
     78    toImpl(managerRef)->clearSiteData(toImpl(sitesRef), toNPClearSiteDataFlags(flags), maxAgeInSeconds, [context, function](CallbackBase::Error error) {
    7979        function(error == CallbackBase::Error::None ? nullptr : toAPI(API::Error::create().get()), context);
    80     }));
     80    });
    8181#else
    8282    UNUSED_PARAM(managerRef);
    … …  
    9292{
    9393#if ENABLE(NETSCAPE_PLUGIN_API)
    94     toImpl(managerRef)->clearSiteData(0, NP_CLEAR_ALL, std::numeric_limits<uint64_t>::max(), VoidCallback::create([context, function](CallbackBase::Error error) {
     94    toImpl(managerRef)->clearSiteData(0, NP_CLEAR_ALL, std::numeric_limits<uint64_t>::max(), [context, function](CallbackBase::Error error) {
    9595        function(error == CallbackBase::Error::None ? nullptr : toAPI(API::Error::create().get()), context);
    96     }));
     96    });
    9797#else
    9898    UNUSED_PARAM(managerRef);

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

    r170000 r170041  
    493493    auto handler = adoptNS([completionHandler copy]);
    494494
    495     _page->runJavaScriptInMainFrame(javaScriptString, WebKit::ScriptValueCallback::create([handler](WebKit::WebSerializedScriptValue* serializedScriptValue, WebKit::ScriptValueCallback::Error errorCode) {
     495    _page->runJavaScriptInMainFrame(javaScriptString, [handler](WebKit::WebSerializedScriptValue* serializedScriptValue, WebKit::ScriptValueCallback::Error errorCode) {
    496496        if (!handler)
    497497            return;
    … …  
    525525
    526526        completionHandler([value toObject], nil);
    527     }));
     527    });
    528528}
    529529

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

    r170000 r170041  
    836836        // FIXME: Theoretically, there is a race here; when we get the answer it might be old, from a previous time
    837837        // we asked for the same command; there is no guarantee the answer is still valid.
    838         _data->_page->validateCommand(commandName, ValidateCommandCallback::create([self](const String& commandName, bool isEnabled, int32_t state, CallbackBase::Error error) {
     838        _data->_page->validateCommand(commandName, [self](const String& commandName, bool isEnabled, int32_t state, CallbackBase::Error error) {
    839839            // If the process exits before the command can be validated, we'll be called back with an error.
    840840            if (error != CallbackBase::Error::None)
    … …  
    842842           
    843843            [self _setUserInterfaceItemState:commandName enabled:isEnabled state:state];
    844         }));
     844        });
    845845    }
    846846
    … …  
    853853- (IBAction)startSpeaking:(id)sender
    854854{
    855     _data->_page->getSelectionOrContentsAsString(StringCallback::create([self](const String& string, CallbackBase::Error error) {
     855    _data->_page->getSelectionOrContentsAsString([self](const String& string, CallbackBase::Error error) {
    856856        if (error != CallbackBase::Error::None)
    857857            return;
    … …  
    860860
    861861        [NSApp speakString:string];
    862     }));
     862    });
    863863}
    864864
    … …  
    14651465
    14661466    LOG(TextInput, "selectedRange");
    1467     _data->_page->getSelectedRangeAsync(EditingRangeCallback::create([completionHandler](const EditingRange& editingRangeResult, CallbackBase::Error error) {
     1467    _data->_page->getSelectedRangeAsync([completionHandler](const EditingRange& editingRangeResult, CallbackBase::Error error) {
    14681468        void (^completionHandlerBlock)(NSRange) = (void (^)(NSRange))completionHandler.get();
    14691469        if (error != CallbackBase::Error::None) {
    … …  
    14781478            LOG(TextInput, "    -> selectedRange returned (%llu, %llu)", result.location, result.length);
    14791479        completionHandlerBlock(result);
    1480     }));
     1480    });
    14811481}
    14821482
    … …  
    14861486
    14871487    LOG(TextInput, "markedRange");
    1488     _data->_page->getMarkedRangeAsync(EditingRangeCallback::create([completionHandler](const EditingRange& editingRangeResult, CallbackBase::Error error) {
     1488    _data->_page->getMarkedRangeAsync([completionHandler](const EditingRange& editingRangeResult, CallbackBase::Error error) {
    14891489        void (^completionHandlerBlock)(NSRange) = (void (^)(NSRange))completionHandler.get();
    14901490        if (error != CallbackBase::Error::None) {
    … …  
    14991499            LOG(TextInput, "    -> markedRange returned (%llu, %llu)", result.location, result.length);
    15001500        completionHandlerBlock(result);
    1501     }));
     1501    });
    15021502}
    15031503
    … …  
    15071507
    15081508    LOG(TextInput, "hasMarkedText");
    1509     _data->_page->getMarkedRangeAsync(EditingRangeCallback::create([completionHandler](const EditingRange& editingRangeResult, CallbackBase::Error error) {
     1509    _data->_page->getMarkedRangeAsync([completionHandler](const EditingRange& editingRangeResult, CallbackBase::Error error) {
    15101510        void (^completionHandlerBlock)(BOOL) = (void (^)(BOOL))completionHandler.get();
    15111511        if (error != CallbackBase::Error::None) {
    … …  
    15171517        LOG(TextInput, "    -> hasMarkedText returned %u", hasMarkedText);
    15181518        completionHandlerBlock(hasMarkedText);
    1519     }));
     1519    });
    15201520}
    15211521
    … …  
    15551555    }
    15561556
    1557     _data->_page->firstRectForCharacterRangeAsync(theRange, RectForCharacterRangeCallback::create([self, completionHandler](const IntRect& rect, const EditingRange& actualRange, CallbackBase::Error error) {
     1557    _data->_page->firstRectForCharacterRangeAsync(theRange, [self, completionHandler](const IntRect& rect, const EditingRange& actualRange, CallbackBase::Error error) {
    15581558        void (^completionHandlerBlock)(NSRect, NSRange) = (void (^)(NSRect, NSRange))completionHandler.get();
    15591559        if (error != CallbackBase::Error::None) {
    … …  
    15681568        LOG(TextInput, "    -> firstRectForCharacterRange returned (%f, %f, %f, %f)", resultRect.origin.x, resultRect.origin.y, resultRect.size.width, resultRect.size.height);
    15691569        completionHandlerBlock(resultRect, actualRange);
    1570     }));
     1570    });
    15711571}
    15721572
    … …  
    15861586    thePoint = [self convertPoint:thePoint fromView:nil];  // the point is relative to the main frame
    15871587
    1588     _data->_page->characterIndexForPointAsync(IntPoint(thePoint), UnsignedCallback::create([completionHandler](uint64_t result, CallbackBase::Error error) {
     1588    _data->_page->characterIndexForPointAsync(IntPoint(thePoint), [completionHandler](uint64_t result, CallbackBase::Error error) {
    15891589        void (^completionHandlerBlock)(NSUInteger) = (void (^)(NSUInteger))completionHandler.get();
    15901590        if (error != CallbackBase::Error::None) {
    … …  
    15971597        LOG(TextInput, "    -> characterIndexForPoint returned %lu", result);
    15981598        completionHandlerBlock(result);
    1599     }));
     1599    });
    16001600}
    16011601

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

    r170000 r170041  
    169169}
    170170
    171 void WebPluginSiteDataManager::clearSiteData(API::Array* sites, uint64_t flags, uint64_t maxAgeInSeconds, PassRefPtr<VoidCallback> prpCallback)
    172 {
    173     RefPtr<VoidCallback> callback = prpCallback;
     171void WebPluginSiteDataManager::clearSiteData(API::Array* sites, uint64_t flags, uint64_t maxAgeInSeconds, std::function<void (CallbackBase::Error)> callbackFunction)
     172{
     173    RefPtr<VoidCallback> callback = VoidCallback::create(std::move(callbackFunction));
    174174    if (!m_webContext) {
    175175        // FIXME: If the context is invalid we should not call the callback. It'd be better to just return false from clearSiteData.

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

    r170000 r170041  
    5454    void didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID);
    5555
    56     void clearSiteData(API::Array* sites, uint64_t flags, uint64_t maxAgeInSeconds, PassRefPtr<VoidCallback>);
     56    void clearSiteData(API::Array* sites, uint64_t flags, uint64_t maxAgeInSeconds, std::function<void (CallbackBase::Error)>);
    5757    void didClearSiteData(uint64_t callbackID);
    5858

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

    r170000 r170041  
    12401240}
    12411241
    1242 void WebPageProxy::validateCommand(const String& commandName, PassRefPtr<ValidateCommandCallback> callback)
    1243 {
     1242void WebPageProxy::validateCommand(const String& commandName, std::function<void (const String&, bool, int32_t, CallbackBase::Error)> callbackFunction)
     1243{
     1244    RefPtr<ValidateCommandCallback> callback = ValidateCommandCallback::create(std::move(callbackFunction));
     1245
    12441246    if (!isValid()) {
    12451247        callback->invalidate();
    … …  
    21842186}
    21852187
    2186 void WebPageProxy::runJavaScriptInMainFrame(const String& script, PassRefPtr<ScriptValueCallback> prpCallback)
    2187 {
    2188     RefPtr<ScriptValueCallback> callback = prpCallback;
     2188void WebPageProxy::runJavaScriptInMainFrame(const String& script, std::function<void (WebSerializedScriptValue*, CallbackBase::Error)> callbackFunction)
     2189{
     2190    RefPtr<ScriptValueCallback> callback = ScriptValueCallback::create(std::move(callbackFunction));
    21892191    if (!isValid()) {
    21902192        callback->invalidate();
    … …  
    21972199}
    21982200
    2199 void WebPageProxy::getRenderTreeExternalRepresentation(PassRefPtr<StringCallback> prpCallback)
    2200 {
    2201     RefPtr<StringCallback> callback = prpCallback;
     2201void WebPageProxy::getRenderTreeExternalRepresentation(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
     2202{
     2203    RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22022204    if (!isValid()) {
    22032205        callback->invalidate();
    … …  
    22102212}
    22112213
    2212 void WebPageProxy::getSourceForFrame(WebFrameProxy* frame, PassRefPtr<StringCallback> prpCallback)
    2213 {
    2214     RefPtr<StringCallback> callback = prpCallback;
     2214void WebPageProxy::getSourceForFrame(WebFrameProxy* frame, std::function<void (const String&, CallbackBase::Error)> callbackFunction)
     2215{
     2216    RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22152217    if (!isValid()) {
    22162218        callback->invalidate();
    … …  
    22242226}
    22252227
    2226 void WebPageProxy::getContentsAsString(PassRefPtr<StringCallback> prpCallback)
    2227 {
    2228     RefPtr<StringCallback> callback = prpCallback;
     2228void WebPageProxy::getContentsAsString(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
     2229{
     2230    RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22292231    if (!isValid()) {
    22302232        callback->invalidate();
    … …  
    22382240}
    22392241
    2240 void WebPageProxy::getBytecodeProfile(PassRefPtr<StringCallback> prpCallback)
    2241 {
    2242     RefPtr<StringCallback> callback = prpCallback;
     2242void WebPageProxy::getBytecodeProfile(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
     2243{
     2244    RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22432245    if (!isValid()) {
    22442246        callback->invalidate();
    … …  
    22532255   
    22542256#if ENABLE(MHTML)
    2255 void WebPageProxy::getContentsAsMHTMLData(PassRefPtr<DataCallback> prpCallback, bool useBinaryEncoding)
    2256 {
    2257     RefPtr<DataCallback> callback = prpCallback;
     2257void WebPageProxy::getContentsAsMHTMLData(std::function<void (API::Data*, CallbackBase::Error)> callbackFunction, bool useBinaryEncoding)
     2258{
     2259    RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    22582260    if (!isValid()) {
    22592261        callback->invalidate();
    … …  
    22672269#endif
    22682270
    2269 void WebPageProxy::getSelectionOrContentsAsString(PassRefPtr<StringCallback> prpCallback)
    2270 {
    2271     RefPtr<StringCallback> callback = prpCallback;
     2271void WebPageProxy::getSelectionOrContentsAsString(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
     2272{
     2273    RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22722274    if (!isValid()) {
    22732275        callback->invalidate();
    … …  
    22802282}
    22812283
    2282 void WebPageProxy::getSelectionAsWebArchiveData(PassRefPtr<DataCallback> prpCallback)
    2283 {
    2284     RefPtr<DataCallback> callback = prpCallback;
     2284void WebPageProxy::getSelectionAsWebArchiveData(std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
     2285{
     2286    RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    22852287    if (!isValid()) {
    22862288        callback->invalidate();
    … …  
    49874989}
    49884990
    4989 void WebPageProxy::getMarkedRangeAsync(PassRefPtr<EditingRangeCallback> callback)
    4990 {
     4991void WebPageProxy::getMarkedRangeAsync(std::function<void (EditingRange, CallbackBase::Error)> callbackFunction)
     4992{
     4993    RefPtr<EditingRangeCallback> callback = EditingRangeCallback::create(std::move(callbackFunction));
     4994
    49914995    if (!isValid()) {
    49924996        callback->invalidate();
    … …  
    50005004}
    50015005
    5002 void WebPageProxy::getSelectedRangeAsync(PassRefPtr<EditingRangeCallback> callback)
    5003 {
     5006void WebPageProxy::getSelectedRangeAsync(std::function<void (EditingRange, CallbackBase::Error)> callbackFunction)
     5007{
     5008    RefPtr<EditingRangeCallback> callback = EditingRangeCallback::create(std::move(callbackFunction));
     5009
    50045010    if (!isValid()) {
    50055011        callback->invalidate();
    … …  
    50135019}
    50145020
    5015 void WebPageProxy::characterIndexForPointAsync(const WebCore::IntPoint& point, PassRefPtr<UnsignedCallback> callback)
    5016 {
     5021void WebPageProxy::characterIndexForPointAsync(const WebCore::IntPoint& point, std::function<void (uint64_t, CallbackBase::Error)> callbackFunction)
     5022{
     5023    RefPtr<UnsignedCallback> callback = UnsignedCallback::create(std::move(callbackFunction));
     5024
    50175025    if (!isValid()) {
    50185026        callback->invalidate();
    … …  
    50265034}
    50275035
    5028 void WebPageProxy::firstRectForCharacterRangeAsync(const EditingRange& range, PassRefPtr<RectForCharacterRangeCallback> callback)
    5029 {
     5036void WebPageProxy::firstRectForCharacterRangeAsync(const EditingRange& range, std::function<void (const WebCore::IntRect&, const EditingRange&, CallbackBase::Error)> callbackFunction)
     5037{
     5038    RefPtr<RectForCharacterRangeCallback> callback = RectForCharacterRangeCallback::create(std::move(callbackFunction));
     5039
    50305040    if (!isValid()) {
    50315041        callback->invalidate();
    … …  
    50605070#endif
    50615071
    5062 void WebPageProxy::takeSnapshot(IntRect rect, IntSize bitmapSize, SnapshotOptions options, ImageCallback::CallbackFunction callbackFunction)
    5063 {
    5064     RefPtr<ImageCallback> callback = ImageCallback::create(callbackFunction);
     5072void WebPageProxy::takeSnapshot(IntRect rect, IntSize bitmapSize, SnapshotOptions options, std::function<void (const ShareableBitmap::Handle&, CallbackBase::Error)> callbackFunction)
     5073{
     5074    RefPtr<ImageCallback> callback = ImageCallback::create(std::move(callbackFunction));
    50655075
    50665076    if (!isValid()) {

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

    r170000 r170041  
    376376
    377377    void executeEditCommand(const String& commandName);
    378     void validateCommand(const String& commandName, PassRefPtr<ValidateCommandCallback>);
     378    void validateCommand(const String& commandName, std::function<void (const String&, bool, int32_t, CallbackBase::Error)>);
    379379#if PLATFORM(IOS)
    380380    double displayedContentScale() const { return m_lastVisibleContentRectUpdate.scale(); }
    … …  
    399399
    400400    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)>);
    401     void updateSelectionWithTouches(const WebCore::IntPoint, uint32_t touches, bool baseIsStart, PassRefPtr<TouchesCallback>);
     401    void updateSelectionWithTouches(const WebCore::IntPoint, uint32_t touches, bool baseIsStart, std::function<void (const WebCore::IntPoint&, uint32_t, CallbackBase::Error)>);
    402402    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);
    405405    void selectWordBackward();
    406     void requestAutocorrectionData(const String& textForAutocorrection, PassRefPtr<AutocorrectionDataCallback>);
    407     void applyAutocorrection(const String& correction, const String& originalText, PassRefPtr<StringCallback>);
     406    void requestAutocorrectionData(const String& textForAutocorrection, std::function<void (const Vector<WebCore::FloatRect>&, const String&, double, uint64_t, CallbackBase::Error)>);
     407    void applyAutocorrection(const String& correction, const String& originalText, std::function<void (const String&, CallbackBase::Error)>);
    408408    bool applyAutocorrection(const String& correction, const String& originalText);
    409     void requestAutocorrectionContext(PassRefPtr<AutocorrectionContextCallback>);
     409    void requestAutocorrectionContext(std::function<void (const String&, const String&, const String&, const String&, uint64_t, uint64_t, CallbackBase::Error)>);
    410410    void getAutocorrectionContext(String& contextBefore, String& markedText, String& selectedText, String& contextAfter, uint64_t& location, uint64_t& length);
    411     void requestDictationContext(PassRefPtr<DictationContextCallback>);
     411    void requestDictationContext(std::function<void (const String&, const String&, const String&, CallbackBase::Error)>);
    412412    void replaceDictatedText(const String& oldText, const String& newText);
    413413    void replaceSelectedText(const String& oldText, const String& newText);
    … …  
    472472
    473473    void insertTextAsync(const String& text, const EditingRange& replacementRange);
    474     void getMarkedRangeAsync(PassRefPtr<EditingRangeCallback>);
    475     void getSelectedRangeAsync(PassRefPtr<EditingRangeCallback>);
    476     void characterIndexForPointAsync(const WebCore::IntPoint&, PassRefPtr<UnsignedCallback>);
    477     void firstRectForCharacterRangeAsync(const EditingRange&, PassRefPtr<RectForCharacterRangeCallback>);
     474    void getMarkedRangeAsync(std::function<void (EditingRange, CallbackBase::Error)>);
     475    void getSelectedRangeAsync(std::function<void (EditingRange, CallbackBase::Error)>);
     476    void characterIndexForPointAsync(const WebCore::IntPoint&, std::function<void (uint64_t, CallbackBase::Error)>);
     477    void firstRectForCharacterRangeAsync(const EditingRange&, std::function<void (const WebCore::IntRect&, const EditingRange&, CallbackBase::Error)>);
    478478    void setCompositionAsync(const String& text, Vector<WebCore::CompositionUnderline> underlines, const EditingRange& selectionRange, const EditingRange& replacementRange);
    479479    void confirmCompositionAsync();
    … …  
    652652    void didFindStringMatches(const String&, const Vector<Vector<WebCore::IntRect>>& matchRects, int32_t firstIndexAfterSelection);
    653653
    654     void getContentsAsString(PassRefPtr<StringCallback>);
    655     void getBytecodeProfile(PassRefPtr<StringCallback>);
     654    void getContentsAsString(std::function<void (const String&, CallbackBase::Error)>);
     655    void getBytecodeProfile(std::function<void (const String&, CallbackBase::Error)>);
    656656
    657657#if ENABLE(MHTML)
    658     void getContentsAsMHTMLData(PassRefPtr<DataCallback>, bool useBinaryEncoding);
     658    void getContentsAsMHTMLData(std::function<void (API::Data*, CallbackBase::Error)>, bool useBinaryEncoding);
    659659#endif
    660660    void getMainResourceDataOfFrame(WebFrameProxy*, std::function<void (API::Data*, CallbackBase::Error)>);
    661661    void getResourceDataFromFrame(WebFrameProxy*, API::URL*, std::function<void (API::Data*, CallbackBase::Error)>);
    662     void getRenderTreeExternalRepresentation(PassRefPtr<StringCallback>);
    663     void getSelectionOrContentsAsString(PassRefPtr<StringCallback>);
    664     void getSelectionAsWebArchiveData(PassRefPtr<DataCallback>);
    665     void getSourceForFrame(WebFrameProxy*, PassRefPtr<StringCallback>);
     662    void getRenderTreeExternalRepresentation(std::function<void (const String&, CallbackBase::Error)>);
     663    void getSelectionOrContentsAsString(std::function<void (const String&, CallbackBase::Error)>);
     664    void getSelectionAsWebArchiveData(std::function<void (API::Data*, CallbackBase::Error)>);
     665    void getSourceForFrame(WebFrameProxy*, std::function<void (const String&, CallbackBase::Error)>);
    666666    void getWebArchiveOfFrame(WebFrameProxy*, std::function<void (API::Data*, CallbackBase::Error)>);
    667     void runJavaScriptInMainFrame(const String&, PassRefPtr<ScriptValueCallback>);
     667    void runJavaScriptInMainFrame(const String&, std::function<void (WebSerializedScriptValue*, CallbackBase::Error)> callbackFunction);
    668668    void forceRepaint(PassRefPtr<VoidCallback>);
    669669
    … …  
    893893    void setThumbnailScale(double);
    894894
    895     void takeSnapshot(WebCore::IntRect, WebCore::IntSize bitmapSize, SnapshotOptions, ImageCallback::CallbackFunction);
     895    void takeSnapshot(WebCore::IntRect, WebCore::IntSize bitmapSize, SnapshotOptions, std::function<void (const ShareableBitmap::Handle&, CallbackBase::Error)>);
    896896
    897897private:

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

    r170000 r170041  
    12111211- (void)_define:(id)sender
    12121212{
    1213     _page->getSelectionOrContentsAsString(StringCallback::create([self](const String& string, CallbackBase::Error error) {
     1213    _page->getSelectionOrContentsAsString([self](const String& string, CallbackBase::Error error) {
    12141214        if (error != CallbackBase::Error::None)
    12151215            return;
    … …  
    12181218
    12191219        [self _showDictionary:string];
    1220     }));
     1220    });
    12211221}
    12221222
    … …  
    14401440{
    14411441    _usingGestureForSelection = YES;
    1442     _page->updateSelectionWithTouches(WebCore::IntPoint(point), static_cast<uint32_t>(toSelectionTouch(touch)), baseIsStart, TouchesCallback::create([self, touch](const WebCore::IntPoint& point, uint32_t touch, CallbackBase::Error error) {
     1442    _page->updateSelectionWithTouches(WebCore::IntPoint(point), static_cast<uint32_t>(toSelectionTouch(touch)), baseIsStart, [self, touch](const WebCore::IntPoint& point, uint32_t touch, CallbackBase::Error error) {
    14431443        selectionChangedWithTouch(self, point, touch, error);
    14441444        if (touch != UIWKSelectionTouchStarted && touch != UIWKSelectionTouchMoved)
    14451445            _usingGestureForSelection = NO;
    1446     }));
     1446    });
    14471447}
    14481448
    … …  
    14771477
    14781478    _autocorrectionData.autocorrectionHandler = [completionHandler copy];
    1479     _page->requestAutocorrectionData(input, AutocorrectionDataCallback::create([self](const Vector<FloatRect>& rects, const String& fontName, double fontSize, uint64_t traits, CallbackBase::Error) {
     1479    _page->requestAutocorrectionData(input, [self](const Vector<FloatRect>& rects, const String& fontName, double fontSize, uint64_t traits, CallbackBase::Error) {
    14801480        CGRect firstRect = CGRectZero;
    14811481        CGRect lastRect = CGRectZero;
    … …  
    14941494        [_autocorrectionData.autocorrectionHandler release];
    14951495        _autocorrectionData.autocorrectionHandler = nil;
    1496     }));
     1496    });
    14971497}
    14981498
    … …  
    15401540    UIWKDictationContextHandler dictationHandler = [completionHandler copy];
    15411541
    1542     _page->requestDictationContext(DictationContextCallback::create([dictationHandler](const String& selectedText, const String& beforeText, const String& afterText, CallbackBase::Error) {
     1542    _page->requestDictationContext([dictationHandler](const String& selectedText, const String& beforeText, const String& afterText, CallbackBase::Error) {
    15431543        dictationHandler(selectedText, beforeText, afterText);
    15441544        [dictationHandler release];
    1545     }));
     1545    });
    15461546}
    15471547
    … …  
    15571557    }
    15581558    _autocorrectionData.autocorrectionHandler = [completionHandler copy];
    1559     _page->applyAutocorrection(correction, input, StringCallback::create([self](const String& string, CallbackBase::Error error) {
     1559    _page->applyAutocorrection(correction, input, [self](const String& string, CallbackBase::Error error) {
    15601560        _autocorrectionData.autocorrectionHandler(!string.isNull() ? [WKAutocorrectionRects autocorrectionRectsWithRects:_autocorrectionData.textFirstRect lastRect:_autocorrectionData.textLastRect] : nil);
    15611561        [_autocorrectionData.autocorrectionHandler release];
    15621562        _autocorrectionData.autocorrectionHandler = nil;
    1563     }));
     1563    });
    15641564}
    15651565
    … …  
    15801580    } else {
    15811581        _autocorrectionData.autocorrectionContextHandler = [completionHandler copy];
    1582         _page->requestAutocorrectionContext(AutocorrectionContextCallback::create([self](const String& beforeText, const String& markedText, const String& selectedText, const String& afterText, uint64_t location, uint64_t length, CallbackBase::Error) {
     1582        _page->requestAutocorrectionContext([self](const String& beforeText, const String& markedText, const String& selectedText, const String& afterText, uint64_t location, uint64_t length, CallbackBase::Error) {
    15831583            _autocorrectionData.autocorrectionContextHandler([WKAutocorrectionContext autocorrectionContextWithData:beforeText markedText:markedText selectedText:selectedText afterText:afterText selectedRangeInMarkedText:NSMakeRange(location, length)]);
    1584         }));
     1584        });
    15851585    }
    15861586}

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

    r170000 r170041  
    318318}
    319319
    320 void WebPageProxy::updateSelectionWithTouches(const WebCore::IntPoint point, uint32_t touches, bool baseIsStart, PassRefPtr<TouchesCallback> callback)
    321 {
     320void WebPageProxy::updateSelectionWithTouches(const WebCore::IntPoint point, uint32_t touches, bool baseIsStart, std::function<void (const WebCore::IntPoint&, uint32_t, CallbackBase::Error)> callbackFunction)
     321{
     322    RefPtr<TouchesCallback> callback = TouchesCallback::create(std::move(callbackFunction));
     323
    322324    if (!isValid()) {
    323325        callback->invalidate();
    … …  
    340342}
    341343
    342 void WebPageProxy::requestAutocorrectionData(const String& textForAutocorrection, PassRefPtr<AutocorrectionDataCallback> callback)
    343 {
     344void WebPageProxy::requestAutocorrectionData(const String& textForAutocorrection, std::function<void (const Vector<WebCore::FloatRect>&, const String&, double, uint64_t, CallbackBase::Error)> callbackFunction)
     345{
     346    RefPtr<AutocorrectionDataCallback> callback = AutocorrectionDataCallback::create(std::move(callbackFunction));
     347
    344348    if (!isValid()) {
    345349        callback->invalidate();
    … …  
    352356}
    353357
    354 void WebPageProxy::applyAutocorrection(const String& correction, const String& originalText, PassRefPtr<StringCallback> callback)
    355 {
     358void WebPageProxy::applyAutocorrection(const String& correction, const String& originalText, std::function<void (const String&, CallbackBase::Error)> callbackFunction)
     359{
     360    RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
     361
    356362    if (!isValid()) {
    357363        callback->invalidate();
    … …  
    371377}
    372378
    373 void WebPageProxy::requestDictationContext(PassRefPtr<DictationContextCallback> callback)
    374 {
     379void WebPageProxy::requestDictationContext(std::function<void (const String&, const String&, const String&, CallbackBase::Error)> callbackFunction)
     380{
     381    RefPtr<DictationContextCallback> callback = DictationContextCallback::create(std::move(callbackFunction));
     382
    375383    if (!isValid()) {
    376384        callback->invalidate();
    … …  
    383391}
    384392
    385 void WebPageProxy::requestAutocorrectionContext(PassRefPtr<AutocorrectionContextCallback> callback)
    386 {
     393void WebPageProxy::requestAutocorrectionContext(std::function<void (const String&, const String&, const String&, const String&, uint64_t, uint64_t, CallbackBase::Error)> callbackFunction)
     394{
     395    RefPtr<AutocorrectionContextCallback> callback = AutocorrectionContextCallback::create(std::move(callbackFunction));
     396
    387397    if (!isValid()) {
    388398        callback->invalidate();
Note: See TracChangeset for help on using the changeset viewer.