Changeset 225926 in webkit


Ignore:
Timestamp:
Dec 14, 2017, 2:08:53 PM (7 years ago)
Author:
achristensen@apple.com
Message:

Use move semantics for SandboxExtension::Handle
​https://bugs.webkit.org/show_bug.cgi?id=180792

Reviewed by Andy Estes.

Passing them around as const SandboxExtension::Handle& is wrong because ownership is transferred and they are consumed.
It only works now because their contents are mutable, which isn't a good use of mutable.

  • NetworkProcess/Downloads/Download.cpp:

(WebKit::Download::decideDestinationWithSuggestedFilename):
(WebKit::Download::didDecideDownloadDestination):

  • NetworkProcess/Downloads/Download.h:
  • NetworkProcess/Downloads/DownloadManager.cpp:

(WebKit::DownloadManager::continueDecidePendingDownloadDestination):
(WebKit::DownloadManager::resumeDownload):

  • NetworkProcess/Downloads/DownloadManager.h:
  • NetworkProcess/Downloads/cocoa/DownloadCocoa.mm:

(WebKit::Download::resume):

  • NetworkProcess/Downloads/ios/DownloadIOS.mm:

(WebKit::Download::resume):

  • NetworkProcess/Downloads/mac/DownloadMac.mm:

(WebKit::Download::resume):

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::registerFileBlobURL):
(WebKit::NetworkConnectionToWebProcess::preregisterSandboxExtensionsForOptionallyFileBackedBlob):

  • NetworkProcess/NetworkConnectionToWebProcess.h:
  • NetworkProcess/NetworkDataTask.h:

(WebKit::NetworkDataTask::setPendingDownloadLocation):

  • NetworkProcess/NetworkDataTaskBlob.cpp:

(WebKit::NetworkDataTaskBlob::setPendingDownloadLocation):

  • NetworkProcess/NetworkDataTaskBlob.h:
  • NetworkProcess/NetworkProcess.cpp:

(WebKit::NetworkProcess::resumeDownload):
(WebKit::NetworkProcess::continueDecidePendingDownloadDestination):

  • NetworkProcess/NetworkProcess.h:
  • NetworkProcess/NetworkResourceLoadParameters.cpp:

(WebKit::NetworkResourceLoadParameters::decode):

  • NetworkProcess/cocoa/NetworkDataTaskCocoa.h:
  • NetworkProcess/cocoa/NetworkDataTaskCocoa.mm:

(WebKit::NetworkDataTaskCocoa::setPendingDownloadLocation):

  • Shared/SandboxExtension.h:

(WebKit::SandboxExtension::create):

  • Shared/WebMemorySampler.cpp:

(WebKit::WebMemorySampler::start):
(WebKit::WebMemorySampler::initializeSandboxedLogFile):

  • Shared/WebMemorySampler.h:
  • Shared/mac/SandboxExtensionMac.mm:

(WebKit::SandboxExtension::create):

  • StorageProcess/StorageProcess.cpp:

(WebKit::StorageProcess::grantSandboxExtensionsForBlobs):

  • StorageProcess/StorageProcess.h:
  • UIProcess/Cocoa/WebViewImpl.mm:

(WebKit::WebViewImpl::performDragOperation):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::dragEntered):
(WebKit::WebPageProxy::dragUpdated):
(WebKit::WebPageProxy::dragExited):
(WebKit::WebPageProxy::performDragOperation):
(WebKit::WebPageProxy::performDragControllerAction):

  • UIProcess/WebPageProxy.h:
  • WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::InjectedBundle::create):

  • WebProcess/InjectedBundle/InjectedBundle.h:
  • WebProcess/MediaStream/MediaDeviceSandboxExtensions.cpp:

(WebKit::MediaDeviceSandboxExtensions::operator[]):
(WebKit::MediaDeviceSandboxExtensions::operator[] const): Deleted.

  • WebProcess/MediaStream/MediaDeviceSandboxExtensions.h:
  • WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:

(WebKit::UserMediaPermissionRequestManager::grantUserMediaDeviceSandboxExtensions):

  • WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
  • WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:

(WebKit::WebPlatformStrategies::getPathnamesForType):

  • WebProcess/WebPage/WebBackForwardListProxy.cpp:

(WebKit::WebBackForwardListProxy::goToItem):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::loadRequest):
(WebKit::WebPage::reload):
(WebKit::WebPage::performDragControllerAction):
(WebKit::WebPage::grantUserMediaDeviceSandboxExtensions):
(WebKit::WebPage::SandboxExtensionTracker::beginLoad):

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

(WebKit::WebProcess::startMemorySampler):

  • WebProcess/WebProcess.h:
Location:
trunk/Source/WebKit
Files:
43 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r225925 r225926  
     12017-12-14  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use move semantics for SandboxExtension::Handle
     4        https://bugs.webkit.org/show_bug.cgi?id=180792
     5
     6        Reviewed by Andy Estes.
     7       
     8        Passing them around as const SandboxExtension::Handle& is wrong because ownership is transferred and they are consumed.
     9        It only works now because their contents are mutable, which isn't a good use of mutable.
     10
     11        * NetworkProcess/Downloads/Download.cpp:
     12        (WebKit::Download::decideDestinationWithSuggestedFilename):
     13        (WebKit::Download::didDecideDownloadDestination):
     14        * NetworkProcess/Downloads/Download.h:
     15        * NetworkProcess/Downloads/DownloadManager.cpp:
     16        (WebKit::DownloadManager::continueDecidePendingDownloadDestination):
     17        (WebKit::DownloadManager::resumeDownload):
     18        * NetworkProcess/Downloads/DownloadManager.h:
     19        * NetworkProcess/Downloads/cocoa/DownloadCocoa.mm:
     20        (WebKit::Download::resume):
     21        * NetworkProcess/Downloads/ios/DownloadIOS.mm:
     22        (WebKit::Download::resume):
     23        * NetworkProcess/Downloads/mac/DownloadMac.mm:
     24        (WebKit::Download::resume):
     25        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     26        (WebKit::NetworkConnectionToWebProcess::registerFileBlobURL):
     27        (WebKit::NetworkConnectionToWebProcess::preregisterSandboxExtensionsForOptionallyFileBackedBlob):
     28        * NetworkProcess/NetworkConnectionToWebProcess.h:
     29        * NetworkProcess/NetworkDataTask.h:
     30        (WebKit::NetworkDataTask::setPendingDownloadLocation):
     31        * NetworkProcess/NetworkDataTaskBlob.cpp:
     32        (WebKit::NetworkDataTaskBlob::setPendingDownloadLocation):
     33        * NetworkProcess/NetworkDataTaskBlob.h:
     34        * NetworkProcess/NetworkProcess.cpp:
     35        (WebKit::NetworkProcess::resumeDownload):
     36        (WebKit::NetworkProcess::continueDecidePendingDownloadDestination):
     37        * NetworkProcess/NetworkProcess.h:
     38        * NetworkProcess/NetworkResourceLoadParameters.cpp:
     39        (WebKit::NetworkResourceLoadParameters::decode):
     40        * NetworkProcess/cocoa/NetworkDataTaskCocoa.h:
     41        * NetworkProcess/cocoa/NetworkDataTaskCocoa.mm:
     42        (WebKit::NetworkDataTaskCocoa::setPendingDownloadLocation):
     43        * Shared/SandboxExtension.h:
     44        (WebKit::SandboxExtension::create):
     45        * Shared/WebMemorySampler.cpp:
     46        (WebKit::WebMemorySampler::start):
     47        (WebKit::WebMemorySampler::initializeSandboxedLogFile):
     48        * Shared/WebMemorySampler.h:
     49        * Shared/mac/SandboxExtensionMac.mm:
     50        (WebKit::SandboxExtension::create):
     51        * StorageProcess/StorageProcess.cpp:
     52        (WebKit::StorageProcess::grantSandboxExtensionsForBlobs):
     53        * StorageProcess/StorageProcess.h:
     54        * UIProcess/Cocoa/WebViewImpl.mm:
     55        (WebKit::WebViewImpl::performDragOperation):
     56        * UIProcess/WebPageProxy.cpp:
     57        (WebKit::WebPageProxy::dragEntered):
     58        (WebKit::WebPageProxy::dragUpdated):
     59        (WebKit::WebPageProxy::dragExited):
     60        (WebKit::WebPageProxy::performDragOperation):
     61        (WebKit::WebPageProxy::performDragControllerAction):
     62        * UIProcess/WebPageProxy.h:
     63        * WebProcess/InjectedBundle/InjectedBundle.cpp:
     64        (WebKit::InjectedBundle::create):
     65        * WebProcess/InjectedBundle/InjectedBundle.h:
     66        * WebProcess/MediaStream/MediaDeviceSandboxExtensions.cpp:
     67        (WebKit::MediaDeviceSandboxExtensions::operator[]):
     68        (WebKit::MediaDeviceSandboxExtensions::operator[] const): Deleted.
     69        * WebProcess/MediaStream/MediaDeviceSandboxExtensions.h:
     70        * WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
     71        (WebKit::UserMediaPermissionRequestManager::grantUserMediaDeviceSandboxExtensions):
     72        * WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
     73        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
     74        (WebKit::WebPlatformStrategies::getPathnamesForType):
     75        * WebProcess/WebPage/WebBackForwardListProxy.cpp:
     76        (WebKit::WebBackForwardListProxy::goToItem):
     77        * WebProcess/WebPage/WebPage.cpp:
     78        (WebKit::WebPage::loadRequest):
     79        (WebKit::WebPage::reload):
     80        (WebKit::WebPage::performDragControllerAction):
     81        (WebKit::WebPage::grantUserMediaDeviceSandboxExtensions):
     82        (WebKit::WebPage::SandboxExtensionTracker::beginLoad):
     83        * WebProcess/WebPage/WebPage.h:
     84        * WebProcess/WebProcess.cpp:
     85        (WebKit::WebProcess::startMemorySampler):
     86        * WebProcess/WebProcess.h:
     87
    1882017-12-14  Alex Christensen  <achristensen@webkit.org>
    289

  • trunk/Source/WebKit/NetworkProcess/Downloads/Download.cpp

    r224299 r225926  
    211211        return String();
    212212
    213     m_sandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
     213    m_sandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle));
    214214    if (m_sandboxExtension)
    215215        m_sandboxExtension->consume();
    … …  
    223223}
    224224
    225 void Download::didDecideDownloadDestination(const String& destinationPath, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite)
     225void Download::didDecideDownloadDestination(const String& destinationPath, SandboxExtension::Handle&& sandboxExtensionHandle, bool allowOverwrite)
    226226{
    227227    ASSERT(!m_sandboxExtension);
    228     m_sandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
     228    m_sandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle));
    229229    if (m_sandboxExtension)
    230230        m_sandboxExtension->consume();

  • trunk/Source/WebKit/NetworkProcess/Downloads/Download.h

    r224846 r225926  
    9191    void startWithHandle(WebCore::ResourceHandle*, const WebCore::ResourceResponse&);
    9292#endif
    93     void resume(const IPC::DataReference& resumeData, const String& path, const SandboxExtension::Handle&);
     93    void resume(const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&&);
    9494    void cancel();
    9595
    … …  
    109109    String decideDestinationWithSuggestedFilename(const String& filename, bool& allowOverwrite);
    110110    void decideDestinationWithSuggestedFilenameAsync(const String&);
    111     void didDecideDownloadDestination(const String& destinationPath, const SandboxExtension::Handle&, bool allowOverwrite);
     111    void didDecideDownloadDestination(const String& destinationPath, SandboxExtension::Handle&&, bool allowOverwrite);
    112112    void continueDidReceiveResponse();
    113113    void platformDidFinish();

  • trunk/Source/WebKit/NetworkProcess/Downloads/DownloadManager.cpp

    r223730 r225926  
    123123}
    124124
    125 void DownloadManager::continueDecidePendingDownloadDestination(DownloadID downloadID, String destination, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite)
     125void DownloadManager::continueDecidePendingDownloadDestination(DownloadID downloadID, String destination, SandboxExtension::Handle&& sandboxExtensionHandle, bool allowOverwrite)
    126126{
    127127#if USE(NETWORK_SESSION)
    … …  
    134134        ASSERT(m_pendingDownloads.contains(downloadID));
    135135
    136         networkDataTask->setPendingDownloadLocation(destination, sandboxExtensionHandle, allowOverwrite);
     136        networkDataTask->setPendingDownloadLocation(destination, WTFMove(sandboxExtensionHandle), allowOverwrite);
    137137        completionHandler(PolicyAction::Download);
    138138        if (networkDataTask->state() == NetworkDataTask::State::Canceling || networkDataTask->state() == NetworkDataTask::State::Completed)
    … …  
    149149#else
    150150    if (auto* waitingDownload = download(downloadID))
    151         waitingDownload->didDecideDownloadDestination(destination, sandboxExtensionHandle, allowOverwrite);
    152 #endif
    153 }
    154 
    155 void DownloadManager::resumeDownload(PAL::SessionID sessionID, DownloadID downloadID, const IPC::DataReference& resumeData, const String& path, const SandboxExtension::Handle& sandboxExtensionHandle)
     151        waitingDownload->didDecideDownloadDestination(destination, WTFMove(sandboxExtensionHandle), allowOverwrite);
     152#endif
     153}
     154
     155void DownloadManager::resumeDownload(PAL::SessionID sessionID, DownloadID downloadID, const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&& sandboxExtensionHandle)
    156156{
    157157#if USE(NETWORK_SESSION) && !PLATFORM(COCOA)
    … …  
    165165#endif
    166166
    167     download->resume(resumeData, path, sandboxExtensionHandle);
     167    download->resume(resumeData, path, WTFMove(sandboxExtensionHandle));
    168168    ASSERT(!m_downloads.contains(downloadID));
    169169    m_downloads.add(downloadID, WTFMove(download));

  • trunk/Source/WebKit/NetworkProcess/Downloads/DownloadManager.h

    r223730 r225926  
    8585#endif
    8686    void convertNetworkLoadToDownload(DownloadID, std::unique_ptr<NetworkLoad>&&, Vector<RefPtr<WebCore::BlobDataFileReference>>&&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);
    87     void continueDecidePendingDownloadDestination(DownloadID, String destination, const SandboxExtension::Handle&, bool allowOverwrite);
     87    void continueDecidePendingDownloadDestination(DownloadID, String destination, SandboxExtension::Handle&&, bool allowOverwrite);
    8888
    89     void resumeDownload(PAL::SessionID, DownloadID, const IPC::DataReference& resumeData, const String& path, const SandboxExtension::Handle&);
     89    void resumeDownload(PAL::SessionID, DownloadID, const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&&);
    9090
    9191    void cancelDownload(DownloadID);

  • trunk/Source/WebKit/NetworkProcess/Downloads/cocoa/DownloadCocoa.mm

    r223431 r225926  
    3636namespace WebKit {
    3737
    38 void Download::resume(const IPC::DataReference& resumeData, const String& path, const SandboxExtension::Handle& sandboxExtensionHandle)
     38void Download::resume(const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&& sandboxExtensionHandle)
    3939{
    40     m_sandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
     40    m_sandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle));
    4141    if (m_sandboxExtension)
    4242        m_sandboxExtension->consume();

  • trunk/Source/WebKit/NetworkProcess/Downloads/ios/DownloadIOS.mm

    r208388 r225926  
    128128}
    129129
    130 void Download::resume(const IPC::DataReference&, const String&, const SandboxExtension::Handle&)
     130void Download::resume(const IPC::DataReference&, const String&, SandboxExtension::Handle&&)
    131131{
    132132    notImplemented();

  • trunk/Source/WebKit/NetworkProcess/Downloads/mac/DownloadMac.mm

    r224828 r225926  
    8484}
    8585
    86 void Download::resume(const IPC::DataReference& resumeData, const String& path, const SandboxExtension::Handle& sandboxExtensionHandle)
     86void Download::resume(const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&& sandboxExtensionHandle)
    8787{
    8888    ASSERT(!m_nsURLDownload);
    8989    ASSERT(!m_delegate);
    9090
    91     m_sandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
     91    m_sandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle));
    9292    if (m_sandboxExtension)
    9393        m_sandboxExtension->consume();

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r224791 r225926  
    378378}
    379379
    380 void NetworkConnectionToWebProcess::registerFileBlobURL(const URL& url, const String& path, const SandboxExtension::Handle& extensionHandle, const String& contentType)
    381 {
    382     RefPtr<SandboxExtension> extension = SandboxExtension::create(extensionHandle);
     380void NetworkConnectionToWebProcess::registerFileBlobURL(const URL& url, const String& path, SandboxExtension::Handle&& extensionHandle, const String& contentType)
     381{
     382    RefPtr<SandboxExtension> extension = SandboxExtension::create(WTFMove(extensionHandle));
    383383
    384384    NetworkBlobRegistry::singleton().registerFileBlobURL(this, url, path, WTFMove(extension), contentType);
    … …  
    395395}
    396396
    397 void NetworkConnectionToWebProcess::preregisterSandboxExtensionsForOptionallyFileBackedBlob(const Vector<String>& filePaths, const SandboxExtension::HandleArray& handles)
     397void NetworkConnectionToWebProcess::preregisterSandboxExtensionsForOptionallyFileBackedBlob(const Vector<String>& filePaths, SandboxExtension::HandleArray&& handles)
    398398{
    399399#if ENABLE(SANDBOX_EXTENSIONS)
    … …  
    401401
    402402    for (size_t i = 0; i < filePaths.size(); ++i)
    403         m_blobDataFileReferences.add(filePaths[i], BlobDataFileReferenceWithSandboxExtension::create(filePaths[i], SandboxExtension::create(handles[i])));
     403        m_blobDataFileReferences.add(filePaths[i], BlobDataFileReferenceWithSandboxExtension::create(filePaths[i], SandboxExtension::create(WTFMove(handles[i]))));
    404404#else
    405405    for (size_t i = 0; i < filePaths.size(); ++i)

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

    r223179 r225926  
    109109    void deleteCookie(PAL::SessionID, const WebCore::URL&, const String& cookieName);
    110110
    111     void registerFileBlobURL(const WebCore::URL&, const String& path, const SandboxExtension::Handle&, const String& contentType);
     111    void registerFileBlobURL(const WebCore::URL&, const String& path, SandboxExtension::Handle&&, const String& contentType);
    112112    void registerBlobURL(const WebCore::URL&, Vector<WebCore::BlobPart>&&, const String& contentType);
    113113    void registerBlobURLFromURL(const WebCore::URL&, const WebCore::URL& srcURL);
    114     void preregisterSandboxExtensionsForOptionallyFileBackedBlob(const Vector<String>& fileBackedPath, const SandboxExtension::HandleArray&);
     114    void preregisterSandboxExtensionsForOptionallyFileBackedBlob(const Vector<String>& fileBackedPath, SandboxExtension::HandleArray&&);
    115115    void registerBlobURLOptionallyFileBacked(const WebCore::URL&, const WebCore::URL& srcURL, const String& fileBackedPath, const String& contentType);
    116116    void registerBlobURLForSlice(const WebCore::URL&, const WebCore::URL& srcURL, int64_t start, int64_t end);

  • trunk/Source/WebKit/NetworkProcess/NetworkDataTask.h

    r224373 r225926  
    120120    }
    121121
    122     virtual void setPendingDownloadLocation(const String& filename, const SandboxExtension::Handle&, bool /*allowOverwrite*/) { m_pendingDownloadLocation = filename; }
     122    virtual void setPendingDownloadLocation(const String& filename, SandboxExtension::Handle&&, bool /*allowOverwrite*/) { m_pendingDownloadLocation = filename; }
    123123    const String& pendingDownloadLocation() const { return m_pendingDownloadLocation; }
    124124    bool isDownload() const { return !!m_pendingDownloadID.downloadID(); }

  • trunk/Source/WebKit/NetworkProcess/NetworkDataTaskBlob.cpp

    r224635 r225926  
    440440}
    441441
    442 void NetworkDataTaskBlob::setPendingDownloadLocation(const String& filename, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite)
    443 {
    444     NetworkDataTask::setPendingDownloadLocation(filename, sandboxExtensionHandle, allowOverwrite);
     442void NetworkDataTaskBlob::setPendingDownloadLocation(const String& filename, SandboxExtension::Handle&& sandboxExtensionHandle, bool allowOverwrite)
     443{
     444    NetworkDataTask::setPendingDownloadLocation(filename, { }, allowOverwrite);
    445445
    446446    ASSERT(!m_sandboxExtension);
    447     m_sandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
     447    m_sandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle));
    448448    if (m_sandboxExtension)
    449449        m_sandboxExtension->consume();

  • trunk/Source/WebKit/NetworkProcess/NetworkDataTaskBlob.h

    r224371 r225926  
    6565    NetworkDataTask::State state() const override { return m_state; }
    6666
    67     void setPendingDownloadLocation(const String&, const SandboxExtension::Handle&, bool /*allowOverwrite*/) override;
     67    void setPendingDownloadLocation(const String&, SandboxExtension::Handle&&, bool /*allowOverwrite*/) override;
    6868    String suggestedFilename() const override;
    6969

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

    r225827 r225926  
    519519}
    520520
    521 void NetworkProcess::resumeDownload(PAL::SessionID sessionID, DownloadID downloadID, const IPC::DataReference& resumeData, const String& path, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle)
    522 {
    523     downloadManager().resumeDownload(sessionID, downloadID, resumeData, path, sandboxExtensionHandle);
     521void NetworkProcess::resumeDownload(PAL::SessionID sessionID, DownloadID downloadID, const IPC::DataReference& resumeData, const String& path, WebKit::SandboxExtension::Handle&& sandboxExtensionHandle)
     522{
     523    downloadManager().resumeDownload(sessionID, downloadID, resumeData, path, WTFMove(sandboxExtensionHandle));
    524524}
    525525
    … …  
    595595#endif
    596596
    597 void NetworkProcess::continueDecidePendingDownloadDestination(DownloadID downloadID, String destination, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite)
     597void NetworkProcess::continueDecidePendingDownloadDestination(DownloadID downloadID, String destination, SandboxExtension::Handle&& sandboxExtensionHandle, bool allowOverwrite)
    598598{
    599599    if (destination.isEmpty())
    600600        downloadManager().cancelDownload(downloadID);
    601601    else
    602         downloadManager().continueDecidePendingDownloadDestination(downloadID, destination, sandboxExtensionHandle, allowOverwrite);
     602        downloadManager().continueDecidePendingDownloadDestination(downloadID, destination, WTFMove(sandboxExtensionHandle), allowOverwrite);
    603603}
    604604

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.h

    r225827 r225926  
    201201
    202202    void downloadRequest(PAL::SessionID, DownloadID, const WebCore::ResourceRequest&, const String& suggestedFilename);
    203     void resumeDownload(PAL::SessionID, DownloadID, const IPC::DataReference& resumeData, const String& path, const SandboxExtension::Handle&);
     203    void resumeDownload(PAL::SessionID, DownloadID, const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&&);
    204204    void cancelDownload(DownloadID);
    205205#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    … …  
    209209    void continueWillSendRequest(DownloadID, WebCore::ResourceRequest&&);
    210210#endif
    211     void continueDecidePendingDownloadDestination(DownloadID, String destination, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite);
     211    void continueDecidePendingDownloadDestination(DownloadID, String destination, SandboxExtension::Handle&&, bool allowOverwrite);
    212212
    213213    void setCacheModel(uint32_t);

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp

    r225826 r225926  
    129129            return false;
    130130        for (size_t i = 0; i < requestBodySandboxExtensionHandles.size(); ++i) {
    131             if (auto extension = SandboxExtension::create(requestBodySandboxExtensionHandles[i]))
     131            if (auto extension = SandboxExtension::create(WTFMove(requestBodySandboxExtensionHandles[i])))
    132132                result.requestBodySandboxExtensions.append(WTFMove(extension));
    133133        }

  • trunk/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h

    r225827 r225926  
    6565    NetworkDataTask::State state() const override;
    6666
    67     void setPendingDownloadLocation(const String&, const SandboxExtension::Handle&, bool /*allowOverwrite*/) override;
     67    void setPendingDownloadLocation(const String&, SandboxExtension::Handle&&, bool /*allowOverwrite*/) override;
    6868    String suggestedFilename() const override;
    6969

  • trunk/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm

    r225827 r225926  
    294294}
    295295
    296 void NetworkDataTaskCocoa::setPendingDownloadLocation(const WTF::String& filename, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite)
    297 {
    298     NetworkDataTask::setPendingDownloadLocation(filename, sandboxExtensionHandle, allowOverwrite);
     296void NetworkDataTaskCocoa::setPendingDownloadLocation(const WTF::String& filename, SandboxExtension::Handle&& sandboxExtensionHandle, bool allowOverwrite)
     297{
     298    NetworkDataTask::setPendingDownloadLocation(filename, { }, allowOverwrite);
    299299
    300300    ASSERT(!m_sandboxExtension);
    301     m_sandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
     301    m_sandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle));
    302302    if (m_sandboxExtension)
    303303        m_sandboxExtension->consume();

  • trunk/Source/WebKit/NetworkProcess/soup/NetworkDataTaskSoup.cpp

    r224299 r225926  
    9696}
    9797
    98 void NetworkDataTaskSoup::setPendingDownloadLocation(const String& filename, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite)
    99 {
    100     NetworkDataTask::setPendingDownloadLocation(filename, sandboxExtensionHandle, allowOverwrite);
     98void NetworkDataTaskSoup::setPendingDownloadLocation(const String& filename, SandboxExtension::Handle&& sandboxExtensionHandle, bool allowOverwrite)
     99{
     100    NetworkDataTask::setPendingDownloadLocation(filename, WTFMove(sandboxExtensionHandle), allowOverwrite);
    101101    m_allowOverwriteDownload = allowOverwrite;
    102102}

  • trunk/Source/WebKit/NetworkProcess/soup/NetworkDataTaskSoup.h

    r224299 r225926  
    5353    NetworkDataTask::State state() const override;
    5454
    55     void setPendingDownloadLocation(const String&, const SandboxExtension::Handle&, bool /*allowOverwrite*/) override;
     55    void setPendingDownloadLocation(const String&, SandboxExtension::Handle&&, bool /*allowOverwrite*/) override;
    5656    String suggestedFilename() const override;
    5757

  • trunk/Source/WebKit/Shared/SandboxExtension.h

    r225826 r225926  
    9494    };
    9595   
    96     static RefPtr<SandboxExtension> create(const Handle&);
     96    static RefPtr<SandboxExtension> create(Handle&&);
    9797    static bool createHandle(const String& path, Type, Handle&);
    9898    static bool createHandleWithoutResolvingPath(const String& path, Type, Handle&);
    … …  
    130130inline void SandboxExtension::HandleArray::encode(IPC::Encoder&) const { }
    131131inline bool SandboxExtension::HandleArray::decode(IPC::Decoder&, HandleArray&) { return true; }
    132 inline RefPtr<SandboxExtension> SandboxExtension::create(const Handle&) { return nullptr; }
     132inline RefPtr<SandboxExtension> SandboxExtension::create(Handle&&) { return nullptr; }
    133133inline bool SandboxExtension::createHandle(const String&, Type, Handle&) { return true; }
    134134inline bool SandboxExtension::createHandleWithoutResolvingPath(const String&, Type, Handle&) { return true; }

  • trunk/Source/WebKit/Shared/WebMemorySampler.cpp

    r224635 r225926  
    7171}
    7272
    73 void WebMemorySampler::start(const SandboxExtension::Handle& sampleLogFileHandle, const String& sampleLogFilePath, const double interval)
     73void WebMemorySampler::start(SandboxExtension::Handle&& sampleLogFileHandle, const String& sampleLogFilePath, const double interval)
    7474{
    7575    if (m_isRunning)
    … …  
    8282    }
    8383       
    84     initializeSandboxedLogFile(sampleLogFileHandle, sampleLogFilePath);
     84    initializeSandboxedLogFile(WTFMove(sampleLogFileHandle), sampleLogFilePath);
    8585    initializeTimers(interval);
    8686   
    … …  
    132132}
    133133
    134 void WebMemorySampler::initializeSandboxedLogFile(const SandboxExtension::Handle& sampleLogSandboxHandle, const String& sampleLogFilePath)
     134void WebMemorySampler::initializeSandboxedLogFile(SandboxExtension::Handle&& sampleLogSandboxHandle, const String& sampleLogFilePath)
    135135{
    136     m_sampleLogSandboxExtension = SandboxExtension::create(sampleLogSandboxHandle);
     136    m_sampleLogSandboxExtension = SandboxExtension::create(WTFMove(sampleLogSandboxHandle));
    137137    if (m_sampleLogSandboxExtension)
    138138        m_sampleLogSandboxExtension->consume();

  • trunk/Source/WebKit/Shared/WebMemorySampler.h

    r224371 r225926  
    7474    static WebMemorySampler* singleton();
    7575    void start(const double interval = 0);
    76     void start(const SandboxExtension::Handle&, const String&, const double interval = 0);
     76    void start(SandboxExtension::Handle&&, const String&, const double interval = 0);
    7777    void stop();
    7878    bool isRunning() const;
    … …  
    8383   
    8484    void initializeTempLogFile();
    85     void initializeSandboxedLogFile(const SandboxExtension::Handle&, const String&);
     85    void initializeSandboxedLogFile(SandboxExtension::Handle&&, const String&);
    8686    void writeHeaders();
    8787    void initializeTimers(double);

  • trunk/Source/WebKit/Shared/mac/SandboxExtensionMac.mm

    r225826 r225926  
    210210}
    211211
    212 RefPtr<SandboxExtension> SandboxExtension::create(const Handle& handle)
     212RefPtr<SandboxExtension> SandboxExtension::create(Handle&& handle)
    213213{
    214214    if (!handle.m_sandboxExtension)

  • trunk/Source/WebKit/StorageProcess/StorageProcess.cpp

    r225914 r225926  
    333333
    334334#if ENABLE(SANDBOX_EXTENSIONS)
    335 void StorageProcess::grantSandboxExtensionsForBlobs(const Vector<String>& paths, const SandboxExtension::HandleArray& handles)
     335void StorageProcess::grantSandboxExtensionsForBlobs(const Vector<String>& paths, SandboxExtension::HandleArray&& handles)
    336336{
    337337    ASSERT(paths.size() == handles.size());
    338338
    339339    for (size_t i = 0; i < paths.size(); ++i) {
    340         auto result = m_blobTemporaryFileSandboxExtensions.add(paths[i], SandboxExtension::create(handles[i]));
     340        auto result = m_blobTemporaryFileSandboxExtensions.add(paths[i], SandboxExtension::create(WTFMove(handles[i])));
    341341        ASSERT_UNUSED(result, result.isNewEntry);
    342342    }

  • trunk/Source/WebKit/StorageProcess/StorageProcess.h

    r225877 r225926  
    125125    void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<WebCore::SecurityOriginData>& origins, uint64_t callbackID);
    126126#if ENABLE(SANDBOX_EXTENSIONS)
    127     void grantSandboxExtensionsForBlobs(const Vector<String>& paths, const SandboxExtension::HandleArray&);
     127    void grantSandboxExtensionsForBlobs(const Vector<String>& paths, SandboxExtension::HandleArray&&);
    128128    void didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&&);
    129129#endif

  • trunk/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm

    r225369 r225926  
    37373737                        m_page->createSandboxExtensionsIfNeeded(*fileNames, sandboxExtensionHandle, sandboxExtensionForUpload);
    37383738                        dragData->setFileNames(*fileNames);
    3739                         m_page->performDragOperation(*dragData, pasteboardName, sandboxExtensionHandle, sandboxExtensionForUpload);
     3739                        m_page->performDragOperation(*dragData, pasteboardName, WTFMove(sandboxExtensionHandle), WTFMove(sandboxExtensionForUpload));
    37403740                        delete dragData;
    37413741                        delete fileNames;
    … …  
    37493749#endif
    37503750
    3751     m_page->performDragOperation(*dragData, draggingInfo.draggingPasteboard.name, sandboxExtensionHandle, sandboxExtensionForUpload);
     3751    m_page->performDragOperation(*dragData, draggingInfo.draggingPasteboard.name, WTFMove(sandboxExtensionHandle), WTFMove(sandboxExtensionForUpload));
    37523752    delete dragData;
    37533753

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

    r225827 r225926  
    17301730void WebPageProxy::dragEntered(DragData& dragData, const String& dragStorageName)
    17311731{
    1732     SandboxExtension::Handle sandboxExtensionHandle;
    1733     SandboxExtension::HandleArray sandboxExtensionHandleEmptyArray;
    1734     performDragControllerAction(DragControllerAction::Entered, dragData, dragStorageName, sandboxExtensionHandle, sandboxExtensionHandleEmptyArray);
     1732    performDragControllerAction(DragControllerAction::Entered, dragData, dragStorageName, { }, { });
    17351733}
    17361734
    17371735void WebPageProxy::dragUpdated(DragData& dragData, const String& dragStorageName)
    17381736{
    1739     SandboxExtension::Handle sandboxExtensionHandle;
    1740     SandboxExtension::HandleArray sandboxExtensionHandleEmptyArray;
    1741     performDragControllerAction(DragControllerAction::Updated, dragData, dragStorageName, sandboxExtensionHandle, sandboxExtensionHandleEmptyArray);
     1737    performDragControllerAction(DragControllerAction::Updated, dragData, dragStorageName, { }, { });
    17421738}
    17431739
    17441740void WebPageProxy::dragExited(DragData& dragData, const String& dragStorageName)
    17451741{
    1746     SandboxExtension::Handle sandboxExtensionHandle;
    1747     SandboxExtension::HandleArray sandboxExtensionHandleEmptyArray;
    1748     performDragControllerAction(DragControllerAction::Exited, dragData, dragStorageName, sandboxExtensionHandle, sandboxExtensionHandleEmptyArray);
    1749 }
    1750 
    1751 void WebPageProxy::performDragOperation(DragData& dragData, const String& dragStorageName, const SandboxExtension::Handle& sandboxExtensionHandle, const SandboxExtension::HandleArray& sandboxExtensionsForUpload)
    1752 {
    1753     performDragControllerAction(DragControllerAction::PerformDragOperation, dragData, dragStorageName, sandboxExtensionHandle, sandboxExtensionsForUpload);
    1754 }
    1755 
    1756 void WebPageProxy::performDragControllerAction(DragControllerAction action, DragData& dragData, const String& dragStorageName, const SandboxExtension::Handle& sandboxExtensionHandle, const SandboxExtension::HandleArray& sandboxExtensionsForUpload)
     1742    performDragControllerAction(DragControllerAction::Exited, dragData, dragStorageName, { }, { });
     1743}
     1744
     1745void WebPageProxy::performDragOperation(DragData& dragData, const String& dragStorageName, SandboxExtension::Handle&& sandboxExtensionHandle, SandboxExtension::HandleArray&& sandboxExtensionsForUpload)
     1746{
     1747    performDragControllerAction(DragControllerAction::PerformDragOperation, dragData, dragStorageName, WTFMove(sandboxExtensionHandle), WTFMove(sandboxExtensionsForUpload));
     1748}
     1749
     1750void WebPageProxy::performDragControllerAction(DragControllerAction action, DragData& dragData, const String& dragStorageName, SandboxExtension::Handle&& sandboxExtensionHandle, SandboxExtension::HandleArray&& sandboxExtensionsForUpload)
    17571751{
    17581752    if (!isValid())

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

    r225827 r225926  
    853853    void dragUpdated(WebCore::DragData&, const String& dragStorageName = String());
    854854    void dragExited(WebCore::DragData&, const String& dragStorageName = String());
    855     void performDragOperation(WebCore::DragData&, const String& dragStorageName, const SandboxExtension::Handle&, const SandboxExtension::HandleArray&);
     855    void performDragOperation(WebCore::DragData&, const String& dragStorageName, SandboxExtension::Handle&&, SandboxExtension::HandleArray&&);
    856856
    857857    void didPerformDragControllerAction(uint64_t dragOperation, bool mouseIsOverFileInput, unsigned numberOfItemsToBeAccepted, const WebCore::IntRect& insertionRect);
    … …  
    16081608    void clearLoadDependentCallbacks();
    16091609
    1610     void performDragControllerAction(DragControllerAction, WebCore::DragData&, const String& dragStorageName, const SandboxExtension::Handle&, const SandboxExtension::HandleArray&);
     1610    void performDragControllerAction(DragControllerAction, WebCore::DragData&, const String& dragStorageName, SandboxExtension::Handle&&, SandboxExtension::HandleArray&&);
    16111611
    16121612    void updateBackingStoreDiscardableState();

  • trunk/Source/WebKit/UIProcess/gtk/DragAndDropHandler.cpp

    r213638 r225926  
    294294        flags |= WebCore::DragApplicationIsCopyKeyDown;
    295295    DragData dragData(droppingContext->selectionData.ptr(), position, convertWidgetPointToScreenPoint(m_page.viewWidget(), position), gdkDragActionToDragOperation(gdk_drag_context_get_actions(context)), static_cast<WebCore::DragApplicationFlags>(flags));
    296     SandboxExtension::Handle handle;
    297     SandboxExtension::HandleArray sandboxExtensionForUpload;
    298     m_page.performDragOperation(dragData, String(), handle, sandboxExtensionForUpload);
     296    m_page.performDragOperation(dragData, String(), { }, { });
    299297    gtk_drag_finish(context, TRUE, FALSE, time);
    300298    return true;

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

    r224819 r225926  
    47844784        SandboxExtension::HandleArray sandboxExtensionForUpload;
    47854785        retainedSelf->_page->createSandboxExtensionsIfNeeded(filenames, sandboxExtensionHandle, sandboxExtensionForUpload);
    4786         retainedSelf->_page->performDragOperation(capturedDragData, "data interaction pasteboard", sandboxExtensionHandle, sandboxExtensionForUpload);
     4786        retainedSelf->_page->performDragOperation(capturedDragData, "data interaction pasteboard", WTFMove(sandboxExtensionHandle), WTFMove(sandboxExtensionForUpload));
    47874787
    47884788        retainedSelf->_visibleContentViewSnapshot = [retainedSelf snapshotViewAfterScreenUpdates:NO];

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

    r225658 r225926  
    8989namespace WebKit {
    9090
    91 RefPtr<InjectedBundle> InjectedBundle::create(const WebProcessCreationParameters& parameters, API::Object* initializationUserData)
     91RefPtr<InjectedBundle> InjectedBundle::create(WebProcessCreationParameters& parameters, API::Object* initializationUserData)
    9292{
    9393    auto bundle = adoptRef(*new InjectedBundle(parameters));
    9494
    95     bundle->m_sandboxExtension = SandboxExtension::create(parameters.injectedBundlePathExtensionHandle);
     95    bundle->m_sandboxExtension = SandboxExtension::create(WTFMove(parameters.injectedBundlePathExtensionHandle));
    9696    if (!bundle->initialize(parameters, initializationUserData))
    9797        return nullptr;

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

    r218534 r225926  
    7575class InjectedBundle : public API::ObjectImpl<API::Object::Type::Bundle> {
    7676public:
    77     static RefPtr<InjectedBundle> create(const WebProcessCreationParameters&, API::Object* initializationUserData);
     77    static RefPtr<InjectedBundle> create(WebProcessCreationParameters&, API::Object* initializationUserData);
    7878
    7979    ~InjectedBundle();

  • trunk/Source/WebKit/WebProcess/MediaStream/MediaDeviceSandboxExtensions.cpp

    r209512 r225926  
    6161    ASSERT_WITH_SECURITY_IMPLICATION(m_ids.size() == m_handles.size());
    6262    ASSERT_WITH_SECURITY_IMPLICATION(i < m_ids.size());
    63     return { m_ids[i], SandboxExtension::create(m_handles[i]) };
    64 }
    65 
    66 const std::pair<String, RefPtr<SandboxExtension>> MediaDeviceSandboxExtensions::operator[](size_t i) const
    67 {
    68     ASSERT_WITH_SECURITY_IMPLICATION(m_ids.size() == m_handles.size());
    69     ASSERT_WITH_SECURITY_IMPLICATION(i < m_ids.size());
    70     return { m_ids[i], SandboxExtension::create(m_handles[i]) };
     63    return { m_ids[i], SandboxExtension::create(WTFMove(m_handles[i])) };
    7164}
    7265

  • trunk/Source/WebKit/WebProcess/MediaStream/MediaDeviceSandboxExtensions.h

    r209512 r225926  
    4444
    4545    std::pair<String, RefPtr<SandboxExtension>> operator[](size_t i);
    46     const std::pair<String, RefPtr<SandboxExtension>> operator[](size_t i) const;
    4746    size_t size() const;
    4847

  • trunk/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp

    r225395 r225926  
    208208}
    209209
    210 void UserMediaPermissionRequestManager::grantUserMediaDeviceSandboxExtensions(const MediaDeviceSandboxExtensions& extensions)
     210void UserMediaPermissionRequestManager::grantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions&& extensions)
    211211{
    212212    for (size_t i = 0; i < extensions.size(); i++) {
    213         auto& extension = extensions[i];
     213        const auto& extension = extensions[i];
    214214        extension.second->consume();
    215215        m_userMediaDeviceSandboxExtensions.add(extension.first, extension.second.copyRef());

  • trunk/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h

    r225395 r225926  
    5353    void didCompleteMediaDeviceEnumeration(uint64_t, const Vector<WebCore::CaptureDevice>& deviceList, String&& deviceIdentifierHashSalt, bool originHasPersistentAccess);
    5454
    55     void grantUserMediaDeviceSandboxExtensions(const MediaDeviceSandboxExtensions&);
     55    void grantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions&&);
    5656    void revokeUserMediaDeviceSandboxExtensions(const Vector<String>&);
    5757

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp

    r225282 r225926  
    198198    ASSERT(pathnames.size() == sandboxExtensionsHandleArray.size());
    199199    for (size_t i = 0; i < sandboxExtensionsHandleArray.size(); i++) {
    200         if (RefPtr<SandboxExtension> extension = SandboxExtension::create(sandboxExtensionsHandleArray[i]))
     200        if (RefPtr<SandboxExtension> extension = SandboxExtension::create(WTFMove(sandboxExtensionsHandleArray[i])))
    201201            extension->consumePermanently();
    202202    }

  • trunk/Source/WebKit/WebProcess/WebPage/WebBackForwardListProxy.cpp

    r222824 r225926  
    167167    SandboxExtension::Handle sandboxExtensionHandle;
    168168    m_page->sendSync(Messages::WebPageProxy::BackForwardGoToItem(historyItemToIDMap().get(item).itemID), Messages::WebPageProxy::BackForwardGoToItem::Reply(sandboxExtensionHandle));
    169     m_page->sandboxExtensionTracker().beginLoad(m_page->mainWebFrame(), sandboxExtensionHandle);
     169    m_page->sandboxExtensionTracker().beginLoad(m_page->mainWebFrame(), WTFMove(sandboxExtensionHandle));
    170170}
    171171

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

    r225925 r225926  
    12041204#endif
    12051205
    1206 void WebPage::loadRequest(const LoadParameters& loadParameters)
     1206void WebPage::loadRequest(LoadParameters&& loadParameters)
    12071207{
    12081208    SendStopResponsivenessTimer stopper;
    … …  
    12101210    m_pendingNavigationID = loadParameters.navigationID;
    12111211
    1212     m_sandboxExtensionTracker.beginLoad(m_mainFrame.get(), loadParameters.sandboxExtensionHandle);
     1212    m_sandboxExtensionTracker.beginLoad(m_mainFrame.get(), WTFMove(loadParameters.sandboxExtensionHandle));
    12131213
    12141214    // Let the InjectedBundle know we are about to start the load, passing the user data from the UIProcess
    … …  
    13291329}
    13301330
    1331 void WebPage::reload(uint64_t navigationID, uint32_t reloadOptions, const SandboxExtension::Handle& sandboxExtensionHandle)
     1331void WebPage::reload(uint64_t navigationID, uint32_t reloadOptions, SandboxExtension::Handle&& sandboxExtensionHandle)
    13321332{
    13331333    SendStopResponsivenessTimer stopper;
    … …  
    13361336    m_pendingNavigationID = navigationID;
    13371337
    1338     m_sandboxExtensionTracker.beginLoad(m_mainFrame.get(), sandboxExtensionHandle);
     1338    m_sandboxExtensionTracker.beginLoad(m_mainFrame.get(), WTFMove(sandboxExtensionHandle));
    13391339    corePage()->userInputBridge().reloadFrame(m_mainFrame->coreFrame(), OptionSet<ReloadOption>::fromRaw(reloadOptions));
    13401340}
    … …  
    33173317}
    33183318#else
    3319 void WebPage::performDragControllerAction(DragControllerAction action, const WebCore::DragData& dragData, const SandboxExtension::Handle& sandboxExtensionHandle, const SandboxExtension::HandleArray& sandboxExtensionsHandleArray)
     3319void WebPage::performDragControllerAction(DragControllerAction action, const WebCore::DragData& dragData, SandboxExtension::Handle&& sandboxExtensionHandle, SandboxExtension::HandleArray&& sandboxExtensionsHandleArray)
    33203320{
    33213321    if (!m_page) {
    … …  
    33433343        ASSERT(!m_pendingDropSandboxExtension);
    33443344
    3345         m_pendingDropSandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
     3345        m_pendingDropSandboxExtension = SandboxExtension::create(WTFMove(sandboxExtensionHandle));
    33463346        for (size_t i = 0; i < sandboxExtensionsHandleArray.size(); i++) {
    3347             if (RefPtr<SandboxExtension> extension = SandboxExtension::create(sandboxExtensionsHandleArray[i]))
     3347            if (RefPtr<SandboxExtension> extension = SandboxExtension::create(WTFMove(sandboxExtensionsHandleArray[i])))
    33483348                m_pendingDropExtensionsForFileUpload.append(extension);
    33493349        }
    … …  
    36143614}
    36153615#if ENABLE(SANDBOX_EXTENSIONS)
    3616 void WebPage::grantUserMediaDeviceSandboxExtensions(const MediaDeviceSandboxExtensions& extensions)
    3617 {
    3618     m_userMediaPermissionRequestManager->grantUserMediaDeviceSandboxExtensions(extensions);
     3616void WebPage::grantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions&& extensions)
     3617{
     3618    m_userMediaPermissionRequestManager->grantUserMediaDeviceSandboxExtensions(WTFMove(extensions));
    36193619}
    36203620
    … …  
    39403940}
    39413941
    3942 void WebPage::SandboxExtensionTracker::beginLoad(WebFrame* frame, const SandboxExtension::Handle& handle)
     3942void WebPage::SandboxExtensionTracker::beginLoad(WebFrame* frame, SandboxExtension::Handle&& handle)
    39433943{
    39443944    ASSERT_UNUSED(frame, frame->isMainFrame());
    39453945
    3946     setPendingProvisionalSandboxExtension(SandboxExtension::create(handle));
     3946    setPendingProvisionalSandboxExtension(SandboxExtension::create(WTFMove(handle)));
    39473947}
    39483948

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r225925 r225926  
    659659        void invalidate();
    660660
    661         void beginLoad(WebFrame*, const SandboxExtension::Handle& handle);
     661        void beginLoad(WebFrame*, SandboxExtension::Handle&&);
    662662        void willPerformLoadDragDestinationAction(RefPtr<SandboxExtension>&& pendingDropSandboxExtension);
    663663        void didStartProvisionalLoad(WebFrame*);
    … …  
    764764
    765765#if ENABLE(DRAG_SUPPORT) && !PLATFORM(GTK)
    766     void performDragControllerAction(DragControllerAction, const WebCore::DragData&, const SandboxExtension::Handle&, const SandboxExtension::HandleArray&);
     766    void performDragControllerAction(DragControllerAction, const WebCore::DragData&, SandboxExtension::Handle&&, SandboxExtension::HandleArray&&);
    767767#endif
    768768
    … …  
    11121112    void tryClose();
    11131113    void platformDidReceiveLoadParameters(const LoadParameters&);
    1114     void loadRequest(const LoadParameters&);
     1114    void loadRequest(LoadParameters&&);
    11151115    void loadData(const LoadParameters&);
    11161116    void loadString(const LoadParameters&);
    11171117    void loadAlternateHTMLString(const LoadParameters&);
    11181118    void navigateToPDFLinkWithSimulatedClick(const String& url, WebCore::IntPoint documentPoint, WebCore::IntPoint screenPoint);
    1119     void reload(uint64_t navigationID, uint32_t reloadOptions, const SandboxExtension::Handle&);
     1119    void reload(uint64_t navigationID, uint32_t reloadOptions, SandboxExtension::Handle&&);
    11201120    void goForward(uint64_t navigationID, uint64_t);
    11211121    void goBack(uint64_t navigationID, uint64_t);
    … …  
    12611261
    12621262#if ENABLE(MEDIA_STREAM) && ENABLE(SANDBOX_EXTENSIONS)
    1263     void grantUserMediaDeviceSandboxExtensions(const MediaDeviceSandboxExtensions&);
     1263    void grantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions&&);
    12641264    void revokeUserMediaDeviceSandboxExtensions(const Vector<String>&);
    12651265#endif

  • trunk/Source/WebKit/WebProcess/WebProcess.cpp

    r225863 r225926  
    11961196}
    11971197   
    1198 void WebProcess::startMemorySampler(const SandboxExtension::Handle& sampleLogFileHandle, const String& sampleLogFilePath, const double interval)
     1198void WebProcess::startMemorySampler(SandboxExtension::Handle&& sampleLogFileHandle, const String& sampleLogFilePath, const double interval)
    11991199{
    12001200#if ENABLE(MEMORY_SAMPLER)   
    1201     WebMemorySampler::singleton()->start(sampleLogFileHandle, sampleLogFilePath, interval);
     1201    WebMemorySampler::singleton()->start(WTFMove(sampleLogFileHandle), sampleLogFilePath, interval);
    12021202#else
    12031203    UNUSED_PARAM(sampleLogFileHandle);

  • trunk/Source/WebKit/WebProcess/WebProcess.h

    r225592 r225926  
    283283    void setEnhancedAccessibility(bool);
    284284   
    285     void startMemorySampler(const SandboxExtension::Handle&, const String&, const double);
     285    void startMemorySampler(SandboxExtension::Handle&&, const String&, const double);
    286286    void stopMemorySampler();
    287287   
Note: See TracChangeset for help on using the changeset viewer.