Changeset 170254 in webkit


Ignore:
Timestamp:
Jun 21, 2014 3:25:34 PM (10 years ago)
Author:
mitz@apple.com
Message:

CallbackMap::put should be able to take an unwrapped function
​https://bugs.webkit.org/show_bug.cgi?id=134104

Reviewed by Anders Carlsson.

  • UIProcess/GenericCallback.h:

(WebKit::CallbackMap::put): Added an overload that takes a function and creates and puts a
callback. Changed both overloads of put() to return the callback ID.

  • 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::getMainResourceDataOfFrame):
(WebKit::WebPageProxy::getResourceDataFromFrame):
(WebKit::WebPageProxy::getWebArchiveOfFrame):
(WebKit::WebPageProxy::getMarkedRangeAsync):
(WebKit::WebPageProxy::getSelectedRangeAsync):
(WebKit::WebPageProxy::characterIndexForPointAsync):
(WebKit::WebPageProxy::firstRectForCharacterRangeAsync):
(WebKit::WebPageProxy::takeSnapshot):

Location:
trunk/Source/WebKit2
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r170253 r170254  
     12014-06-21  Dan Bernstein  <mitz@apple.com>
     2
     3        CallbackMap::put should be able to take an unwrapped function
     4        https://bugs.webkit.org/show_bug.cgi?id=134104
     5
     6        Reviewed by Anders Carlsson.
     7
     8        * UIProcess/GenericCallback.h:
     9        (WebKit::CallbackMap::put): Added an overload that takes a function and creates and puts a
     10        callback. Changed both overloads of put() to return the callback ID.
     11
     12        * UIProcess/WebPageProxy.cpp:
     13        (WebKit::WebPageProxy::validateCommand):
     14        (WebKit::WebPageProxy::runJavaScriptInMainFrame):
     15        (WebKit::WebPageProxy::getRenderTreeExternalRepresentation):
     16        (WebKit::WebPageProxy::getSourceForFrame):
     17        (WebKit::WebPageProxy::getContentsAsString):
     18        (WebKit::WebPageProxy::getBytecodeProfile):
     19        (WebKit::WebPageProxy::getContentsAsMHTMLData):
     20        (WebKit::WebPageProxy::getSelectionOrContentsAsString):
     21        (WebKit::WebPageProxy::getSelectionAsWebArchiveData):
     22        (WebKit::WebPageProxy::getMainResourceDataOfFrame):
     23        (WebKit::WebPageProxy::getResourceDataFromFrame):
     24        (WebKit::WebPageProxy::getWebArchiveOfFrame):
     25        (WebKit::WebPageProxy::getMarkedRangeAsync):
     26        (WebKit::WebPageProxy::getSelectedRangeAsync):
     27        (WebKit::WebPageProxy::characterIndexForPointAsync):
     28        (WebKit::WebPageProxy::firstRectForCharacterRangeAsync):
     29        (WebKit::WebPageProxy::takeSnapshot):
     30
    1312014-06-21  Anders Carlsson  <andersca@apple.com>
    232

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

    r170168 r170254  
    168168class CallbackMap {
    169169public:
    170     void put(PassRefPtr<CallbackBase> callback)
     170    uint64_t put(PassRefPtr<CallbackBase> callback)
    171171    {
    172172        ASSERT(!m_map.contains(callback->callbackID()));
    173         m_map.set(callback->callbackID(), callback);
     173
     174        uint64_t callbackID = callback->callbackID();
     175        m_map.set(callbackID, callback);
     176        return callbackID;
     177    }
     178
     179    template<unsigned I, typename T, typename... U>
     180    struct GenericCallbackType {
     181        typedef typename GenericCallbackType<I - 1, U..., T>::type type;
     182    };
     183
     184    template<typename... U>
     185    struct GenericCallbackType<1, CallbackBase::Error, U...> {
     186        typedef GenericCallback<U...> type;
     187    };
     188
     189    template<typename... T>
     190    uint64_t put(std::function<void (T...)> function)
     191    {
     192        auto callback = GenericCallbackType<sizeof...(T), T...>::type::create(std::move(function));
     193        return put(callback);
    174194    }
    175195

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

    r170222 r170254  
    12421242void WebPageProxy::validateCommand(const String& commandName, std::function<void (const String&, bool, int32_t, CallbackBase::Error)> callbackFunction)
    12431243{
    1244     RefPtr<ValidateCommandCallback> callback = ValidateCommandCallback::create(std::move(callbackFunction));
    1245 
    12461244    if (!isValid()) {
    1247         callback->invalidate();
    1248         return;
    1249     }
    1250 
    1251     uint64_t callbackID = callback->callbackID();
    1252     m_callbacks.put(callback);
     1245        callbackFunction(String(), false, 0, CallbackBase::Error::Unknown);
     1246        return;
     1247    }
     1248
     1249    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    12531250    m_process->send(Messages::WebPage::ValidateCommand(commandName, callbackID), m_pageID);
    12541251}
    … …  
    21882185void WebPageProxy::runJavaScriptInMainFrame(const String& script, std::function<void (WebSerializedScriptValue*, CallbackBase::Error)> callbackFunction)
    21892186{
    2190     RefPtr<ScriptValueCallback> callback = ScriptValueCallback::create(std::move(callbackFunction));
    21912187    if (!isValid()) {
    2192         callback->invalidate();
    2193         return;
    2194     }
    2195 
    2196     uint64_t callbackID = callback->callbackID();
    2197     m_callbacks.put(callback);
     2188        callbackFunction(nullptr, CallbackBase::Error::Unknown);
     2189        return;
     2190    }
     2191
     2192    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    21982193    m_process->send(Messages::WebPage::RunJavaScriptInMainFrame(script, callbackID), m_pageID);
    21992194}
    … …  
    22012196void WebPageProxy::getRenderTreeExternalRepresentation(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
    22022197{
    2203     RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22042198    if (!isValid()) {
    2205         callback->invalidate();
     2199        callbackFunction(String(), CallbackBase::Error::Unknown);
    22062200        return;
    22072201    }
    22082202   
    2209     uint64_t callbackID = callback->callbackID();
    2210     m_callbacks.put(callback);
     2203    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    22112204    m_process->send(Messages::WebPage::GetRenderTreeExternalRepresentation(callbackID), m_pageID);
    22122205}
    … …  
    22142207void WebPageProxy::getSourceForFrame(WebFrameProxy* frame, std::function<void (const String&, CallbackBase::Error)> callbackFunction)
    22152208{
    2216     RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22172209    if (!isValid()) {
    2218         callback->invalidate();
     2210        callbackFunction(String(), CallbackBase::Error::Unknown);
    22192211        return;
    22202212    }
    22212213   
    2222     uint64_t callbackID = callback->callbackID();
     2214    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    22232215    m_loadDependentStringCallbackIDs.add(callbackID);
    2224     m_callbacks.put(callback);
    22252216    m_process->send(Messages::WebPage::GetSourceForFrame(frame->frameID(), callbackID), m_pageID);
    22262217}
    … …  
    22282219void WebPageProxy::getContentsAsString(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
    22292220{
    2230     RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22312221    if (!isValid()) {
    2232         callback->invalidate();
     2222        callbackFunction(String(), CallbackBase::Error::Unknown);
    22332223        return;
    22342224    }
    22352225   
    2236     uint64_t callbackID = callback->callbackID();
     2226    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    22372227    m_loadDependentStringCallbackIDs.add(callbackID);
    2238     m_callbacks.put(callback);
    22392228    m_process->send(Messages::WebPage::GetContentsAsString(callbackID), m_pageID);
    22402229}
    … …  
    22422231void WebPageProxy::getBytecodeProfile(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
    22432232{
    2244     RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22452233    if (!isValid()) {
    2246         callback->invalidate();
     2234        callbackFunction(String(), CallbackBase::Error::Unknown);
    22472235        return;
    22482236    }
    22492237   
    2250     uint64_t callbackID = callback->callbackID();
     2238    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    22512239    m_loadDependentStringCallbackIDs.add(callbackID);
    2252     m_callbacks.put(callback);
    22532240    m_process->send(Messages::WebPage::GetBytecodeProfile(callbackID), m_pageID);
    22542241}
    … …  
    22572244void WebPageProxy::getContentsAsMHTMLData(std::function<void (API::Data*, CallbackBase::Error)> callbackFunction, bool useBinaryEncoding)
    22582245{
    2259     RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    22602246    if (!isValid()) {
    2261         callback->invalidate();
    2262         return;
    2263     }
    2264 
    2265     uint64_t callbackID = callback->callbackID();
    2266     m_callbacks.put(callback);
     2247        callbackFunction(nullptr, CallbackBase::Error::Unknown);
     2248        return;
     2249    }
     2250
     2251    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    22672252    m_process->send(Messages::WebPage::GetContentsAsMHTMLData(callbackID, useBinaryEncoding), m_pageID);
    22682253}
    … …  
    22712256void WebPageProxy::getSelectionOrContentsAsString(std::function<void (const String&, CallbackBase::Error)> callbackFunction)
    22722257{
    2273     RefPtr<StringCallback> callback = StringCallback::create(std::move(callbackFunction));
    22742258    if (!isValid()) {
    2275         callback->invalidate();
     2259        callbackFunction(String(), CallbackBase::Error::Unknown);
    22762260        return;
    22772261    }
    22782262   
    2279     uint64_t callbackID = callback->callbackID();
    2280     m_callbacks.put(callback);
     2263    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    22812264    m_process->send(Messages::WebPage::GetSelectionOrContentsAsString(callbackID), m_pageID);
    22822265}
    … …  
    22842267void WebPageProxy::getSelectionAsWebArchiveData(std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
    22852268{
    2286     RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    22872269    if (!isValid()) {
    2288         callback->invalidate();
     2270        callbackFunction(nullptr, CallbackBase::Error::Unknown);
    22892271        return;
    22902272    }
    22912273   
    2292     uint64_t callbackID = callback->callbackID();
    2293     m_callbacks.put(callback);
     2274    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    22942275    m_process->send(Messages::WebPage::GetSelectionAsWebArchiveData(callbackID), m_pageID);
    22952276}
    … …  
    22972278void WebPageProxy::getMainResourceDataOfFrame(WebFrameProxy* frame, std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
    22982279{
    2299     RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    23002280    if (!isValid() || !frame) {
    2301         callback->invalidate();
     2281        callbackFunction(nullptr, CallbackBase::Error::Unknown);
    23022282        return;
    23032283    }
    23042284   
    2305     uint64_t callbackID = callback->callbackID();
    2306     m_callbacks.put(callback);
     2285    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    23072286    m_process->send(Messages::WebPage::GetMainResourceDataOfFrame(frame->frameID(), callbackID), m_pageID);
    23082287}
    … …  
    23102289void WebPageProxy::getResourceDataFromFrame(WebFrameProxy* frame, API::URL* resourceURL, std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
    23112290{
    2312     RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    23132291    if (!isValid()) {
    2314         callback->invalidate();
     2292        callbackFunction(nullptr, CallbackBase::Error::Unknown);
    23152293        return;
    23162294    }
    23172295   
    2318     uint64_t callbackID = callback->callbackID();
    2319     m_callbacks.put(callback);
     2296    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    23202297    m_process->send(Messages::WebPage::GetResourceDataFromFrame(frame->frameID(), resourceURL->string(), callbackID), m_pageID);
    23212298}
    … …  
    23232300void WebPageProxy::getWebArchiveOfFrame(WebFrameProxy* frame, std::function<void (API::Data*, CallbackBase::Error)> callbackFunction)
    23242301{
    2325     RefPtr<DataCallback> callback = DataCallback::create(std::move(callbackFunction));
    23262302    if (!isValid()) {
    2327         callback->invalidate();
     2303        callbackFunction(nullptr, CallbackBase::Error::Unknown);
    23282304        return;
    23292305    }
    23302306   
    2331     uint64_t callbackID = callback->callbackID();
    2332     m_callbacks.put(callback);
     2307    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    23332308    m_process->send(Messages::WebPage::GetWebArchiveOfFrame(frame->frameID(), callbackID), m_pageID);
    23342309}
    … …  
    49694944void WebPageProxy::getMarkedRangeAsync(std::function<void (EditingRange, CallbackBase::Error)> callbackFunction)
    49704945{
     4946    if (!isValid()) {
     4947        callbackFunction(EditingRange(), CallbackBase::Error::Unknown);
     4948        return;
     4949    }
     4950
     4951    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
     4952    process().send(Messages::WebPage::GetMarkedRangeAsync(callbackID), m_pageID);
     4953}
     4954
     4955void WebPageProxy::getSelectedRangeAsync(std::function<void (EditingRange, CallbackBase::Error)> callbackFunction)
     4956{
    49714957    RefPtr<EditingRangeCallback> callback = EditingRangeCallback::create(std::move(callbackFunction));
    49724958
    … …  
    49764962    }
    49774963
    4978     uint64_t callbackID = callback->callbackID();
    4979     m_callbacks.put(callback);
    4980 
    4981     process().send(Messages::WebPage::GetMarkedRangeAsync(callbackID), m_pageID);
    4982 }
    4983 
    4984 void WebPageProxy::getSelectedRangeAsync(std::function<void (EditingRange, CallbackBase::Error)> callbackFunction)
    4985 {
    4986     RefPtr<EditingRangeCallback> callback = EditingRangeCallback::create(std::move(callbackFunction));
    4987 
     4964    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
     4965    process().send(Messages::WebPage::GetSelectedRangeAsync(callbackID), m_pageID);
     4966}
     4967
     4968void WebPageProxy::characterIndexForPointAsync(const WebCore::IntPoint& point, std::function<void (uint64_t, CallbackBase::Error)> callbackFunction)
     4969{
    49884970    if (!isValid()) {
    4989         callback->invalidate();
    4990         return;
    4991     }
    4992 
    4993     uint64_t callbackID = callback->callbackID();
    4994     m_callbacks.put(callback);
    4995 
    4996     process().send(Messages::WebPage::GetSelectedRangeAsync(callbackID), m_pageID);
    4997 }
    4998 
    4999 void WebPageProxy::characterIndexForPointAsync(const WebCore::IntPoint& point, std::function<void (uint64_t, CallbackBase::Error)> callbackFunction)
    5000 {
    5001     RefPtr<UnsignedCallback> callback = UnsignedCallback::create(std::move(callbackFunction));
    5002 
     4971        callbackFunction(0, CallbackBase::Error::Unknown);
     4972        return;
     4973    }
     4974
     4975    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
     4976    process().send(Messages::WebPage::CharacterIndexForPointAsync(point, callbackID), m_pageID);
     4977}
     4978
     4979void WebPageProxy::firstRectForCharacterRangeAsync(const EditingRange& range, std::function<void (const WebCore::IntRect&, const EditingRange&, CallbackBase::Error)> callbackFunction)
     4980{
    50034981    if (!isValid()) {
    5004         callback->invalidate();
    5005         return;
    5006     }
    5007 
    5008     uint64_t callbackID = callback->callbackID();
    5009     m_callbacks.put(callback);
    5010 
    5011     process().send(Messages::WebPage::CharacterIndexForPointAsync(point, callbackID), m_pageID);
    5012 }
    5013 
    5014 void WebPageProxy::firstRectForCharacterRangeAsync(const EditingRange& range, std::function<void (const WebCore::IntRect&, const EditingRange&, CallbackBase::Error)> callbackFunction)
    5015 {
    5016     RefPtr<RectForCharacterRangeCallback> callback = RectForCharacterRangeCallback::create(std::move(callbackFunction));
    5017 
    5018     if (!isValid()) {
    5019         callback->invalidate();
    5020         return;
    5021     }
    5022 
    5023     uint64_t callbackID = callback->callbackID();
    5024     m_callbacks.put(callback);
    5025 
     4982        callbackFunction(WebCore::IntRect(), EditingRange(), CallbackBase::Error::Unknown);
     4983        return;
     4984    }
     4985
     4986    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    50264987    process().send(Messages::WebPage::FirstRectForCharacterRangeAsync(range, callbackID), m_pageID);
    50274988}
    … …  
    50505011void WebPageProxy::takeSnapshot(IntRect rect, IntSize bitmapSize, SnapshotOptions options, std::function<void (const ShareableBitmap::Handle&, CallbackBase::Error)> callbackFunction)
    50515012{
    5052     RefPtr<ImageCallback> callback = ImageCallback::create(std::move(callbackFunction));
    5053 
    50545013    if (!isValid()) {
    5055         callback->invalidate();
    5056         return;
    5057     }
    5058 
    5059     uint64_t callbackID = callback->callbackID();
    5060     m_callbacks.put(callback);
    5061 
     5014        callbackFunction(ShareableBitmap::Handle(), CallbackBase::Error::Unknown);
     5015        return;
     5016    }
     5017
     5018    uint64_t callbackID = m_callbacks.put(std::move(callbackFunction));
    50625019    m_process->send(Messages::WebPage::TakeSnapshot(rect, bitmapSize, options, callbackID), m_pageID);
    50635020}
Note: See TracChangeset for help on using the changeset viewer.