| /* |
| * Copyright (C) 2009 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "public/platform/WebURLRequest.h" |
| |
| #include "platform/RuntimeEnabledFeatures.h" |
| #include "platform/network/ResourceRequest.h" |
| #include "public/platform/WebCachePolicy.h" |
| #include "public/platform/WebHTTPBody.h" |
| #include "public/platform/WebHTTPHeaderVisitor.h" |
| #include "public/platform/WebSecurityOrigin.h" |
| #include "public/platform/WebURL.h" |
| #include "wtf/Allocator.h" |
| #include "wtf/Noncopyable.h" |
| #include "wtf/PtrUtil.h" |
| #include <memory> |
| |
| namespace blink { |
| |
| namespace { |
| |
| class ExtraDataContainer : public ResourceRequest::ExtraData { |
| public: |
| static PassRefPtr<ExtraDataContainer> create( |
| WebURLRequest::ExtraData* extraData) { |
| return adoptRef(new ExtraDataContainer(extraData)); |
| } |
| |
| ~ExtraDataContainer() override {} |
| |
| WebURLRequest::ExtraData* getExtraData() const { return m_extraData.get(); } |
| |
| private: |
| explicit ExtraDataContainer(WebURLRequest::ExtraData* extraData) |
| : m_extraData(WTF::wrapUnique(extraData)) {} |
| |
| std::unique_ptr<WebURLRequest::ExtraData> m_extraData; |
| }; |
| |
| } // namespace |
| |
| // The purpose of this struct is to permit allocating a ResourceRequest on the |
| // heap, which is otherwise disallowed by DISALLOW_NEW_EXCEPT_PLACEMENT_NEW |
| // annotation on ResourceRequest. |
| struct WebURLRequest::ResourceRequestContainer { |
| ResourceRequestContainer() {} |
| explicit ResourceRequestContainer(const ResourceRequest& r) |
| : resourceRequest(r) {} |
| |
| ResourceRequest resourceRequest; |
| }; |
| |
| WebURLRequest::~WebURLRequest() {} |
| |
| WebURLRequest::WebURLRequest() |
| : m_ownedResourceRequest(new ResourceRequestContainer()), |
| m_resourceRequest(&m_ownedResourceRequest->resourceRequest) {} |
| |
| WebURLRequest::WebURLRequest(const WebURLRequest& r) |
| : m_ownedResourceRequest( |
| new ResourceRequestContainer(*r.m_resourceRequest)), |
| m_resourceRequest(&m_ownedResourceRequest->resourceRequest) {} |
| |
| WebURLRequest::WebURLRequest(const WebURL& url) : WebURLRequest() { |
| setURL(url); |
| } |
| |
| WebURLRequest& WebURLRequest::operator=(const WebURLRequest& r) { |
| // Copying subclasses that have different m_resourceRequest ownership |
| // semantics via this operator is just not supported. |
| DCHECK(m_ownedResourceRequest); |
| DCHECK(m_resourceRequest); |
| if (&r != this) |
| *m_resourceRequest = *r.m_resourceRequest; |
| return *this; |
| } |
| |
| bool WebURLRequest::isNull() const { |
| return m_resourceRequest->isNull(); |
| } |
| |
| WebURL WebURLRequest::url() const { |
| return m_resourceRequest->url(); |
| } |
| |
| void WebURLRequest::setURL(const WebURL& url) { |
| m_resourceRequest->setURL(url); |
| } |
| |
| WebURL WebURLRequest::firstPartyForCookies() const { |
| return m_resourceRequest->firstPartyForCookies(); |
| } |
| |
| void WebURLRequest::setFirstPartyForCookies( |
| const WebURL& firstPartyForCookies) { |
| m_resourceRequest->setFirstPartyForCookies(firstPartyForCookies); |
| } |
| |
| WebSecurityOrigin WebURLRequest::requestorOrigin() const { |
| return m_resourceRequest->requestorOrigin(); |
| } |
| |
| void WebURLRequest::setRequestorOrigin( |
| const WebSecurityOrigin& requestorOrigin) { |
| m_resourceRequest->setRequestorOrigin(requestorOrigin); |
| } |
| |
| bool WebURLRequest::allowStoredCredentials() const { |
| return m_resourceRequest->allowStoredCredentials(); |
| } |
| |
| void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials) { |
| m_resourceRequest->setAllowStoredCredentials(allowStoredCredentials); |
| } |
| |
| WebCachePolicy WebURLRequest::getCachePolicy() const { |
| return m_resourceRequest->getCachePolicy(); |
| } |
| |
| void WebURLRequest::setCachePolicy(WebCachePolicy cachePolicy) { |
| m_resourceRequest->setCachePolicy(cachePolicy); |
| } |
| |
| WebString WebURLRequest::httpMethod() const { |
| return m_resourceRequest->httpMethod(); |
| } |
| |
| void WebURLRequest::setHTTPMethod(const WebString& httpMethod) { |
| m_resourceRequest->setHTTPMethod(httpMethod); |
| } |
| |
| WebString WebURLRequest::httpHeaderField(const WebString& name) const { |
| return m_resourceRequest->httpHeaderField(name); |
| } |
| |
| void WebURLRequest::setHTTPHeaderField(const WebString& name, |
| const WebString& value) { |
| RELEASE_ASSERT(!equalIgnoringCase(name, "referer")); |
| m_resourceRequest->setHTTPHeaderField(name, value); |
| } |
| |
| void WebURLRequest::setHTTPReferrer(const WebString& webReferrer, |
| WebReferrerPolicy referrerPolicy) { |
| // WebString doesn't have the distinction between empty and null. We use |
| // the null WTFString for referrer. |
| ASSERT(Referrer::noReferrer() == String()); |
| String referrer = |
| webReferrer.isEmpty() ? Referrer::noReferrer() : String(webReferrer); |
| m_resourceRequest->setHTTPReferrer( |
| Referrer(referrer, static_cast<ReferrerPolicy>(referrerPolicy))); |
| } |
| |
| void WebURLRequest::addHTTPHeaderField(const WebString& name, |
| const WebString& value) { |
| m_resourceRequest->addHTTPHeaderField(name, value); |
| } |
| |
| void WebURLRequest::clearHTTPHeaderField(const WebString& name) { |
| m_resourceRequest->clearHTTPHeaderField(name); |
| } |
| |
| void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const { |
| const HTTPHeaderMap& map = m_resourceRequest->httpHeaderFields(); |
| for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it) |
| visitor->visitHeader(it->key, it->value); |
| } |
| |
| WebHTTPBody WebURLRequest::httpBody() const { |
| // TODO(mkwst): This is wrong, as it means that we're producing the body |
| // before any ServiceWorker has a chance to operate, which means we're |
| // revealing data to the SW that we ought to be hiding. Baby steps. |
| // https://crbug.com/599597 |
| if (m_resourceRequest->attachedCredential()) |
| return WebHTTPBody(m_resourceRequest->attachedCredential()); |
| return WebHTTPBody(m_resourceRequest->httpBody()); |
| } |
| |
| void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody) { |
| m_resourceRequest->setHTTPBody(httpBody); |
| } |
| |
| WebHTTPBody WebURLRequest::attachedCredential() const { |
| return WebHTTPBody(m_resourceRequest->attachedCredential()); |
| } |
| |
| void WebURLRequest::setAttachedCredential( |
| const WebHTTPBody& attachedCredential) { |
| m_resourceRequest->setAttachedCredential(attachedCredential); |
| } |
| |
| bool WebURLRequest::reportUploadProgress() const { |
| return m_resourceRequest->reportUploadProgress(); |
| } |
| |
| void WebURLRequest::setReportUploadProgress(bool reportUploadProgress) { |
| m_resourceRequest->setReportUploadProgress(reportUploadProgress); |
| } |
| |
| void WebURLRequest::setReportRawHeaders(bool reportRawHeaders) { |
| m_resourceRequest->setReportRawHeaders(reportRawHeaders); |
| } |
| |
| bool WebURLRequest::reportRawHeaders() const { |
| return m_resourceRequest->reportRawHeaders(); |
| } |
| |
| WebURLRequest::RequestContext WebURLRequest::getRequestContext() const { |
| return m_resourceRequest->requestContext(); |
| } |
| |
| WebURLRequest::FrameType WebURLRequest::getFrameType() const { |
| return m_resourceRequest->frameType(); |
| } |
| |
| WebReferrerPolicy WebURLRequest::getReferrerPolicy() const { |
| return static_cast<WebReferrerPolicy>(m_resourceRequest->getReferrerPolicy()); |
| } |
| |
| void WebURLRequest::addHTTPOriginIfNeeded(const WebSecurityOrigin& origin) { |
| m_resourceRequest->addHTTPOriginIfNeeded(origin.get()); |
| } |
| |
| bool WebURLRequest::hasUserGesture() const { |
| return m_resourceRequest->hasUserGesture(); |
| } |
| |
| void WebURLRequest::setHasUserGesture(bool hasUserGesture) { |
| m_resourceRequest->setHasUserGesture(hasUserGesture); |
| } |
| |
| void WebURLRequest::setRequestContext(RequestContext requestContext) { |
| m_resourceRequest->setRequestContext(requestContext); |
| } |
| |
| void WebURLRequest::setFrameType(FrameType frameType) { |
| m_resourceRequest->setFrameType(frameType); |
| } |
| |
| int WebURLRequest::requestorID() const { |
| return m_resourceRequest->requestorID(); |
| } |
| |
| void WebURLRequest::setRequestorID(int requestorID) { |
| m_resourceRequest->setRequestorID(requestorID); |
| } |
| |
| int WebURLRequest::requestorProcessID() const { |
| return m_resourceRequest->requestorProcessID(); |
| } |
| |
| void WebURLRequest::setRequestorProcessID(int requestorProcessID) { |
| m_resourceRequest->setRequestorProcessID(requestorProcessID); |
| } |
| |
| int WebURLRequest::appCacheHostID() const { |
| return m_resourceRequest->appCacheHostID(); |
| } |
| |
| void WebURLRequest::setAppCacheHostID(int appCacheHostID) { |
| m_resourceRequest->setAppCacheHostID(appCacheHostID); |
| } |
| |
| bool WebURLRequest::downloadToFile() const { |
| return m_resourceRequest->downloadToFile(); |
| } |
| |
| void WebURLRequest::setDownloadToFile(bool downloadToFile) { |
| m_resourceRequest->setDownloadToFile(downloadToFile); |
| } |
| |
| bool WebURLRequest::useStreamOnResponse() const { |
| return m_resourceRequest->useStreamOnResponse(); |
| } |
| |
| void WebURLRequest::setUseStreamOnResponse(bool useStreamOnResponse) { |
| m_resourceRequest->setUseStreamOnResponse(useStreamOnResponse); |
| } |
| |
| WebURLRequest::ServiceWorkerMode WebURLRequest::getServiceWorkerMode() const { |
| return m_resourceRequest->getServiceWorkerMode(); |
| } |
| |
| void WebURLRequest::setServiceWorkerMode( |
| WebURLRequest::ServiceWorkerMode serviceWorkerMode) { |
| m_resourceRequest->setServiceWorkerMode(serviceWorkerMode); |
| } |
| |
| bool WebURLRequest::shouldResetAppCache() const { |
| return m_resourceRequest->shouldResetAppCache(); |
| } |
| |
| void WebURLRequest::setShouldResetAppCache(bool setShouldResetAppCache) { |
| m_resourceRequest->setShouldResetAppCache(setShouldResetAppCache); |
| } |
| |
| WebURLRequest::FetchRequestMode WebURLRequest::getFetchRequestMode() const { |
| return m_resourceRequest->fetchRequestMode(); |
| } |
| |
| void WebURLRequest::setFetchRequestMode(WebURLRequest::FetchRequestMode mode) { |
| return m_resourceRequest->setFetchRequestMode(mode); |
| } |
| |
| WebURLRequest::FetchCredentialsMode WebURLRequest::getFetchCredentialsMode() |
| const { |
| return m_resourceRequest->fetchCredentialsMode(); |
| } |
| |
| void WebURLRequest::setFetchCredentialsMode( |
| WebURLRequest::FetchCredentialsMode mode) { |
| return m_resourceRequest->setFetchCredentialsMode(mode); |
| } |
| |
| WebURLRequest::FetchRedirectMode WebURLRequest::getFetchRedirectMode() const { |
| return m_resourceRequest->fetchRedirectMode(); |
| } |
| |
| void WebURLRequest::setFetchRedirectMode( |
| WebURLRequest::FetchRedirectMode redirect) { |
| return m_resourceRequest->setFetchRedirectMode(redirect); |
| } |
| |
| WebURLRequest::PreviewsState WebURLRequest::getPreviewsState() const { |
| return m_resourceRequest->previewsState(); |
| } |
| |
| void WebURLRequest::setPreviewsState( |
| WebURLRequest::PreviewsState previewsState) { |
| return m_resourceRequest->setPreviewsState(previewsState); |
| } |
| |
| WebURLRequest::ExtraData* WebURLRequest::getExtraData() const { |
| RefPtr<ResourceRequest::ExtraData> data = m_resourceRequest->getExtraData(); |
| if (!data) |
| return 0; |
| return static_cast<ExtraDataContainer*>(data.get())->getExtraData(); |
| } |
| |
| void WebURLRequest::setExtraData(WebURLRequest::ExtraData* extraData) { |
| m_resourceRequest->setExtraData(ExtraDataContainer::create(extraData)); |
| } |
| |
| ResourceRequest& WebURLRequest::toMutableResourceRequest() { |
| DCHECK(m_resourceRequest); |
| return *m_resourceRequest; |
| } |
| |
| WebURLRequest::Priority WebURLRequest::getPriority() const { |
| return static_cast<WebURLRequest::Priority>(m_resourceRequest->priority()); |
| } |
| |
| void WebURLRequest::setPriority(WebURLRequest::Priority priority) { |
| m_resourceRequest->setPriority(static_cast<ResourceLoadPriority>(priority)); |
| } |
| |
| bool WebURLRequest::checkForBrowserSideNavigation() const { |
| return m_resourceRequest->checkForBrowserSideNavigation(); |
| } |
| |
| void WebURLRequest::setCheckForBrowserSideNavigation(bool check) { |
| m_resourceRequest->setCheckForBrowserSideNavigation(check); |
| } |
| |
| double WebURLRequest::uiStartTime() const { |
| return m_resourceRequest->uiStartTime(); |
| } |
| |
| void WebURLRequest::setUiStartTime(double timeSeconds) { |
| m_resourceRequest->setUIStartTime(timeSeconds); |
| } |
| |
| bool WebURLRequest::isExternalRequest() const { |
| return m_resourceRequest->isExternalRequest(); |
| } |
| |
| WebURLRequest::LoadingIPCType WebURLRequest::getLoadingIPCType() const { |
| if (RuntimeEnabledFeatures::loadingWithMojoEnabled()) |
| return WebURLRequest::LoadingIPCType::Mojo; |
| return WebURLRequest::LoadingIPCType::ChromeIPC; |
| } |
| |
| void WebURLRequest::setNavigationStartTime(double navigationStartSeconds) { |
| m_resourceRequest->setNavigationStartTime(navigationStartSeconds); |
| } |
| |
| void WebURLRequest::setIsSameDocumentNavigation(bool isSameDocument) { |
| m_resourceRequest->setIsSameDocumentNavigation(isSameDocument); |
| } |
| |
| WebURLRequest::InputToLoadPerfMetricReportPolicy |
| WebURLRequest::inputPerfMetricReportPolicy() const { |
| return static_cast<WebURLRequest::InputToLoadPerfMetricReportPolicy>( |
| m_resourceRequest->inputPerfMetricReportPolicy()); |
| } |
| |
| void WebURLRequest::setInputPerfMetricReportPolicy( |
| WebURLRequest::InputToLoadPerfMetricReportPolicy policy) { |
| m_resourceRequest->setInputPerfMetricReportPolicy( |
| static_cast<blink::InputToLoadPerfMetricReportPolicy>(policy)); |
| } |
| |
| const ResourceRequest& WebURLRequest::toResourceRequest() const { |
| DCHECK(m_resourceRequest); |
| return *m_resourceRequest; |
| } |
| |
| WebURLRequest::WebURLRequest(ResourceRequest& r) : m_resourceRequest(&r) {} |
| |
| } // namespace blink |