4af920de3d082fa202580306e10c33ef49cce276
[WebKit-https.git] / Source / WebCore / loader / MediaResourceLoader.cpp
1 /*
2  * Copyright (C) 2014 Igalia S.L
3  * Copyright (C) 2016 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28 #include "MediaResourceLoader.h"
29
30 #if ENABLE(VIDEO)
31
32 #include "CachedRawResource.h"
33 #include "CachedResourceLoader.h"
34 #include "CachedResourceRequest.h"
35 #include "CrossOriginAccessControl.h"
36 #include "Document.h"
37 #include "SecurityOrigin.h"
38 #include <wtf/NeverDestroyed.h>
39
40 namespace WebCore {
41
42 MediaResourceLoader::MediaResourceLoader(Document& document, const String& crossOriginMode)
43     : ContextDestructionObserver(&document)
44     , m_document(&document)
45     , m_crossOriginMode(crossOriginMode)
46 {
47 }
48
49 MediaResourceLoader::~MediaResourceLoader()
50 {
51     ASSERT(m_resources.isEmpty());
52 }
53
54 void MediaResourceLoader::contextDestroyed()
55 {
56     ContextDestructionObserver::contextDestroyed();
57     m_document = nullptr;
58 }
59
60 RefPtr<PlatformMediaResource> MediaResourceLoader::requestResource(const ResourceRequest& request, LoadOptions options)
61 {
62     if (!m_document)
63         return nullptr;
64
65     DataBufferingPolicy bufferingPolicy = options & LoadOption::BufferData ? WebCore::BufferData : WebCore::DoNotBufferData;
66     auto cachingPolicy = options & LoadOption::DisallowCaching ? CachingPolicy::DisallowCaching : CachingPolicy::AllowCaching;
67
68     // FIXME: We should try to remove the copy of request when crearing cacheRequest.
69     // FIXME: Skip Content Security Policy check if the element that inititated this request is in a user-agent shadow tree. See <https://bugs.webkit.org/show_bug.cgi?id=155505>.
70     CachedResourceRequest cacheRequest(ResourceRequest(request), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, bufferingPolicy, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, cachingPolicy));
71
72     cacheRequest.setAsPotentiallyCrossOrigin(m_crossOriginMode, *m_document);
73
74     cacheRequest.mutableResourceRequest().setRequester(ResourceRequest::Requester::Media);
75 #if HAVE(AVFOUNDATION_LOADER_DELEGATE) && PLATFORM(MAC)
76     // FIXME: Workaround for <rdar://problem/26071607>. We are not able to do CORS checking on 304 responses because they
77     // are usually missing the headers we need.
78     if (cacheRequest.options().mode == FetchOptions::Mode::Cors)
79         cacheRequest.mutableResourceRequest().makeUnconditional();
80 #endif
81
82     CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(WTFMove(cacheRequest));
83     if (!resource)
84         return nullptr;
85
86     Ref<MediaResource> mediaResource = MediaResource::create(*this, resource);
87     m_resources.add(mediaResource.ptr());
88
89     return WTFMove(mediaResource);
90 }
91
92 void MediaResourceLoader::removeResource(MediaResource& mediaResource)
93 {
94     ASSERT(m_resources.contains(&mediaResource));
95     m_resources.remove(&mediaResource);
96 }
97
98 Ref<MediaResource> MediaResource::create(MediaResourceLoader& loader, CachedResourceHandle<CachedRawResource> resource)
99 {
100     return adoptRef(*new MediaResource(loader, resource));
101 }
102
103 MediaResource::MediaResource(MediaResourceLoader& loader, CachedResourceHandle<CachedRawResource> resource)
104     : m_loader(loader)
105     , m_resource(resource)
106 {
107     ASSERT(resource);
108     resource->addClient(*this);
109 }
110
111 MediaResource::~MediaResource()
112 {
113     stop();
114     m_loader->removeResource(*this);
115 }
116
117 void MediaResource::stop()
118 {
119     if (!m_resource)
120         return;
121
122     m_resource->removeClient(*this);
123     m_resource = nullptr;
124 }
125
126 void MediaResource::setDefersLoading(bool defersLoading)
127 {
128     if (m_resource)
129         m_resource->setDefersLoading(defersLoading);
130 }
131
132 void MediaResource::responseReceived(CachedResource& resource, const ResourceResponse& response)
133 {
134     ASSERT_UNUSED(resource, &resource == m_resource);
135
136     if (!m_loader->document())
137         return;
138
139     RefPtr<MediaResource> protectedThis(this);
140     if (!m_loader->crossOriginMode().isNull() && !m_resource->passesSameOriginPolicyCheck(*m_loader->document()->securityOrigin())) {
141         static NeverDestroyed<const String> consoleMessage("Cross-origin media resource load denied by Cross-Origin Resource Sharing policy.");
142         m_loader->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage.get());
143         m_didPassAccessControlCheck = false;
144         if (m_client)
145             m_client->accessControlCheckFailed(*this, ResourceError(errorDomainWebKitInternal, 0, response.url(), consoleMessage.get()));
146         stop();
147         return;
148     }
149
150     m_didPassAccessControlCheck = !m_loader->crossOriginMode().isNull();
151     if (m_client)
152         m_client->responseReceived(*this, response);
153 }
154
155 bool MediaResource::shouldCacheResponse(CachedResource& resource, const ResourceResponse& response)
156 {
157     ASSERT_UNUSED(resource, &resource == m_resource);
158
159     RefPtr<MediaResource> protectedThis(this);
160     if (m_client)
161         return m_client->shouldCacheResponse(*this, response);
162     return true;
163 }
164
165 void MediaResource::redirectReceived(CachedResource& resource, ResourceRequest& request, const ResourceResponse& response)
166 {
167     ASSERT_UNUSED(resource, &resource == m_resource);
168
169     RefPtr<MediaResource> protectedThis(this);
170     if (m_client)
171         m_client->redirectReceived(*this, request, response);
172 }
173
174 void MediaResource::dataSent(CachedResource& resource, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
175 {
176     ASSERT_UNUSED(resource, &resource == m_resource);
177
178     RefPtr<MediaResource> protectedThis(this);
179     if (m_client)
180         m_client->dataSent(*this, bytesSent, totalBytesToBeSent);
181 }
182
183 void MediaResource::dataReceived(CachedResource& resource, const char* data, int dataLength)
184 {
185     ASSERT_UNUSED(resource, &resource == m_resource);
186
187     RefPtr<MediaResource> protectedThis(this);
188     if (m_client)
189         m_client->dataReceived(*this, data, dataLength);
190 }
191
192 void MediaResource::notifyFinished(CachedResource& resource)
193 {
194     ASSERT_UNUSED(resource, &resource == m_resource);
195
196     RefPtr<MediaResource> protectedThis(this);
197     if (m_client) {
198         if (m_resource->loadFailedOrCanceled())
199             m_client->loadFailed(*this, m_resource->resourceError());
200         else
201             m_client->loadFinished(*this);
202     }
203     stop();
204 }
205
206 #if USE(SOUP)
207 char* MediaResource::getOrCreateReadBuffer(CachedResource& resource, size_t requestedSize, size_t& actualSize)
208 {
209     ASSERT_UNUSED(resource, &resource == m_resource);
210     return m_client ? m_client->getOrCreateReadBuffer(*this, requestedSize, actualSize) : nullptr;
211 }
212 #endif
213
214 } // namespace WebCore
215
216 #endif