Changeset 196442 in webkit


Ignore:
Timestamp:
Feb 11, 2016 2:34:36 PM (8 years ago)
Author:
jer.noble@apple.com
Message:

Make MediaResourceLoader behave more like a CachedResourceLoader.
https://bugs.webkit.org/show_bug.cgi?id=154117

Reviewed by Alex Christensen.

MediaResourceLoader currently can only handle a single request at a time. Split the class
into two, MediaResourceLoader and MediaResource, effectively wrapping CachedResourceLoader
and CachedRawResource respectively. With this devision, the same loader can be used to issue
multiple simultaneous resource requests.

This necessecitates splitting PlatformMediaResource into two classes as well. To simplify
the HTMLMediaElement, MediaPlayer, and MediaPlayerClient APIs, do not require a client
object when creating the loader; instead, the client is required to create the resource.
This also matches the CachedRawResource API.

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::mediaPlayerCreateResourceLoader): Remove the client parameter.

  • html/HTMLMediaElement.h:
  • loader/MediaResourceLoader.cpp:

(WebCore::MediaResourceLoader::MediaResourceLoader):
(WebCore::MediaResourceLoader::~MediaResourceLoader):
(WebCore::MediaResourceLoader::requestResource): Renamed from start().
(WebCore::MediaResourceLoader::removeResource): Remove resource from live resource list.
(WebCore::MediaResource::create): Utility factory.
(WebCore::MediaResource::MediaResource):
(WebCore::MediaResource::~MediaResource):
(WebCore::MediaResource::stop): Moved from MediaResourceLoader.
(WebCore::MediaResource::setDefersLoading): Ditto.
(WebCore::MediaResource::responseReceived): Ditto.
(WebCore::MediaResource::redirectReceived): Ditto.
(WebCore::MediaResource::dataSent): Ditto.
(WebCore::MediaResource::dataReceived): Ditto.
(WebCore::MediaResource::notifyFinished): Ditto.
(WebCore::MediaResource::getOrCreateReadBuffer): Ditto.

  • loader/MediaResourceLoader.h:
  • platform/graphics/MediaPlayer.cpp:

(WebCore::MediaPlayer::createResourceLoader):

  • platform/graphics/MediaPlayer.h:

(WebCore::MediaPlayerClient::mediaPlayerCreateResourceLoader):

  • platform/graphics/PlatformMediaResourceLoader.h:

(WebCore::PlatformMediaResourceClient::~PlatformMediaResourceClient): Renamed from PlatformMediaResourceLoaderClient.
(WebCore::PlatformMediaResourceClient::responseReceived): Client methods now take a reference to the resource.
(WebCore::PlatformMediaResourceClient::redirectReceived): Ditto.
(WebCore::PlatformMediaResourceClient::dataSent): Ditto.
(WebCore::PlatformMediaResourceClient::dataReceived): Ditto.
(WebCore::PlatformMediaResourceClient::accessControlCheckFailed): Ditto.
(WebCore::PlatformMediaResourceClient::loadFailed): Ditto.
(WebCore::PlatformMediaResourceClient::loadFinished): Ditto.
(WebCore::PlatformMediaResourceClient::getOrCreateReadBuffer): Ditto.
(WebCore::PlatformMediaResourceLoader::PlatformMediaResourceLoader): Ditto.
(WebCore::PlatformMediaResource::PlatformMediaResource):
(WebCore::PlatformMediaResource::~PlatformMediaResource):
(WebCore::PlatformMediaResource::setClient):

  • platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:

(webKitWebSrcStart):
(webKitWebSrcNeedData):
(webKitWebSrcEnoughData):
(CachedResourceStreamingClient::getOrCreateReadBuffer):
(CachedResourceStreamingClient::responseReceived):
(CachedResourceStreamingClient::dataReceived):
(CachedResourceStreamingClient::accessControlCheckFailed):
(CachedResourceStreamingClient::loadFailed):
(CachedResourceStreamingClient::loadFinished):

Location:
trunk/Source/WebCore
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r196439 r196442  
     12016-02-11  Jer Noble  <jer.noble@apple.com>
     2
     3        Make MediaResourceLoader behave more like a CachedResourceLoader.
     4        https://bugs.webkit.org/show_bug.cgi?id=154117
     5
     6        Reviewed by Alex Christensen.
     7
     8        MediaResourceLoader currently can only handle a single request at a time. Split the class
     9        into two, MediaResourceLoader and MediaResource, effectively wrapping CachedResourceLoader
     10        and CachedRawResource respectively. With this devision, the same loader can be used to issue
     11        multiple simultaneous resource requests.
     12
     13        This necessecitates splitting PlatformMediaResource into two classes as well.  To simplify
     14        the HTMLMediaElement, MediaPlayer, and MediaPlayerClient APIs, do not require a client
     15        object when creating the loader; instead, the client is required to create the resource.
     16        This also matches the CachedRawResource API.
     17
     18        * html/HTMLMediaElement.cpp:
     19        (WebCore::HTMLMediaElement::mediaPlayerCreateResourceLoader): Remove the client parameter.
     20        * html/HTMLMediaElement.h:
     21        * loader/MediaResourceLoader.cpp:
     22        (WebCore::MediaResourceLoader::MediaResourceLoader):
     23        (WebCore::MediaResourceLoader::~MediaResourceLoader):
     24        (WebCore::MediaResourceLoader::requestResource): Renamed from start().
     25        (WebCore::MediaResourceLoader::removeResource): Remove resource from live resource list.
     26        (WebCore::MediaResource::create): Utility factory.
     27        (WebCore::MediaResource::MediaResource):
     28        (WebCore::MediaResource::~MediaResource):
     29        (WebCore::MediaResource::stop): Moved from MediaResourceLoader.
     30        (WebCore::MediaResource::setDefersLoading): Ditto.
     31        (WebCore::MediaResource::responseReceived): Ditto.
     32        (WebCore::MediaResource::redirectReceived): Ditto.
     33        (WebCore::MediaResource::dataSent): Ditto.
     34        (WebCore::MediaResource::dataReceived): Ditto.
     35        (WebCore::MediaResource::notifyFinished): Ditto.
     36        (WebCore::MediaResource::getOrCreateReadBuffer): Ditto.
     37        * loader/MediaResourceLoader.h:
     38        * platform/graphics/MediaPlayer.cpp:
     39        (WebCore::MediaPlayer::createResourceLoader):
     40        * platform/graphics/MediaPlayer.h:
     41        (WebCore::MediaPlayerClient::mediaPlayerCreateResourceLoader):
     42        * platform/graphics/PlatformMediaResourceLoader.h:
     43        (WebCore::PlatformMediaResourceClient::~PlatformMediaResourceClient): Renamed from PlatformMediaResourceLoaderClient.
     44        (WebCore::PlatformMediaResourceClient::responseReceived): Client methods now take a reference to the resource.
     45        (WebCore::PlatformMediaResourceClient::redirectReceived): Ditto.
     46        (WebCore::PlatformMediaResourceClient::dataSent): Ditto.
     47        (WebCore::PlatformMediaResourceClient::dataReceived): Ditto.
     48        (WebCore::PlatformMediaResourceClient::accessControlCheckFailed): Ditto.
     49        (WebCore::PlatformMediaResourceClient::loadFailed): Ditto.
     50        (WebCore::PlatformMediaResourceClient::loadFinished): Ditto.
     51        (WebCore::PlatformMediaResourceClient::getOrCreateReadBuffer): Ditto.
     52        (WebCore::PlatformMediaResourceLoader::PlatformMediaResourceLoader): Ditto.
     53        (WebCore::PlatformMediaResource::PlatformMediaResource):
     54        (WebCore::PlatformMediaResource::~PlatformMediaResource):
     55        (WebCore::PlatformMediaResource::setClient):
     56        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
     57        (webKitWebSrcStart):
     58        (webKitWebSrcNeedData):
     59        (webKitWebSrcEnoughData):
     60        (CachedResourceStreamingClient::getOrCreateReadBuffer):
     61        (CachedResourceStreamingClient::responseReceived):
     62        (CachedResourceStreamingClient::dataReceived):
     63        (CachedResourceStreamingClient::accessControlCheckFailed):
     64        (CachedResourceStreamingClient::loadFailed):
     65        (CachedResourceStreamingClient::loadFinished):
     66
    1672016-02-11  Zalan Bujtas  <zalan@apple.com>
    268
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r196401 r196442  
    60936093}
    60946094
    6095 RefPtr<PlatformMediaResourceLoader> HTMLMediaElement::mediaPlayerCreateResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient> client)
    6096 {
    6097     return adoptRef(*new MediaResourceLoader(document(), fastGetAttribute(HTMLNames::crossoriginAttr), WTFMove(client)));
     6095RefPtr<PlatformMediaResourceLoader> HTMLMediaElement::mediaPlayerCreateResourceLoader()
     6096{
     6097    return adoptRef(*new MediaResourceLoader(document(), fastGetAttribute(HTMLNames::crossoriginAttr)));
    60986098}
    60996099
  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r195953 r196442  
    596596    virtual bool mediaPlayerIsLooping() const override;
    597597    virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() override;
    598     virtual RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient>) override;
     598    virtual RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() override;
    599599
    600600#if PLATFORM(WIN) && USE(AVFOUNDATION)
  • trunk/Source/WebCore/loader/MediaResourceLoader.cpp

    r195770 r196442  
    3939namespace WebCore {
    4040
    41 MediaResourceLoader::MediaResourceLoader(Document& document, const String& crossOriginMode, std::unique_ptr<PlatformMediaResourceLoaderClient> client)
    42     : PlatformMediaResourceLoader(WTFMove(client))
    43     , m_document(document)
     41MediaResourceLoader::MediaResourceLoader(Document& document, const String& crossOriginMode)
     42    : m_document(document)
    4443    , m_crossOriginMode(crossOriginMode)
    45     , m_didPassAccessControlCheck(false)
    4644{
    4745}
     
    4947MediaResourceLoader::~MediaResourceLoader()
    5048{
    51     stop();
     49    ASSERT(m_resources.isEmpty());
    5250}
    5351
    54 bool MediaResourceLoader::start(const ResourceRequest& request, LoadOptions options)
     52RefPtr<PlatformMediaResource> MediaResourceLoader::requestResource(const ResourceRequest& request, LoadOptions options)
    5553{
    56     if (m_resource)
    57         return false;
    58 
    5954    DataBufferingPolicy bufferingPolicy = options & LoadOption::BufferData ? WebCore::BufferData : WebCore::DoNotBufferData;
    6055    RequestOriginPolicy corsPolicy = !m_crossOriginMode.isNull() ? PotentiallyCrossOriginEnabled : UseDefaultOriginRestrictionsForType;
     
    6762        updateRequestForAccessControl(cacheRequest.mutableResourceRequest(), m_document.securityOrigin(), allowCredentials);
    6863
    69     m_didPassAccessControlCheck = false;
     64    CachedResourceHandle<CachedRawResource> resource = m_document.cachedResourceLoader().requestRawResource(cacheRequest);
     65    if (!resource)
     66        return nullptr;
    7067
    71     m_resource = m_document.cachedResourceLoader().requestRawResource(cacheRequest);
    72     if (!m_resource)
    73         return false;
     68    Ref<MediaResource> mediaResource = MediaResource::create(*this, resource);
     69    m_resources.add(mediaResource.ptr());
    7470
    75     m_resource->addClient(this);
    76     return true;
     71    return WTFMove(mediaResource);
    7772}
    7873
    79 void MediaResourceLoader::stop()
     74void MediaResourceLoader::removeResource(MediaResource& mediaResource)
     75{
     76    ASSERT(m_resources.contains(&mediaResource));
     77    m_resources.remove(&mediaResource);
     78}
     79
     80Ref<MediaResource> MediaResource::create(MediaResourceLoader& loader, CachedResourceHandle<CachedRawResource> resource)
     81{
     82    return adoptRef(*new MediaResource(loader, resource));
     83}
     84
     85MediaResource::MediaResource(MediaResourceLoader& loader, CachedResourceHandle<CachedRawResource> resource)
     86    : m_loader(loader)
     87    , m_resource(resource)
     88{
     89    ASSERT(resource);
     90    resource->addClient(this);
     91}
     92
     93MediaResource::~MediaResource()
     94{
     95    stop();
     96    m_loader->removeResource(*this);
     97}
     98
     99void MediaResource::stop()
    80100{
    81101    if (!m_resource)
     
    86106}
    87107
    88 void MediaResourceLoader::setDefersLoading(bool defersLoading)
     108void MediaResource::setDefersLoading(bool defersLoading)
    89109{
    90110    if (m_resource)
     
    92112}
    93113
    94 void MediaResourceLoader::responseReceived(CachedResource* resource, const ResourceResponse& response)
     114void MediaResource::responseReceived(CachedResource* resource, const ResourceResponse& response)
    95115{
    96116    ASSERT_UNUSED(resource, resource == m_resource);
    97117
    98     RefPtr<MediaResourceLoader> protect(this);
    99     if (!m_crossOriginMode.isNull() && !resource->passesSameOriginPolicyCheck(*m_document.securityOrigin())) {
     118    RefPtr<MediaResource> protect(this);
     119    if (!m_loader->crossOriginMode().isNull() && !resource->passesSameOriginPolicyCheck(*m_loader->document().securityOrigin())) {
    100120        static NeverDestroyed<const String> consoleMessage("Cross-origin media resource load denied by Cross-Origin Resource Sharing policy.");
    101         m_document.addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage.get());
     121        m_loader->document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage.get());
    102122        m_didPassAccessControlCheck = false;
    103         m_client->accessControlCheckFailed(ResourceError(errorDomainWebKitInternal, 0, response.url(), consoleMessage.get()));
     123        if (m_client)
     124            m_client->accessControlCheckFailed(*this, ResourceError(errorDomainWebKitInternal, 0, response.url(), consoleMessage.get()));
    104125        stop();
    105126        return;
    106127    }
    107128
    108     m_didPassAccessControlCheck = !m_crossOriginMode.isNull();
    109     m_client->responseReceived(response);
     129    m_didPassAccessControlCheck = !m_loader->crossOriginMode().isNull();
     130    if (m_client)
     131        m_client->responseReceived(*this, response);
    110132}
    111133
    112 void MediaResourceLoader::dataReceived(CachedResource* resource, const char* data, int dataLength)
     134void MediaResource::redirectReceived(CachedResource* resource, ResourceRequest& request, const ResourceResponse& response)
    113135{
    114136    ASSERT_UNUSED(resource, resource == m_resource);
    115137
    116     RefPtr<MediaResourceLoader> protect(this);
    117     m_client->dataReceived(data, dataLength);
     138    RefPtr<MediaResource> protect(this);
     139    if (m_client)
     140        m_client->redirectReceived(*this, request, response);
    118141}
    119142
    120 void MediaResourceLoader::notifyFinished(CachedResource* resource)
     143void MediaResource::dataSent(CachedResource* resource, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
     144{
     145    ASSERT_UNUSED(resource, resource == m_resource);
     146
     147    RefPtr<MediaResource> protect(this);
     148    if (m_client)
     149        m_client->dataSent(*this, bytesSent, totalBytesToBeSent);
     150}
     151
     152void MediaResource::dataReceived(CachedResource* resource, const char* data, int dataLength)
     153{
     154    ASSERT_UNUSED(resource, resource == m_resource);
     155
     156    RefPtr<MediaResource> protect(this);
     157    if (m_client)
     158        m_client->dataReceived(*this, data, dataLength);
     159}
     160
     161void MediaResource::notifyFinished(CachedResource* resource)
    121162{
    122163    ASSERT(resource == m_resource);
    123164
    124     RefPtr<MediaResourceLoader> protect(this);
    125     if (resource->loadFailedOrCanceled())
    126         m_client->loadFailed(resource->resourceError());
    127     else
    128         m_client->loadFinished();
     165    RefPtr<MediaResource> protect(this);
     166    if (m_client) {
     167        if (resource->loadFailedOrCanceled())
     168            m_client->loadFailed(*this, resource->resourceError());
     169        else
     170            m_client->loadFinished(*this);
     171    }
    129172    stop();
    130173}
    131174
    132175#if USE(SOUP)
    133 char* MediaResourceLoader::getOrCreateReadBuffer(CachedResource* resource, size_t requestedSize, size_t& actualSize)
     176char* MediaResource::getOrCreateReadBuffer(CachedResource* resource, size_t requestedSize, size_t& actualSize)
    134177{
    135178    ASSERT_UNUSED(resource, resource == m_resource);
    136     return m_client->getOrCreateReadBuffer(requestedSize, actualSize);
     179    return m_client ? m_client->getOrCreateReadBuffer(*this, requestedSize, actualSize) : nullptr;
    137180}
    138181#endif
  • trunk/Source/WebCore/loader/MediaResourceLoader.h

    r175050 r196442  
    3131#include "CachedResourceHandle.h"
    3232#include "PlatformMediaResourceLoader.h"
     33#include <wtf/HashSet.h>
     34#include <wtf/Ref.h>
    3335#include <wtf/text/WTFString.h>
    3436
     
    3739class CachedRawResource;
    3840class Document;
     41class MediaResource;
    3942
    40 class MediaResourceLoader final : public PlatformMediaResourceLoader, CachedRawResourceClient {
     43class MediaResourceLoader final : public PlatformMediaResourceLoader {
    4144public:
    42     MediaResourceLoader(Document&, const String& crossOriginMode, std::unique_ptr<PlatformMediaResourceLoaderClient>);
    43     virtual ~MediaResourceLoader();
     45    WEBCORE_EXPORT MediaResourceLoader(Document&, const String& crossOriginMode);
     46    WEBCORE_EXPORT virtual ~MediaResourceLoader();
    4447
    45     virtual bool start(const ResourceRequest&, LoadOptions) override;
    46     virtual void stop() override;
    47     virtual void setDefersLoading(bool) override;
    48     virtual bool didPassAccessControlCheck() const override { return m_didPassAccessControlCheck; }
     48    RefPtr<PlatformMediaResource> requestResource(const ResourceRequest&, LoadOptions) override;
     49    void removeResource(MediaResource&);
    4950
    50     // CachedResourceClient
    51     virtual void responseReceived(CachedResource*, const ResourceResponse&) override;
    52     virtual void dataReceived(CachedResource*, const char*, int) override;
    53     virtual void notifyFinished(CachedResource*) override;
    54 #if USE(SOUP)
    55     virtual char* getOrCreateReadBuffer(CachedResource*, size_t /*requestedSize*/, size_t& /*actualSize*/) override;
    56 #endif
     51    Document& document() { return m_document; }
     52    const String& crossOriginMode() const { return m_crossOriginMode; }
    5753
    5854private:
    5955    Document& m_document;
    6056    String m_crossOriginMode;
    61     bool m_didPassAccessControlCheck;
     57    HashSet<MediaResource*> m_resources;
     58};
     59
     60class MediaResource : public PlatformMediaResource, CachedRawResourceClient {
     61public:
     62    static Ref<MediaResource> create(MediaResourceLoader&, CachedResourceHandle<CachedRawResource>);
     63    virtual ~MediaResource();
     64
     65    // PlatformMediaResource
     66    void stop() override;
     67    void setDefersLoading(bool) override;
     68    bool didPassAccessControlCheck() const override { return m_didPassAccessControlCheck; }
     69
     70    // CachedResourceClient
     71    void responseReceived(CachedResource*, const ResourceResponse&) override;
     72    void redirectReceived(CachedResource*, ResourceRequest&, const ResourceResponse&) override;
     73    void dataSent(CachedResource*, unsigned long long, unsigned long long) override;
     74    void dataReceived(CachedResource*, const char*, int) override;
     75    void notifyFinished(CachedResource*) override;
     76#if USE(SOUP)
     77    char* getOrCreateReadBuffer(CachedResource*, size_t /*requestedSize*/, size_t& /*actualSize*/) override;
     78#endif
     79
     80private:
     81    MediaResource(MediaResourceLoader&, CachedResourceHandle<CachedRawResource>);
     82    Ref<MediaResourceLoader> m_loader;
     83    bool m_didPassAccessControlCheck { false };
    6284    CachedResourceHandle<CachedRawResource> m_resource;
    6385};
  • trunk/Source/WebCore/platform/graphics/MediaPlayer.cpp

    r196117 r196442  
    12381238}
    12391239
    1240 PassRefPtr<PlatformMediaResourceLoader> MediaPlayer::createResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient> client)
    1241 {
    1242     return m_client.mediaPlayerCreateResourceLoader(WTFMove(client));
     1240PassRefPtr<PlatformMediaResourceLoader> MediaPlayer::createResourceLoader()
     1241{
     1242    return m_client.mediaPlayerCreateResourceLoader();
    12431243}
    12441244
  • trunk/Source/WebCore/platform/graphics/MediaPlayer.h

    r195951 r196442  
    239239    virtual bool mediaPlayerIsLooping() const { return false; }
    240240    virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() { return 0; }
    241     virtual RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient>) { return nullptr; }
     241    virtual RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() { return nullptr; }
    242242    virtual bool doesHaveAttribute(const AtomicString&, AtomicString* = 0) const { return false; }
    243243
     
    547547
    548548    CachedResourceLoader* cachedResourceLoader();
    549     PassRefPtr<PlatformMediaResourceLoader> createResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient>);
     549    PassRefPtr<PlatformMediaResourceLoader> createResourceLoader();
    550550
    551551#if ENABLE(VIDEO_TRACK)
  • trunk/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h

    r194496 r196442  
    3434namespace WebCore {
    3535
     36class PlatformMediaResource;
    3637class ResourceError;
    3738class ResourceRequest;
    3839class ResourceResponse;
    3940
    40 class PlatformMediaResourceLoaderClient {
     41class PlatformMediaResourceClient {
    4142public:
    42     virtual ~PlatformMediaResourceLoaderClient() { }
     43    virtual ~PlatformMediaResourceClient() { }
    4344
    44     virtual void responseReceived(const ResourceResponse&) { }
    45     virtual void dataReceived(const char*, int) { }
    46     virtual void accessControlCheckFailed(const ResourceError&) { }
    47     virtual void loadFailed(const ResourceError&) { }
    48     virtual void loadFinished() { }
     45    virtual void responseReceived(PlatformMediaResource&, const ResourceResponse&) { }
     46    virtual void redirectReceived(PlatformMediaResource&, ResourceRequest&, const ResourceResponse&) { }
     47    virtual void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) { }
     48    virtual void dataReceived(PlatformMediaResource&, const char*, int) { }
     49    virtual void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) { }
     50    virtual void loadFailed(PlatformMediaResource&, const ResourceError&) { }
     51    virtual void loadFinished(PlatformMediaResource&) { }
    4952#if USE(SOUP)
    50     virtual char* getOrCreateReadBuffer(size_t /*requestedSize*/, size_t& /*actualSize*/) { return nullptr; };
     53    virtual char* getOrCreateReadBuffer(PlatformMediaResource&, size_t /*requestedSize*/, size_t& /*actualSize*/) { return nullptr; };
    5154#endif
    5255};
     
    6265    virtual ~PlatformMediaResourceLoader() { }
    6366
    64     virtual bool start(const ResourceRequest&, LoadOptions) = 0;
     67    virtual RefPtr<PlatformMediaResource> requestResource(const ResourceRequest&, LoadOptions) = 0;
     68
     69protected:
     70    PlatformMediaResourceLoader() { }
     71};
     72
     73class PlatformMediaResource : public RefCounted<PlatformMediaResource> {
     74    WTF_MAKE_NONCOPYABLE(PlatformMediaResource); WTF_MAKE_FAST_ALLOCATED;
     75public:
     76    PlatformMediaResource() { }
     77    virtual ~PlatformMediaResource() { }
    6578    virtual void stop() { }
    6679    virtual void setDefersLoading(bool) { }
    6780    virtual bool didPassAccessControlCheck() const { return false; }
    6881
     82    void setClient(std::unique_ptr<PlatformMediaResourceClient>&& client) { m_client = WTFMove(client); }
     83
    6984protected:
    70     explicit PlatformMediaResourceLoader(std::unique_ptr<PlatformMediaResourceLoaderClient> client)
    71         : m_client(WTFMove(client))
    72     {
    73     }
    74 
    75     std::unique_ptr<PlatformMediaResourceLoaderClient> m_client;
     85    std::unique_ptr<PlatformMediaResourceClient> m_client;
    7686};
    7787
  • trunk/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

    r192102 r196442  
    6363};
    6464
    65 class CachedResourceStreamingClient final : public PlatformMediaResourceLoaderClient, public StreamingClient {
     65class CachedResourceStreamingClient final : public PlatformMediaResourceClient, public StreamingClient {
    6666    WTF_MAKE_NONCOPYABLE(CachedResourceStreamingClient);
    6767    public:
     
    7070
    7171    private:
    72         // PlatformMediaResourceLoaderClient virtual methods.
     72        // PlatformMediaResourceClient virtual methods.
    7373#if USE(SOUP)
    74         virtual char* getOrCreateReadBuffer(size_t requestedSize, size_t& actualSize) override;
     74        virtual char* getOrCreateReadBuffer(PlatformMediaResource&, size_t requestedSize, size_t& actualSize) override;
    7575#endif
    76         virtual void responseReceived(const ResourceResponse&) override;
    77         virtual void dataReceived(const char*, int) override;
    78         virtual void accessControlCheckFailed(const ResourceError&) override;
    79         virtual void loadFailed(const ResourceError&) override;
    80         virtual void loadFinished() override;
     76        virtual void responseReceived(PlatformMediaResource&, const ResourceResponse&) override;
     77        virtual void dataReceived(PlatformMediaResource&, const char*, int) override;
     78        virtual void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;
     79        virtual void loadFailed(PlatformMediaResource&, const ResourceError&) override;
     80        virtual void loadFinished(PlatformMediaResource&) override;
    8181};
    8282
     
    127127
    128128    RefPtr<PlatformMediaResourceLoader> loader;
     129    RefPtr<PlatformMediaResource> resource;
    129130    ResourceHandleStreamingClient* client;
    130131
     
    578579    bool loadFailed = true;
    579580    if (priv->player && !priv->loader)
    580         priv->loader = priv->player->createResourceLoader(std::make_unique<CachedResourceStreamingClient>(src));
     581        priv->loader = priv->player->createResourceLoader();
    581582
    582583    if (priv->loader) {
     
    584585        if (request.url().protocolIs("blob"))
    585586            loadOptions |= PlatformMediaResourceLoader::LoadOption::BufferData;
    586         loadFailed = !priv->loader->start(request, loadOptions);
     587        priv->resource = priv->loader->requestResource(request, loadOptions);
     588        loadFailed = !priv->resource;
     589
     590        if (priv->resource)
     591            priv->resource->setClient(std::make_unique<CachedResourceStreamingClient>(src));
    587592    } else {
    588593        priv->client = new ResourceHandleStreamingClient(src, request);
     
    597602        }
    598603        priv->loader = nullptr;
     604        priv->resource = nullptr;
    599605        locker.unlock();
    600606        webKitWebSrcStop(src);
     
    784790    if (priv->client)
    785791        priv->client->setDefersLoading(false);
    786     if (priv->loader)
    787         priv->loader->setDefersLoading(false);
     792    if (priv->resource)
     793        priv->resource->setDefersLoading(false);
    788794}
    789795
     
    803809    if (priv->client)
    804810        priv->client->setDefersLoading(true);
    805     if (priv->loader)
    806         priv->loader->setDefersLoading(true);
     811    if (priv->resource)
     812        priv->resource->setDefersLoading(true);
    807813}
    808814
     
    10031009
    10041010#if USE(SOUP)
    1005 char* CachedResourceStreamingClient::getOrCreateReadBuffer(size_t requestedSize, size_t& actualSize)
     1011char* CachedResourceStreamingClient::getOrCreateReadBuffer(PlatformMediaResource&, size_t requestedSize, size_t& actualSize)
    10061012{
    10071013    return createReadBuffer(requestedSize, actualSize);
     
    10091015#endif
    10101016
    1011 void CachedResourceStreamingClient::responseReceived(const ResourceResponse& response)
     1017void CachedResourceStreamingClient::responseReceived(PlatformMediaResource&, const ResourceResponse& response)
    10121018{
    10131019    WebKitWebSrcPrivate* priv = WEBKIT_WEB_SRC(m_src)->priv;
    1014     priv->didPassAccessControlCheck = priv->loader->didPassAccessControlCheck();
     1020    priv->didPassAccessControlCheck = priv->resource->didPassAccessControlCheck();
    10151021    handleResponseReceived(response);
    10161022}
    10171023
    1018 void CachedResourceStreamingClient::dataReceived(const char* data, int length)
     1024void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, const char* data, int length)
    10191025{
    10201026    handleDataReceived(data, length);
    10211027}
    10221028
    1023 void CachedResourceStreamingClient::accessControlCheckFailed(const ResourceError& error)
     1029void CachedResourceStreamingClient::accessControlCheckFailed(PlatformMediaResource&, const ResourceError& error)
    10241030{
    10251031    WebKitWebSrc* src = WEBKIT_WEB_SRC(m_src);
     
    10291035}
    10301036
    1031 void CachedResourceStreamingClient::loadFailed(const ResourceError& error)
     1037void CachedResourceStreamingClient::loadFailed(PlatformMediaResource&, const ResourceError& error)
    10321038{
    10331039    WebKitWebSrc* src = WEBKIT_WEB_SRC(m_src);
     
    10411047}
    10421048
    1043 void CachedResourceStreamingClient::loadFinished()
     1049void CachedResourceStreamingClient::loadFinished(PlatformMediaResource&)
    10441050{
    10451051    handleNotifyFinished();
Note: See TracChangeset for help on using the changeset viewer.