⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 243977 in webkit


Ignore:
Timestamp:
Apr 8, 2019, 3:14:24 AM (7 years ago)
Author:
Carlos Garcia Campos
Message:

Merge r243197 - [GStreamer] Switch back to webkitwebsrc for adaptive streaming fragments downloading
​https://bugs.webkit.org/show_bug.cgi?id=195948

Reviewed by Xabier Rodriguez-Calvar.

The webkitwebsrc element now behaves much better when used through
GStreamer's adaptivedemux, so use it for all WebKit media
downloads. The MediaPlayer needed by the webkitwebsrc element now
travels through GstContext messages and queries so that it can be
shared by multiple elements, typically the first webkitwebsrc
element downloads the HLS manifest and then adaptivedemux, through
uridownloader, will create new webkitwebsrc elements for fragments
downloading. Those new elements will query the first webkitwebsrc
element for its context.

The previous hack used to check SecurityOrigins can
also be cleaned-up. The origins are now cached upon reception of
the HTTP headers message from webkitwebsrc.

No new tests, existing http/tests/media/hls tests cover this change.

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:

(WebCore::MediaPlayerPrivateGStreamer::setPlaybinURL):
(WebCore::MediaPlayerPrivateGStreamer::loadFull):
(WebCore::MediaPlayerPrivateGStreamer::handleMessage):
(WebCore::MediaPlayerPrivateGStreamer::loadNextLocation):
(WebCore::MediaPlayerPrivateGStreamer::wouldTaintOrigin const):
(WebCore::convertToInternalProtocol): Deleted.

  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:

(WebCore::MediaPlayerPrivateGStreamerBase::handleSyncMessage):

  • platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:

(webkit_web_src_class_init):
(webKitWebSrcSetContext):
(webKitWebSrcStart):
(webKitWebSrcGetProtocols):
(webKitWebSrcSetUri):
(CachedResourceStreamingClient::responseReceived):
(convertPlaybinURI): Deleted.
(webKitSrcWouldTaintOrigin): Deleted.

  • platform/graphics/gstreamer/WebKitWebSourceGStreamer.h:
Location:
releases/WebKitGTK/webkit-2.24/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • releases/WebKitGTK/webkit-2.24/Source/WebCore/ChangeLog

    r243976 r243977  
     12019-03-20  Philippe Normand  <pnormand@igalia.com>
     2
     3        [GStreamer] Switch back to webkitwebsrc for adaptive streaming fragments downloading
     4        https://bugs.webkit.org/show_bug.cgi?id=195948
     5
     6        Reviewed by Xabier Rodriguez-Calvar.
     7
     8        The webkitwebsrc element now behaves much better when used through
     9        GStreamer's adaptivedemux, so use it for all WebKit media
     10        downloads. The MediaPlayer needed by the webkitwebsrc element now
     11        travels through GstContext messages and queries so that it can be
     12        shared by multiple elements, typically the first webkitwebsrc
     13        element downloads the HLS manifest and then adaptivedemux, through
     14        uridownloader, will create new webkitwebsrc elements for fragments
     15        downloading. Those new elements will query the first webkitwebsrc
     16        element for its context.
     17
     18        The previous hack used to check SecurityOrigins can
     19        also be cleaned-up. The origins are now cached upon reception of
     20        the HTTP headers message from webkitwebsrc.
     21
     22        No new tests, existing http/tests/media/hls tests cover this change.
     23
     24        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
     25        (WebCore::MediaPlayerPrivateGStreamer::setPlaybinURL):
     26        (WebCore::MediaPlayerPrivateGStreamer::loadFull):
     27        (WebCore::MediaPlayerPrivateGStreamer::handleMessage):
     28        (WebCore::MediaPlayerPrivateGStreamer::loadNextLocation):
     29        (WebCore::MediaPlayerPrivateGStreamer::wouldTaintOrigin const):
     30        (WebCore::convertToInternalProtocol): Deleted.
     31        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
     32        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
     33        (WebCore::MediaPlayerPrivateGStreamerBase::handleSyncMessage):
     34        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
     35        (webkit_web_src_class_init):
     36        (webKitWebSrcSetContext):
     37        (webKitWebSrcStart):
     38        (webKitWebSrcGetProtocols):
     39        (webKitWebSrcSetUri):
     40        (CachedResourceStreamingClient::responseReceived):
     41        (convertPlaybinURI): Deleted.
     42        (webKitSrcWouldTaintOrigin): Deleted.
     43        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.h:
     44
    1452019-03-19  Philippe Normand  <pnormand@igalia.com>
    246

  • releases/WebKitGTK/webkit-2.24/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp

    r243976 r243977  
    226226}
    227227
    228 static void convertToInternalProtocol(URL& url)
    229 {
    230     if (url.protocolIsInHTTPFamily() || url.protocolIsBlob())
    231         url.setProtocol("webkit+" + url.protocol());
    232 }
    233 
    234228void MediaPlayerPrivateGStreamer::setPlaybinURL(const URL& url)
    235229{
    … …  
    240234
    241235    m_url = URL(URL(), cleanURLString);
    242     convertToInternalProtocol(m_url);
    243 
    244236    GST_INFO_OBJECT(pipeline(), "Load %s", m_url.string().utf8().data());
    245237    g_object_set(m_pipeline.get(), "uri", m_url.string().utf8().data(), nullptr);
    … …  
    311303    m_player->readyStateChanged();
    312304    m_volumeAndMuteInitialized = false;
    313     m_hasTaintedOrigin = WTF::nullopt;
    314305
    315306    if (!m_delayingLoad)
    … …  
    13601351#endif
    13611352        else if (gst_structure_has_name(structure, "http-headers")) {
    1362             if (const char* uri = gst_structure_get_string(structure, "uri")) {
     1353            const char* redirectionUri = gst_structure_get_string(structure, "redirection-uri");
     1354            const char* uri = redirectionUri ? redirectionUri : gst_structure_get_string(structure, "uri");
     1355            if (uri) {
    13631356                URL url(URL(), uri);
    1364                 convertToInternalProtocol(url);
     1357
     1358                m_origins.add(SecurityOrigin::create(url));
     1359
    13651360                if (url != m_url) {
    13661361                    GST_DEBUG_OBJECT(pipeline(), "Ignoring HTTP response headers for non-main URI.");
    … …  
    13721367                const char* contentLengthHeaderName = httpHeaderNameString(HTTPHeaderName::ContentLength).utf8().data();
    13731368                uint64_t contentLength = 0;
    1374                 if (!gst_structure_get_uint64(responseHeaders.get(), contentLengthHeaderName, &contentLength)) {
    1375                     // souphttpsrc sets a string for Content-Length, so
    1376                     // handle it here, until we remove the webkit+ protocol
    1377                     // prefix from webkitwebsrc.
    1378                     if (const char* contentLengthAsString = gst_structure_get_string(responseHeaders.get(), contentLengthHeaderName)) {
    1379                         contentLength = g_ascii_strtoull(contentLengthAsString, nullptr, 10);
    1380                         if (contentLength == G_MAXUINT64)
    1381                             contentLength = 0;
    1382                     }
    1383                 }
     1369                gst_structure_get_uint64(responseHeaders.get(), contentLengthHeaderName, &contentLength);
    13841370                GST_INFO_OBJECT(pipeline(), "%s stream detected", !contentLength ? "Live" : "Non-live");
    13851371                if (!contentLength) {
    … …  
    13911377            if (gst_structure_get_uint64(structure, "read-position", &m_networkReadPosition))
    13921378                GST_DEBUG_OBJECT(pipeline(), "Updated network read position %" G_GUINT64_FORMAT, m_networkReadPosition);
    1393         } else if (gst_structure_has_name(structure, "adaptive-streaming-statistics")) {
    1394             if (WEBKIT_IS_WEB_SRC(m_source.get()))
    1395                 if (const char* uri = gst_structure_get_string(structure, "uri"))
    1396                     m_hasTaintedOrigin = webKitSrcWouldTaintOrigin(WEBKIT_WEB_SRC(m_source.get()), SecurityOrigin::create(URL(URL(), uri)));
    13971379        } else
    13981380            GST_DEBUG_OBJECT(pipeline(), "Unhandled element message: %" GST_PTR_FORMAT, structure);
    … …  
    21822164        URL baseUrl = gst_uri_is_valid(newLocation) ? URL() : m_url;
    21832165        URL newUrl = URL(baseUrl, newLocation);
    2184         convertToInternalProtocol(newUrl);
    21852166
    21862167        auto securityOrigin = SecurityOrigin::create(m_url);
    … …  
    25912572}
    25922573
    2593 Optional<bool> MediaPlayerPrivateGStreamer::wouldTaintOrigin(const SecurityOrigin&) const
    2594 {
    2595     // Ideally the given origin should always be verified with
    2596     // webKitSrcWouldTaintOrigin() instead of only checking it for
    2597     // adaptive-streaming-statistics. We can't do this yet because HLS fragments
    2598     // are currently downloaded independently from WebKit.
    2599     // See also https://bugs.webkit.org/show_bug.cgi?id=189967.
    2600     return m_hasTaintedOrigin;
    2601 }
    2602 
     2574Optional<bool> MediaPlayerPrivateGStreamer::wouldTaintOrigin(const SecurityOrigin& origin) const
     2575{
     2576    GST_TRACE_OBJECT(pipeline(), "Checking %u origins", m_origins.size());
     2577    for (auto& responseOrigin : m_origins) {
     2578        if (!origin.canAccess(*responseOrigin)) {
     2579            GST_DEBUG_OBJECT(pipeline(), "Found reachable response origin");
     2580            return true;
     2581        }
     2582    }
     2583    GST_DEBUG_OBJECT(pipeline(), "No valid response origin found");
     2584    return false;
     2585}
    26032586
    26042587}

  • releases/WebKitGTK/webkit-2.24/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h

    r243976 r243977  
    291291    mutable uint64_t m_readPositionAtLastDidLoadingProgress { 0 };
    292292
    293     Optional<bool> m_hasTaintedOrigin { WTF::nullopt };
     293    HashSet<RefPtr<WebCore::SecurityOrigin>> m_origins;
    294294};
     295
    295296}
    296297

  • releases/WebKitGTK/webkit-2.24/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp

    r243591 r243977  
    3737#include "NotImplemented.h"
    3838#include "VideoSinkGStreamer.h"
     39#include "WebKitWebSourceGStreamer.h"
    3940#include <wtf/glib/GUniquePtr.h>
    4041#include <wtf/text/AtomicString.h>
    … …  
    337338    gst_message_parse_context_type(message, &contextType);
    338339    GST_DEBUG_OBJECT(pipeline(), "Handling %s need-context message for %s", contextType, GST_MESSAGE_SRC_NAME(message));
     340
     341    if (!g_strcmp0(contextType, WEBKIT_WEB_SRC_PLAYER_CONTEXT_TYPE_NAME)) {
     342        GRefPtr<GstContext> context = adoptGRef(gst_context_new(WEBKIT_WEB_SRC_PLAYER_CONTEXT_TYPE_NAME, FALSE));
     343        GstStructure* contextStructure = gst_context_writable_structure(context.get());
     344
     345        ASSERT(m_player);
     346        gst_structure_set(contextStructure, "player", G_TYPE_POINTER, m_player, nullptr);
     347        gst_element_set_context(GST_ELEMENT(GST_MESSAGE_SRC(message)), context.get());
     348        return true;
     349    }
    339350
    340351#if USE(GSTREAMER_GL)

  • releases/WebKitGTK/webkit-2.24/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

    r243976 r243977  
    3232#include "ResourceRequest.h"
    3333#include "ResourceResponse.h"
    34 #include "SecurityOrigin.h"
    3534#include <cstdint>
    3635#include <wtf/Condition.h>
     36#include <wtf/Scope.h>
    3737#include <wtf/text/CString.h>
    3838
    … …  
    4444    CachedResourceStreamingClient(WebKitWebSrc*, ResourceRequest&&);
    4545    virtual ~CachedResourceStreamingClient();
    46 
    47     const HashSet<RefPtr<WebCore::SecurityOrigin>>& securityOrigins() const { return m_origins; }
    4846
    4947private:
    … …  
    6866    GRefPtr<GstElement> m_src;
    6967    ResourceRequest m_request;
    70     HashSet<RefPtr<WebCore::SecurityOrigin>> m_origins;
    7168};
    7269
    … …  
    111108    GRefPtr<GstAdapter> adapter;
    112109    GRefPtr<GstEvent> httpHeadersEvent;
     110    GUniquePtr<GstStructure> httpHeaders;
    113111};
    114112
    … …  
    144142static gboolean webKitWebSrcUnLock(GstBaseSrc*);
    145143static gboolean webKitWebSrcUnLockStop(GstBaseSrc*);
     144static void webKitWebSrcSetContext(GstElement*, GstContext*);
    146145
    147146#define webkit_web_src_parent_class parent_class
    … …  
    194193
    195194    eklass->change_state = GST_DEBUG_FUNCPTR(webKitWebSrcChangeState);
     195    eklass->set_context = GST_DEBUG_FUNCPTR(webKitWebSrcSetContext);
    196196
    197197    GstBaseSrcClass* baseSrcClass = GST_BASE_SRC_CLASS(klass);
    … …  
    316316        break;
    317317    }
     318}
     319
     320static void webKitWebSrcSetContext(GstElement* element, GstContext* context)
     321{
     322    WebKitWebSrc* src = WEBKIT_WEB_SRC(element);
     323    WebKitWebSrcPrivate* priv = src->priv;
     324
     325    GST_DEBUG_OBJECT(src, "context type: %s", gst_context_get_context_type(context));
     326    if (gst_context_has_context_type(context, WEBKIT_WEB_SRC_PLAYER_CONTEXT_TYPE_NAME)) {
     327        const GValue* value = gst_structure_get_value(gst_context_get_structure(context), "player");
     328        priv->player = reinterpret_cast<MediaPlayer*>(g_value_get_pointer(value));
     329    }
     330    GST_ELEMENT_CLASS(parent_class)->set_context(element, context);
    318331}
    319332
    … …  
    473486    WebKitWebSrc* src = WEBKIT_WEB_SRC(baseSrc);
    474487    WebKitWebSrcPrivate* priv = src->priv;
    475     ASSERT(priv->player);
     488
     489    if (!priv->player) {
     490        GRefPtr<GstQuery> query = adoptGRef(gst_query_new_context(WEBKIT_WEB_SRC_PLAYER_CONTEXT_TYPE_NAME));
     491        if (gst_pad_peer_query(GST_BASE_SRC_PAD(baseSrc), query.get())) {
     492            GstContext* context;
     493
     494            gst_query_parse_context(query.get(), &context);
     495            gst_element_set_context(GST_ELEMENT_CAST(src), context);
     496        } else
     497            gst_element_post_message(GST_ELEMENT_CAST(src), gst_message_new_need_context(GST_OBJECT_CAST(src), WEBKIT_WEB_SRC_PLAYER_CONTEXT_TYPE_NAME));
     498    }
     499
     500    RELEASE_ASSERT(priv->player);
    476501
    477502    priv->wereHeadersReceived = false;
    … …  
    741766const gchar* const* webKitWebSrcGetProtocols(GType)
    742767{
    743     static const char* protocols[] = {"webkit+http", "webkit+https", "webkit+blob", nullptr };
     768    static const char* protocols[] = {"http", "https", "blob", nullptr };
    744769    return protocols;
    745 }
    746 
    747 static URL convertPlaybinURI(const char* uriString)
    748 {
    749     URL url(URL(), uriString);
    750     ASSERT(url.protocol().substring(0, 7) == "webkit+");
    751     url.setProtocol(url.protocol().substring(7).toString());
    752     return url;
    753770}
    754771
    … …  
    775792        return TRUE;
    776793
    777     URL url = convertPlaybinURI(uri);
     794    if (priv->originalURI.length()) {
     795        GST_ERROR_OBJECT(src, "URI can only be set in states < PAUSED");
     796        return FALSE;
     797    }
     798
     799    URL url(URL(), uri);
    778800    if (!urlHasSupportedProtocol(url)) {
    779801        g_set_error(error, GST_URI_ERROR, GST_URI_ERROR_BAD_URI, "Invalid URI '%s'", uri);
    … …  
    858880    GST_DEBUG_OBJECT(src, "Received response: %d", response.httpStatusCode());
    859881
    860     auto origin = SecurityOrigin::create(response.url());
    861     m_origins.add(WTFMove(origin));
    862 
    863882    auto responseURI = response.url().string().utf8();
    864883    if (priv->originalURI != responseURI)
    865884        priv->redirectedURI = WTFMove(responseURI);
     885
     886    uint64_t length = response.expectedContentLength();
     887    if (length > 0 && priv->requestedPosition && response.httpStatusCode() == 206)
     888        length += priv->requestedPosition;
     889
     890    priv->httpHeaders.reset(gst_structure_new_empty("http-headers"));
     891    gst_structure_set(priv->httpHeaders.get(), "uri", G_TYPE_STRING, priv->originalURI.data(),
     892        "http-status-code", G_TYPE_UINT, response.httpStatusCode(), nullptr);
     893    if (!priv->redirectedURI.isNull())
     894        gst_structure_set(priv->httpHeaders.get(), "redirection-uri", G_TYPE_STRING, priv->redirectedURI.data(), nullptr);
     895    GUniquePtr<GstStructure> headers(gst_structure_new_empty("request-headers"));
     896    for (const auto& header : m_request.httpHeaderFields())
     897        gst_structure_set(headers.get(), header.key.utf8().data(), G_TYPE_STRING, header.value.utf8().data(), nullptr);
     898    GST_DEBUG_OBJECT(src, "Request headers going downstream: %" GST_PTR_FORMAT, headers.get());
     899    gst_structure_set(priv->httpHeaders.get(), "request-headers", GST_TYPE_STRUCTURE, headers.get(), nullptr);
     900    headers.reset(gst_structure_new_empty("response-headers"));
     901    for (const auto& header : response.httpHeaderFields()) {
     902        bool ok = false;
     903        uint64_t convertedValue = header.value.toUInt64(&ok);
     904        if (ok)
     905            gst_structure_set(headers.get(), header.key.utf8().data(), G_TYPE_UINT64, convertedValue, nullptr);
     906        else
     907            gst_structure_set(headers.get(), header.key.utf8().data(), G_TYPE_STRING, header.value.utf8().data(), nullptr);
     908    }
     909    auto contentLengthFieldName(httpHeaderNameString(HTTPHeaderName::ContentLength).toString());
     910    if (!gst_structure_has_field(headers.get(), contentLengthFieldName.utf8().data()))
     911        gst_structure_set(headers.get(), contentLengthFieldName.utf8().data(), G_TYPE_UINT64, static_cast<uint64_t>(length), nullptr);
     912    gst_structure_set(priv->httpHeaders.get(), "response-headers", GST_TYPE_STRUCTURE, headers.get(), nullptr);
     913    GST_DEBUG_OBJECT(src, "Response headers going downstream: %" GST_PTR_FORMAT, headers.get());
     914
     915    priv->httpHeadersEvent = adoptGRef(gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM_STICKY, gst_structure_copy(priv->httpHeaders.get())));
     916
     917    auto scopeExit = makeScopeExit([&] {
     918        GstStructure* structure = gst_structure_copy(src->priv->httpHeaders.get());
     919        gst_element_post_message(GST_ELEMENT_CAST(src), gst_message_new_element(GST_OBJECT_CAST(src), structure));
     920    });
    866921
    867922    if (response.httpStatusCode() >= 400) {
    … …  
    892947    }
    893948
    894     long long length = response.expectedContentLength();
    895     if (length > 0 && priv->requestedPosition && response.httpStatusCode() == 206)
    896         length += priv->requestedPosition;
    897 
    898949    priv->isSeekable = length > 0 && g_ascii_strcasecmp("none", response.httpHeaderField(HTTPHeaderName::AcceptRanges).utf8().data());
    899950
    900     GST_DEBUG_OBJECT(src, "Size: %lld, isSeekable: %s", length, boolForPrinting(priv->isSeekable));
     951    GST_DEBUG_OBJECT(src, "Size: %" G_GUINT64_FORMAT ", isSeekable: %s", length, boolForPrinting(priv->isSeekable));
    901952    if (length > 0) {
    902         if (!priv->haveSize || (static_cast<long long>(priv->size) != length)) {
     953        if (!priv->haveSize || priv->size != length) {
    903954            priv->haveSize = true;
    904955            priv->size = length;
    … …  
    929980    {
    930981        LockHolder locker(priv->responseLock);
    931 
    932         // Emit a GST_EVENT_CUSTOM_DOWNSTREAM_STICKY event and message to let
    933         // GStreamer know about the HTTP headers sent and received.
    934         GstStructure* httpHeaders = gst_structure_new_empty("http-headers");
    935         gst_structure_set(httpHeaders, "uri", G_TYPE_STRING, priv->originalURI.data(),
    936             "http-status-code", G_TYPE_UINT, response.httpStatusCode(), nullptr);
    937         if (!priv->redirectedURI.isNull())
    938             gst_structure_set(httpHeaders, "redirection-uri", G_TYPE_STRING, priv->redirectedURI.data(), nullptr);
    939         GUniquePtr<GstStructure> headers(gst_structure_new_empty("request-headers"));
    940         for (const auto& header : m_request.httpHeaderFields())
    941             gst_structure_set(headers.get(), header.key.utf8().data(), G_TYPE_STRING, header.value.utf8().data(), nullptr);
    942         GST_DEBUG_OBJECT(src, "Request headers going downstream: %" GST_PTR_FORMAT, headers.get());
    943         gst_structure_set(httpHeaders, "request-headers", GST_TYPE_STRUCTURE, headers.get(), nullptr);
    944         headers.reset(gst_structure_new_empty("response-headers"));
    945         for (const auto& header : response.httpHeaderFields()) {
    946             bool ok = false;
    947             uint64_t convertedValue = header.value.toUInt64(&ok);
    948             if (ok)
    949                 gst_structure_set(headers.get(), header.key.utf8().data(), G_TYPE_UINT64, convertedValue, nullptr);
    950             else
    951                 gst_structure_set(headers.get(), header.key.utf8().data(), G_TYPE_STRING, header.value.utf8().data(), nullptr);
    952         }
    953         auto contentLengthFieldName(httpHeaderNameString(HTTPHeaderName::ContentLength).toString());
    954         if (!gst_structure_has_field(headers.get(), contentLengthFieldName.utf8().data()))
    955             gst_structure_set(headers.get(), contentLengthFieldName.utf8().data(), G_TYPE_UINT64, static_cast<uint64_t>(length), nullptr);
    956         gst_structure_set(httpHeaders, "response-headers", GST_TYPE_STRUCTURE, headers.get(), nullptr);
    957         GST_DEBUG_OBJECT(src, "Response headers going downstream: %" GST_PTR_FORMAT, headers.get());
    958 
    959         gst_element_post_message(GST_ELEMENT_CAST(src), gst_message_new_element(GST_OBJECT_CAST(src), gst_structure_copy(httpHeaders)));
    960 
    961         priv->httpHeadersEvent = adoptGRef(gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM_STICKY, httpHeaders));
    962982        priv->wereHeadersReceived = true;
    963983        priv->headersCondition.notifyOne();
    … …  
    10421062}
    10431063
    1044 bool webKitSrcWouldTaintOrigin(WebKitWebSrc* src, const SecurityOrigin& origin)
    1045 {
    1046     WebKitWebSrcPrivate* priv = src->priv;
    1047 
    1048     auto* cachedResourceStreamingClient = reinterpret_cast<CachedResourceStreamingClient*>(priv->resource->client());
    1049     for (auto& responseOrigin : cachedResourceStreamingClient->securityOrigins()) {
    1050         if (!origin.canAccess(*responseOrigin))
    1051             return true;
    1052     }
    1053     return false;
    1054 }
    1055 
    10561064#endif // ENABLE(VIDEO) && USE(GSTREAMER)

  • releases/WebKitGTK/webkit-2.24/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.h

    r243975 r243977  
    2626namespace WebCore {
    2727class MediaPlayer;
    28 class SecurityOrigin;
    2928}
    3029
    … …  
    3635#define WEBKIT_IS_WEB_SRC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WEBKIT_TYPE_WEB_SRC))
    3736#define WEBKIT_IS_WEB_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), WEBKIT_TYPE_WEB_SRC))
     37
     38#define WEBKIT_WEB_SRC_PLAYER_CONTEXT_TYPE_NAME  "webkit.media-player"
    3839
    3940typedef struct _WebKitWebSrc        WebKitWebSrc;
    … …  
    5455void webKitWebSrcSetMediaPlayer(WebKitWebSrc*, WebCore::MediaPlayer*);
    5556bool webKitSrcPassedCORSAccessCheck(WebKitWebSrc*);
    56 bool webKitSrcWouldTaintOrigin(WebKitWebSrc*, const WebCore::SecurityOrigin&);
    5757
    5858G_END_DECLS
Note: See TracChangeset for help on using the changeset viewer.