Remove class blink::WebURLResponsePrivate

third_party/WebKit/Source/platform/exported/WebURLResponse.cpp

 /*
  * 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
@@ skipping 12 matching lines @@
  * 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/WebURLResponse.h"
 
-#include "platform/exported/WebURLResponsePrivate.h"
 #include "platform/network/ResourceLoadTiming.h"
 #include "platform/network/ResourceResponse.h"
 #include "public/platform/WebHTTPHeaderVisitor.h"
 #include "public/platform/WebHTTPLoadInfo.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLLoadTiming.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/PtrUtil.h"
@@ skipping 16 matching lines @@
     explicit ExtraDataContainer(WebURLResponse::ExtraData* extraData)
         : m_extraData(wrapUnique(extraData))
     {
     }
 
     std::unique_ptr<WebURLResponse::ExtraData> m_extraData;
 };
 
 } // namespace
 
-// The standard implementation of WebURLResponsePrivate, which maintains
-// ownership of a ResourceResponse instance.
-class WebURLResponsePrivateImpl final : public WebURLResponsePrivate {
-    USING_FAST_MALLOC(WebURLResponsePrivateImpl);
-public:
-    WebURLResponsePrivateImpl()
+// The purpose of this struct is to permit allocating a ResourceResponse on the
+// heap, which is otherwise disallowed by the DISALLOW_NEW_EXCEPT_PLACEMENT_NEW
+// annotation on ResourceResponse.
+struct WebURLResponse::ResourceResponseContainer {
+    ResourceResponseContainer() {}
+
+    ResourceResponseContainer(const ResourceResponse& r)
+        : resourceResponse(r)
     {
-        m_resourceResponse = &m_resourceResponseAllocation;
     }
 
-    WebURLResponsePrivateImpl(const WebURLResponsePrivate& p)
-        : m_resourceResponseAllocation(*p.m_resourceResponse)
-    {
-        m_resourceResponse = &m_resourceResponseAllocation;
-    }
-
-    ~WebURLResponsePrivateImpl() override {}
-
-private:
-    ResourceResponse m_resourceResponseAllocation;
+    ResourceResponse resourceResponse;
 };
 
 WebURLResponse::~WebURLResponse()
 {
 }
 
 WebURLResponse::WebURLResponse()
-    : m_owningPrivate(new WebURLResponsePrivateImpl())
-    , m_private(m_owningPrivate.get())
+    : m_ownedResourceResponse(new ResourceResponseContainer())
+    , m_resourceResponse(&m_ownedResourceResponse->resourceResponse)
 {
 }
 
 WebURLResponse::WebURLResponse(const WebURLResponse& r)
-    : m_owningPrivate(new WebURLResponsePrivateImpl(*r.m_private))
-    , m_private(m_owningPrivate.get())
+    : m_ownedResourceResponse(new ResourceResponseContainer(*r.m_resourceResponse))
+    , m_resourceResponse(&m_ownedResourceResponse->resourceResponse)
 {
 }
 
 WebURLResponse::WebURLResponse(const WebURL& url)
     : WebURLResponse()
 {
     setURL(url);
 }
 
 WebURLResponse& WebURLResponse::operator=(const WebURLResponse& r)
 {
-    // Copying subclasses that have different m_private ownership semantics
+    // Copying subclasses that have different m_resourceResponse ownership semantics
     // via this operator is just not supported.
-    DCHECK(m_owningPrivate);
-    DCHECK(m_private->m_resourceResponse);
+    DCHECK(m_ownedResourceResponse);
+    DCHECK(m_resourceResponse);
     if (&r != this)
-        *m_private->m_resourceResponse = *r.m_private->m_resourceResponse;
+        *m_resourceResponse = *r.m_resourceResponse;
     return *this;
 }
 
 bool WebURLResponse::isNull() const
 {
-    return m_private->m_resourceResponse->isNull();
+    return m_resourceResponse->isNull();
 }
 
 WebURL WebURLResponse::url() const
 {
-    return m_private->m_resourceResponse->url();
+    return m_resourceResponse->url();
 }
 
 void WebURLResponse::setURL(const WebURL& url)
 {
-    m_private->m_resourceResponse->setURL(url);
+    m_resourceResponse->setURL(url);
 }
 
 unsigned WebURLResponse::connectionID() const
 {
-    return m_private->m_resourceResponse->connectionID();
+    return m_resourceResponse->connectionID();
 }
 
 void WebURLResponse::setConnectionID(unsigned connectionID)
 {
-    m_private->m_resourceResponse->setConnectionID(connectionID);
+    m_resourceResponse->setConnectionID(connectionID);
 }
 
 bool WebURLResponse::connectionReused() const
 {
-    return m_private->m_resourceResponse->connectionReused();
+    return m_resourceResponse->connectionReused();
 }
 
 void WebURLResponse::setConnectionReused(bool connectionReused)
 {
-    m_private->m_resourceResponse->setConnectionReused(connectionReused);
+    m_resourceResponse->setConnectionReused(connectionReused);
 }
 
 WebURLLoadTiming WebURLResponse::loadTiming()
 {
-    return WebURLLoadTiming(m_private->m_resourceResponse->resourceLoadTiming());
+    return WebURLLoadTiming(m_resourceResponse->resourceLoadTiming());
 }
 
 void WebURLResponse::setLoadTiming(const WebURLLoadTiming& timing)
 {
     RefPtr<ResourceLoadTiming> loadTiming = PassRefPtr<ResourceLoadTiming>(timing);
-    m_private->m_resourceResponse->setResourceLoadTiming(loadTiming.release());
+    m_resourceResponse->setResourceLoadTiming(loadTiming.release());
 }
 
 WebHTTPLoadInfo WebURLResponse::httpLoadInfo()
 {
-    return WebHTTPLoadInfo(m_private->m_resourceResponse->resourceLoadInfo());
+    return WebHTTPLoadInfo(m_resourceResponse->resourceLoadInfo());
 }
 
 void WebURLResponse::setHTTPLoadInfo(const WebHTTPLoadInfo& value)
 {
-    m_private->m_resourceResponse->setResourceLoadInfo(value);
+    m_resourceResponse->setResourceLoadInfo(value);
 }
 
 void WebURLResponse::setResponseTime(long long responseTime)
 {
-    m_private->m_resourceResponse->setResponseTime(static_cast<int64_t>(responseTime));
+    m_resourceResponse->setResponseTime(static_cast<int64_t>(responseTime));
 }
 
 WebString WebURLResponse::mimeType() const
 {
-    return m_private->m_resourceResponse->mimeType();
+    return m_resourceResponse->mimeType();
 }
 
 void WebURLResponse::setMIMEType(const WebString& mimeType)
 {
-    m_private->m_resourceResponse->setMimeType(mimeType);
+    m_resourceResponse->setMimeType(mimeType);
 }
 
 long long WebURLResponse::expectedContentLength() const
 {
-    return m_private->m_resourceResponse->expectedContentLength();
+    return m_resourceResponse->expectedContentLength();
 }
 
 void WebURLResponse::setExpectedContentLength(long long expectedContentLength)
 {
-    m_private->m_resourceResponse->setExpectedContentLength(expectedContentLength);
+    m_resourceResponse->setExpectedContentLength(expectedContentLength);
 }
 
 WebString WebURLResponse::textEncodingName() const
 {
-    return m_private->m_resourceResponse->textEncodingName();
+    return m_resourceResponse->textEncodingName();
 }
 
 void WebURLResponse::setTextEncodingName(const WebString& textEncodingName)
 {
-    m_private->m_resourceResponse->setTextEncodingName(textEncodingName);
+    m_resourceResponse->setTextEncodingName(textEncodingName);
 }
 
 WebString WebURLResponse::suggestedFileName() const
 {
-    return m_private->m_resourceResponse->suggestedFilename();
+    return m_resourceResponse->suggestedFilename();
 }
 
 void WebURLResponse::setSuggestedFileName(const WebString& suggestedFileName)
 {
-    m_private->m_resourceResponse->setSuggestedFilename(suggestedFileName);
+    m_resourceResponse->setSuggestedFilename(suggestedFileName);
 }
 
 WebURLResponse::HTTPVersion WebURLResponse::httpVersion() const
 {
-    return static_cast<HTTPVersion>(m_private->m_resourceResponse->httpVersion());
+    return static_cast<HTTPVersion>(m_resourceResponse->httpVersion());
 }
 
 void WebURLResponse::setHTTPVersion(HTTPVersion version)
 {
-    m_private->m_resourceResponse->setHTTPVersion(static_cast<ResourceResponse::HTTPVersion>(version));
+    m_resourceResponse->setHTTPVersion(static_cast<ResourceResponse::HTTPVersion>(version));
 }
 
 int WebURLResponse::httpStatusCode() const
 {
-    return m_private->m_resourceResponse->httpStatusCode();
+    return m_resourceResponse->httpStatusCode();
 }
 
 void WebURLResponse::setHTTPStatusCode(int httpStatusCode)
 {
-    m_private->m_resourceResponse->setHTTPStatusCode(httpStatusCode);
+    m_resourceResponse->setHTTPStatusCode(httpStatusCode);
 }
 
 WebString WebURLResponse::httpStatusText() const
 {
-    return m_private->m_resourceResponse->httpStatusText();
+    return m_resourceResponse->httpStatusText();
 }
 
 void WebURLResponse::setHTTPStatusText(const WebString& httpStatusText)
 {
-    m_private->m_resourceResponse->setHTTPStatusText(httpStatusText);
+    m_resourceResponse->setHTTPStatusText(httpStatusText);
 }
 
 WebString WebURLResponse::httpHeaderField(const WebString& name) const
 {
-    return m_private->m_resourceResponse->httpHeaderField(name);
+    return m_resourceResponse->httpHeaderField(name);
 }
 
 void WebURLResponse::setHTTPHeaderField(const WebString& name, const WebString& value)
 {
-    m_private->m_resourceResponse->setHTTPHeaderField(name, value);
+    m_resourceResponse->setHTTPHeaderField(name, value);
 }
 
 void WebURLResponse::addHTTPHeaderField(const WebString& name, const WebString& value)
 {
     if (name.isNull() || value.isNull())
         return;
 
-    m_private->m_resourceResponse->addHTTPHeaderField(name, value);
+    m_resourceResponse->addHTTPHeaderField(name, value);
 }
 
 void WebURLResponse::clearHTTPHeaderField(const WebString& name)
 {
-    m_private->m_resourceResponse->clearHTTPHeaderField(name);
+    m_resourceResponse->clearHTTPHeaderField(name);
 }
 
 void WebURLResponse::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const
 {
-    const HTTPHeaderMap& map = m_private->m_resourceResponse->httpHeaderFields();
+    const HTTPHeaderMap& map = m_resourceResponse->httpHeaderFields();
     for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it)
         visitor->visitHeader(it->key, it->value);
 }
 
 double WebURLResponse::lastModifiedDate() const
 {
-    return static_cast<double>(m_private->m_resourceResponse->lastModifiedDate());
+    return static_cast<double>(m_resourceResponse->lastModifiedDate());
 }
 
 void WebURLResponse::setLastModifiedDate(double lastModifiedDate)
 {
-    m_private->m_resourceResponse->setLastModifiedDate(static_cast<time_t>(lastModifiedDate));
+    m_resourceResponse->setLastModifiedDate(static_cast<time_t>(lastModifiedDate));
 }
 
 long long WebURLResponse::appCacheID() const
 {
-    return m_private->m_resourceResponse->appCacheID();
+    return m_resourceResponse->appCacheID();
 }
 
 void WebURLResponse::setAppCacheID(long long appCacheID)
 {
-    m_private->m_resourceResponse->setAppCacheID(appCacheID);
+    m_resourceResponse->setAppCacheID(appCacheID);
 }
 
 WebURL WebURLResponse::appCacheManifestURL() const
 {
-    return m_private->m_resourceResponse->appCacheManifestURL();
+    return m_resourceResponse->appCacheManifestURL();
 }
 
 void WebURLResponse::setAppCacheManifestURL(const WebURL& url)
 {
-    m_private->m_resourceResponse->setAppCacheManifestURL(url);
+    m_resourceResponse->setAppCacheManifestURL(url);
 }
 
 WebCString WebURLResponse::securityInfo() const
 {
     // FIXME: getSecurityInfo is misnamed.
-    return m_private->m_resourceResponse->getSecurityInfo();
+    return m_resourceResponse->getSecurityInfo();
 }
 
 void WebURLResponse::setSecurityInfo(const WebCString& securityInfo)
 {
-    m_private->m_resourceResponse->setSecurityInfo(securityInfo);
+    m_resourceResponse->setSecurityInfo(securityInfo);
 }
 
 void WebURLResponse::setHasMajorCertificateErrors(bool value)
 {
-    m_private->m_resourceResponse->setHasMajorCertificateErrors(value);
+    m_resourceResponse->setHasMajorCertificateErrors(value);
 }
 
 WebURLResponse::SecurityStyle WebURLResponse::getSecurityStyle() const
 {
-    return static_cast<SecurityStyle>(m_private->m_resourceResponse->getSecurityStyle());
+    return static_cast<SecurityStyle>(m_resourceResponse->getSecurityStyle());
 }
 
 void WebURLResponse::setSecurityStyle(SecurityStyle securityStyle)
 {
-    m_private->m_resourceResponse->setSecurityStyle(static_cast<ResourceResponse::SecurityStyle>(securityStyle));
+    m_resourceResponse->setSecurityStyle(static_cast<ResourceResponse::SecurityStyle>(securityStyle));
 }
 
 void WebURLResponse::setSecurityDetails(const WebSecurityDetails& webSecurityDetails)
 {
     blink::ResourceResponse::SignedCertificateTimestampList sctList;
     for (const auto& iter : webSecurityDetails.sctList)
         sctList.append(static_cast<blink::ResourceResponse::SignedCertificateTimestamp>(iter));
-    m_private->m_resourceResponse->setSecurityDetails(
+    m_resourceResponse->setSecurityDetails(
         webSecurityDetails.protocol,
         webSecurityDetails.keyExchange,
         webSecurityDetails.cipher,
         webSecurityDetails.mac,
         webSecurityDetails.certId,
         webSecurityDetails.numUnknownScts,
         webSecurityDetails.numInvalidScts,
         webSecurityDetails.numValidScts,
         sctList);
 }
 
 ResourceResponse& WebURLResponse::toMutableResourceResponse()
 {
-    DCHECK(m_private->m_resourceResponse);
-    return *m_private->m_resourceResponse;
+    return *m_resourceResponse;
 }
 
 const ResourceResponse& WebURLResponse::toResourceResponse() const
 {
-    DCHECK(m_private->m_resourceResponse);
-    return *m_private->m_resourceResponse;
+    return *m_resourceResponse;
 }
 
 bool WebURLResponse::wasCached() const
 {
-    return m_private->m_resourceResponse->wasCached();
+    return m_resourceResponse->wasCached();
 }
 
 void WebURLResponse::setWasCached(bool value)
 {
-    m_private->m_resourceResponse->setWasCached(value);
+    m_resourceResponse->setWasCached(value);
 }
 
 bool WebURLResponse::wasFetchedViaSPDY() const
 {
-    return m_private->m_resourceResponse->wasFetchedViaSPDY();
+    return m_resourceResponse->wasFetchedViaSPDY();
 }
 
 void WebURLResponse::setWasFetchedViaSPDY(bool value)
 {
-    m_private->m_resourceResponse->setWasFetchedViaSPDY(value);
+    m_resourceResponse->setWasFetchedViaSPDY(value);
 }
 
 bool WebURLResponse::wasNpnNegotiated() const
 {
-    return m_private->m_resourceResponse->wasNpnNegotiated();
+    return m_resourceResponse->wasNpnNegotiated();
 }
 
 void WebURLResponse::setWasNpnNegotiated(bool value)
 {
-    m_private->m_resourceResponse->setWasNpnNegotiated(value);
+    m_resourceResponse->setWasNpnNegotiated(value);
 }
 
 bool WebURLResponse::wasAlternateProtocolAvailable() const
 {
-    return m_private->m_resourceResponse->wasAlternateProtocolAvailable();
+    return m_resourceResponse->wasAlternateProtocolAvailable();
 }
 
 void WebURLResponse::setWasAlternateProtocolAvailable(bool value)
 {
-    m_private->m_resourceResponse->setWasAlternateProtocolAvailable(value);
+    m_resourceResponse->setWasAlternateProtocolAvailable(value);
 }
 
 bool WebURLResponse::wasFetchedViaProxy() const
 {
-    return m_private->m_resourceResponse->wasFetchedViaProxy();
+    return m_resourceResponse->wasFetchedViaProxy();
 }
 
 void WebURLResponse::setWasFetchedViaProxy(bool value)
 {
-    m_private->m_resourceResponse->setWasFetchedViaProxy(value);
+    m_resourceResponse->setWasFetchedViaProxy(value);
 }
 
 bool WebURLResponse::wasFetchedViaServiceWorker() const
 {
-    return m_private->m_resourceResponse->wasFetchedViaServiceWorker();
+    return m_resourceResponse->wasFetchedViaServiceWorker();
 }
 
 void WebURLResponse::setWasFetchedViaServiceWorker(bool value)
 {
-    m_private->m_resourceResponse->setWasFetchedViaServiceWorker(value);
+    m_resourceResponse->setWasFetchedViaServiceWorker(value);
 }
 
 bool WebURLResponse::wasFallbackRequiredByServiceWorker() const
 {
-    return m_private->m_resourceResponse->wasFallbackRequiredByServiceWorker();
+    return m_resourceResponse->wasFallbackRequiredByServiceWorker();
 }
 
 void WebURLResponse::setWasFallbackRequiredByServiceWorker(bool value)
 {
-    m_private->m_resourceResponse->setWasFallbackRequiredByServiceWorker(value);
+    m_resourceResponse->setWasFallbackRequiredByServiceWorker(value);
 }
 
 WebServiceWorkerResponseType WebURLResponse::serviceWorkerResponseType() const
 {
-    return m_private->m_resourceResponse->serviceWorkerResponseType();
+    return m_resourceResponse->serviceWorkerResponseType();
 }
 
 void WebURLResponse::setServiceWorkerResponseType(WebServiceWorkerResponseType value)
 {
-    m_private->m_resourceResponse->setServiceWorkerResponseType(value);
+    m_resourceResponse->setServiceWorkerResponseType(value);
 }
 
 WebURL WebURLResponse::originalURLViaServiceWorker() const
 {
-    return m_private->m_resourceResponse->originalURLViaServiceWorker();
+    return m_resourceResponse->originalURLViaServiceWorker();
 }
 
 void WebURLResponse::setOriginalURLViaServiceWorker(const WebURL& url)
 {
-    m_private->m_resourceResponse->setOriginalURLViaServiceWorker(url);
+    m_resourceResponse->setOriginalURLViaServiceWorker(url);
 }
 
 void WebURLResponse::setMultipartBoundary(const char* bytes, size_t size)
 {
-    m_private->m_resourceResponse->setMultipartBoundary(bytes, size);
+    m_resourceResponse->setMultipartBoundary(bytes, size);
 }
 
 WebString WebURLResponse::cacheStorageCacheName() const
 {
-    return m_private->m_resourceResponse->cacheStorageCacheName();
+    return m_resourceResponse->cacheStorageCacheName();
 }
 
 void WebURLResponse::setCacheStorageCacheName(const WebString& cacheStorageCacheName)
 {
-    m_private->m_resourceResponse->setCacheStorageCacheName(cacheStorageCacheName);
+    m_resourceResponse->setCacheStorageCacheName(cacheStorageCacheName);
 }
 
 void WebURLResponse::setCorsExposedHeaderNames(const WebVector<WebString>& headerNames)
 {
     Vector<String> exposedHeaderNames;
     exposedHeaderNames.append(headerNames.data(), headerNames.size());
-    m_private->m_resourceResponse->setCorsExposedHeaderNames(exposedHeaderNames);
+    m_resourceResponse->setCorsExposedHeaderNames(exposedHeaderNames);
 }
 
 WebString WebURLResponse::downloadFilePath() const
 {
-    return m_private->m_resourceResponse->downloadedFilePath();
+    return m_resourceResponse->downloadedFilePath();
 }
 
 void WebURLResponse::setDownloadFilePath(const WebString& downloadFilePath)
 {
-    m_private->m_resourceResponse->setDownloadedFilePath(downloadFilePath);
+    m_resourceResponse->setDownloadedFilePath(downloadFilePath);
 }
 
 WebString WebURLResponse::remoteIPAddress() const
 {
-    return m_private->m_resourceResponse->remoteIPAddress();
+    return m_resourceResponse->remoteIPAddress();
 }
 
 void WebURLResponse::setRemoteIPAddress(const WebString& remoteIPAddress)
 {
-    m_private->m_resourceResponse->setRemoteIPAddress(remoteIPAddress);
+    m_resourceResponse->setRemoteIPAddress(remoteIPAddress);
 }
 
 unsigned short WebURLResponse::remotePort() const
 {
-    return m_private->m_resourceResponse->remotePort();
+    return m_resourceResponse->remotePort();
 }
 
 void WebURLResponse::setRemotePort(unsigned short remotePort)
 {
-    m_private->m_resourceResponse->setRemotePort(remotePort);
+    m_resourceResponse->setRemotePort(remotePort);
 }
 
 WebURLResponse::ExtraData* WebURLResponse::getExtraData() const
 {
-    RefPtr<ResourceResponse::ExtraData> data = m_private->m_resourceResponse->getExtraData();
+    RefPtr<ResourceResponse::ExtraData> data = m_resourceResponse->getExtraData();
     if (!data)
         return 0;
     return static_cast<ExtraDataContainer*>(data.get())->getExtraData();
 }
 
 void WebURLResponse::setExtraData(WebURLResponse::ExtraData* extraData)
 {
-    m_private->m_resourceResponse->setExtraData(ExtraDataContainer::create(extraData));
+    m_resourceResponse->setExtraData(ExtraDataContainer::create(extraData));
 }
 
-WebURLResponse::WebURLResponse(WebURLResponsePrivate* p)
-    : m_private(p)
+WebURLResponse::WebURLResponse(ResourceResponse* p)
+    : m_resourceResponse(p)
 {
     DCHECK(p);
 }
 
 } // namespace blink