AssociatedURLLoader shouldn't derive from WebURLLoader

third_party/WebKit/Source/web/WebAssociatedURLLoaderImpl.cpp

 /*
  * Copyright (C) 2010, 2011, 2012 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 10 matching lines @@
  * 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 "web/AssociatedURLLoader.h"
+#include "web/WebAssociatedURLLoaderImpl.h"
 
 #include "core/dom/ContextLifecycleObserver.h"
 #include "core/fetch/CrossOriginAccessControl.h"
 #include "core/fetch/FetchUtils.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/DocumentThreadableLoaderClient.h"
 #include "platform/Timer.h"
 #include "platform/exported/WrappedResourceRequest.h"
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/network/HTTPParsers.h"
 #include "platform/network/ResourceError.h"
 #include "public/platform/WebHTTPHeaderVisitor.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURLError.h"
-#include "public/platform/WebURLLoaderClient.h"
 #include "public/platform/WebURLRequest.h"
+#include "public/web/WebAssociatedURLLoaderClient.h"
 #include "public/web/WebDataSource.h"
 #include "web/WebLocalFrameImpl.h"
 #include "wtf/HashSet.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/WTFString.h"
 #include <limits.h>
 #include <memory>
 
 namespace blink {
 
@@ skipping 17 matching lines @@
                                              const WebString& value) {
   m_isSafe = m_isSafe && isValidHTTPToken(name) &&
              !FetchUtils::isForbiddenHeaderName(name) &&
              isValidHTTPHeaderValue(value);
 }
 
 }  // namespace
 
 // This class bridges the interface differences between WebCore and WebKit
 // loader clients.
-// It forwards its ThreadableLoaderClient notifications to a WebURLLoaderClient.
-class AssociatedURLLoader::ClientAdapter final
+// It forwards its ThreadableLoaderClient notifications to a
+// WebAssociatedURLLoaderClient.
+class WebAssociatedURLLoaderImpl::ClientAdapter final
     : public DocumentThreadableLoaderClient {
   WTF_MAKE_NONCOPYABLE(ClientAdapter);
 
  public:
-  static std::unique_ptr<ClientAdapter> create(AssociatedURLLoader*,
-                                               WebURLLoaderClient*,
-                                               const WebURLLoaderOptions&);
+  static std::unique_ptr<ClientAdapter> create(
+      WebAssociatedURLLoaderImpl*,
+      WebAssociatedURLLoaderClient*,
+      const WebAssociatedURLLoaderOptions&);
 
   // ThreadableLoaderClient
   void didSendData(unsigned long long /*bytesSent*/,
                    unsigned long long /*totalBytesToBeSent*/) override;
   void didReceiveResponse(unsigned long,
                           const ResourceResponse&,
                           std::unique_ptr<WebDataConsumerHandle>) override;
   void didDownloadData(int /*dataLength*/) override;
   void didReceiveData(const char*, unsigned /*dataLength*/) override;
   void didReceiveCachedMetadata(const char*, int /*dataLength*/) override;
   void didFinishLoading(unsigned long /*identifier*/,
                         double /*finishTime*/) override;
   void didFail(const ResourceError&) override;
   void didFailRedirectCheck() override;
 
   // DocumentThreadableLoaderClient
   bool willFollowRedirect(
       const ResourceRequest& /*newRequest*/,
       const ResourceResponse& /*redirectResponse*/) override;
 
   // Sets an error to be reported back to the client, asychronously.
   void setDelayedError(const ResourceError&);
 
-  // Enables forwarding of error notifications to the WebURLLoaderClient. These
+  // Enables forwarding of error notifications to the
+  // WebAssociatedURLLoaderClient. These
   // must be deferred until after the call to
-  // AssociatedURLLoader::loadAsynchronously() completes.
+  // WebAssociatedURLLoader::loadAsynchronously() completes.
   void enableErrorNotifications();
 
   // Stops loading and releases the DocumentThreadableLoader as early as
   // possible.
-  WebURLLoaderClient* releaseClient() {
-    WebURLLoaderClient* client = m_client;
+  WebAssociatedURLLoaderClient* releaseClient() {
+    WebAssociatedURLLoaderClient* client = m_client;
     m_client = nullptr;
     return client;
   }
 
  private:
-  ClientAdapter(AssociatedURLLoader*,
-                WebURLLoaderClient*,
-                const WebURLLoaderOptions&);
+  ClientAdapter(WebAssociatedURLLoaderImpl*,
+                WebAssociatedURLLoaderClient*,
+                const WebAssociatedURLLoaderOptions&);
 
   void notifyError(TimerBase*);
 
-  AssociatedURLLoader* m_loader;
-  WebURLLoaderClient* m_client;
-  WebURLLoaderOptions m_options;
+  WebAssociatedURLLoaderImpl* m_loader;
+  WebAssociatedURLLoaderClient* m_client;
+  WebAssociatedURLLoaderOptions m_options;
   WebURLError m_error;
 
   Timer<ClientAdapter> m_errorTimer;
   bool m_enableErrorNotifications;
   bool m_didFail;
 };
 
-std::unique_ptr<AssociatedURLLoader::ClientAdapter>
-AssociatedURLLoader::ClientAdapter::create(AssociatedURLLoader* loader,
-                                           WebURLLoaderClient* client,
-                                           const WebURLLoaderOptions& options) {
+std::unique_ptr<WebAssociatedURLLoaderImpl::ClientAdapter>
+WebAssociatedURLLoaderImpl::ClientAdapter::create(
+    WebAssociatedURLLoaderImpl* loader,
+    WebAssociatedURLLoaderClient* client,
+    const WebAssociatedURLLoaderOptions& options) {
   return wrapUnique(new ClientAdapter(loader, client, options));
 }
 
-AssociatedURLLoader::ClientAdapter::ClientAdapter(
-    AssociatedURLLoader* loader,
-    WebURLLoaderClient* client,
-    const WebURLLoaderOptions& options)
+WebAssociatedURLLoaderImpl::ClientAdapter::ClientAdapter(
+    WebAssociatedURLLoaderImpl* loader,
+    WebAssociatedURLLoaderClient* client,
+    const WebAssociatedURLLoaderOptions& options)
     : m_loader(loader),
       m_client(client),
       m_options(options),
       m_errorTimer(this, &ClientAdapter::notifyError),
       m_enableErrorNotifications(false),
       m_didFail(false) {
   DCHECK(m_loader);
   DCHECK(m_client);
 }
 
-bool AssociatedURLLoader::ClientAdapter::willFollowRedirect(
+bool WebAssociatedURLLoaderImpl::ClientAdapter::willFollowRedirect(
     const ResourceRequest& newRequest,
     const ResourceResponse& redirectResponse) {
   if (!m_client)
     return true;
 
   WrappedResourceRequest wrappedNewRequest(newRequest);
   WrappedResourceResponse wrappedRedirectResponse(redirectResponse);
-  return m_client->willFollowRedirect(m_loader, wrappedNewRequest,
+  return m_client->willFollowRedirect(wrappedNewRequest,
                                       wrappedRedirectResponse);
 }
 
-void AssociatedURLLoader::ClientAdapter::didSendData(
+void WebAssociatedURLLoaderImpl::ClientAdapter::didSendData(
     unsigned long long bytesSent,
     unsigned long long totalBytesToBeSent) {
   if (!m_client)
     return;
 
-  m_client->didSendData(m_loader, bytesSent, totalBytesToBeSent);
+  m_client->didSendData(bytesSent, totalBytesToBeSent);
 }
 
-void AssociatedURLLoader::ClientAdapter::didReceiveResponse(
+void WebAssociatedURLLoaderImpl::ClientAdapter::didReceiveResponse(
     unsigned long,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
+  ALLOW_UNUSED_LOCAL(handle);
   DCHECK(!handle);
   if (!m_client)
     return;
 
   if (m_options.exposeAllResponseHeaders ||
       m_options.crossOriginRequestPolicy !=
-          WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl) {
+          WebAssociatedURLLoaderOptions::
+              CrossOriginRequestPolicyUseAccessControl) {
     // Use the original ResourceResponse.
-    m_client->didReceiveResponse(m_loader, WrappedResourceResponse(response));
+    m_client->didReceiveResponse(WrappedResourceResponse(response));
     return;
   }
 
   HTTPHeaderSet exposedHeaders;
   extractCorsExposedHeaderNamesList(response, exposedHeaders);
   HTTPHeaderSet blockedHeaders;
   for (const auto& header : response.httpHeaderFields()) {
     if (FetchUtils::isForbiddenResponseHeaderName(header.key) ||
         (!isOnAccessControlResponseHeaderWhitelist(header.key) &&
          !exposedHeaders.contains(header.key)))
       blockedHeaders.add(header.key);
   }
 
   if (blockedHeaders.isEmpty()) {
     // Use the original ResourceResponse.
-    m_client->didReceiveResponse(m_loader, WrappedResourceResponse(response));
+    m_client->didReceiveResponse(WrappedResourceResponse(response));
     return;
   }
 
   // If there are blocked headers, copy the response so we can remove them.
   WebURLResponse validatedResponse = WrappedResourceResponse(response);
   for (const auto& header : blockedHeaders)
     validatedResponse.clearHTTPHeaderField(header);
-  m_client->didReceiveResponse(m_loader, validatedResponse);
+  m_client->didReceiveResponse(validatedResponse);
 }
 
-void AssociatedURLLoader::ClientAdapter::didDownloadData(int dataLength) {
+void WebAssociatedURLLoaderImpl::ClientAdapter::didDownloadData(
+    int dataLength) {
   if (!m_client)
     return;
 
-  m_client->didDownloadData(m_loader, dataLength, -1);
+  m_client->didDownloadData(dataLength);
 }
 
-void AssociatedURLLoader::ClientAdapter::didReceiveData(const char* data,
-                                                        unsigned dataLength) {
+void WebAssociatedURLLoaderImpl::ClientAdapter::didReceiveData(
+    const char* data,
+    unsigned dataLength) {
   if (!m_client)
     return;
 
   CHECK_LE(dataLength, static_cast<unsigned>(std::numeric_limits<int>::max()));
 
-  m_client->didReceiveData(m_loader, data, dataLength, -1, dataLength);
+  m_client->didReceiveData(data, dataLength);
 }
 
-void AssociatedURLLoader::ClientAdapter::didReceiveCachedMetadata(
+void WebAssociatedURLLoaderImpl::ClientAdapter::didReceiveCachedMetadata(
     const char* data,
     int dataLength) {
   if (!m_client)
     return;
 
-  m_client->didReceiveCachedMetadata(m_loader, data, dataLength);
+  m_client->didReceiveCachedMetadata(data, dataLength);
 }
 
-void AssociatedURLLoader::ClientAdapter::didFinishLoading(
+void WebAssociatedURLLoaderImpl::ClientAdapter::didFinishLoading(
     unsigned long identifier,
     double finishTime) {
   if (!m_client)
     return;
 
   m_loader->clientAdapterDone();
 
-  releaseClient()->didFinishLoading(
-      m_loader, finishTime, WebURLLoaderClient::kUnknownEncodedDataLength);
+  releaseClient()->didFinishLoading(finishTime);
   // |this| may be dead here.
 }
 
-void AssociatedURLLoader::ClientAdapter::didFail(const ResourceError& error) {
+void WebAssociatedURLLoaderImpl::ClientAdapter::didFail(
+    const ResourceError& error) {
   if (!m_client)
     return;
 
   m_loader->clientAdapterDone();
 
   m_didFail = true;
   m_error = WebURLError(error);
   if (m_enableErrorNotifications)
     notifyError(&m_errorTimer);
 }
 
-void AssociatedURLLoader::ClientAdapter::didFailRedirectCheck() {
+void WebAssociatedURLLoaderImpl::ClientAdapter::didFailRedirectCheck() {
   didFail(ResourceError());
 }
 
-void AssociatedURLLoader::ClientAdapter::enableErrorNotifications() {
+void WebAssociatedURLLoaderImpl::ClientAdapter::enableErrorNotifications() {
   m_enableErrorNotifications = true;
   // If an error has already been received, start a timer to report it to the
-  // client after AssociatedURLLoader::loadAsynchronously has returned to the
+  // client after WebAssociatedURLLoader::loadAsynchronously has returned to the
   // caller.
   if (m_didFail)
     m_errorTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
-void AssociatedURLLoader::ClientAdapter::notifyError(TimerBase* timer) {
+void WebAssociatedURLLoaderImpl::ClientAdapter::notifyError(TimerBase* timer) {
   DCHECK_EQ(timer, &m_errorTimer);
 
   if (m_client)
-    releaseClient()->didFail(m_loader, m_error);
+    releaseClient()->didFail(m_error);
   // |this| may be dead here.
 }
 
-class AssociatedURLLoader::Observer final : public GarbageCollected<Observer>,
-                                            public ContextLifecycleObserver {
+class WebAssociatedURLLoaderImpl::Observer final
+    : public GarbageCollected<Observer>,
+      public ContextLifecycleObserver {
   USING_GARBAGE_COLLECTED_MIXIN(Observer);
 
  public:
-  Observer(AssociatedURLLoader* parent, Document* document)
+  Observer(WebAssociatedURLLoaderImpl* parent, Document* document)
       : ContextLifecycleObserver(document), m_parent(parent) {}
 
   void dispose() {
     m_parent = nullptr;
     clearContext();
   }
 
   void contextDestroyed() override {
     if (m_parent)
       m_parent->documentDestroyed();
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() { ContextLifecycleObserver::trace(visitor); }
 
-  AssociatedURLLoader* m_parent;
+  WebAssociatedURLLoaderImpl* m_parent;
 };
 
-AssociatedURLLoader::AssociatedURLLoader(WebLocalFrameImpl* frameImpl,
-                                         const WebURLLoaderOptions& options)
+WebAssociatedURLLoaderImpl::WebAssociatedURLLoaderImpl(
+    WebLocalFrameImpl* frameImpl,
+    const WebAssociatedURLLoaderOptions& options)
     : m_client(nullptr),
       m_options(options),
       m_observer(new Observer(this, frameImpl->frame()->document())) {}
 
-AssociatedURLLoader::~AssociatedURLLoader() {
+WebAssociatedURLLoaderImpl::~WebAssociatedURLLoaderImpl() {
   cancel();
 }
 
 #define STATIC_ASSERT_ENUM(a, b)                            \
   static_assert(static_cast<int>(a) == static_cast<int>(b), \
                 "mismatching enum: " #a)
 
-STATIC_ASSERT_ENUM(WebURLLoaderOptions::CrossOriginRequestPolicyDeny,
+STATIC_ASSERT_ENUM(WebAssociatedURLLoaderOptions::CrossOriginRequestPolicyDeny,
                    DenyCrossOriginRequests);
 STATIC_ASSERT_ENUM(
-    WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl,
+    WebAssociatedURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl,
     UseAccessControl);
-STATIC_ASSERT_ENUM(WebURLLoaderOptions::CrossOriginRequestPolicyAllow,
+STATIC_ASSERT_ENUM(WebAssociatedURLLoaderOptions::CrossOriginRequestPolicyAllow,
                    AllowCrossOriginRequests);
 
-STATIC_ASSERT_ENUM(WebURLLoaderOptions::ConsiderPreflight, ConsiderPreflight);
-STATIC_ASSERT_ENUM(WebURLLoaderOptions::ForcePreflight, ForcePreflight);
-STATIC_ASSERT_ENUM(WebURLLoaderOptions::PreventPreflight, PreventPreflight);
+STATIC_ASSERT_ENUM(WebAssociatedURLLoaderOptions::ConsiderPreflight,
+                   ConsiderPreflight);
+STATIC_ASSERT_ENUM(WebAssociatedURLLoaderOptions::ForcePreflight,
+                   ForcePreflight);
+STATIC_ASSERT_ENUM(WebAssociatedURLLoaderOptions::PreventPreflight,
+                   PreventPreflight);
 
-void AssociatedURLLoader::loadSynchronously(const WebURLRequest& request,
-                                            WebURLResponse& response,
-                                            WebURLError& error,
-                                            WebData& data,
-                                            int64_t& encodedDataLength) {
-  DCHECK(0);  // Synchronous loading is not supported.
-}
-
-void AssociatedURLLoader::loadAsynchronously(const WebURLRequest& request,
-                                             WebURLLoaderClient* client) {
+void WebAssociatedURLLoaderImpl::loadAsynchronously(
+    const WebURLRequest& request,
+    WebAssociatedURLLoaderClient* client) {
   DCHECK(!m_client);
   DCHECK(!m_loader);
   DCHECK(!m_clientAdapter);
 
   DCHECK(client);
 
   bool allowLoad = true;
   WebURLRequest newRequest(request);
   if (m_options.untrustedHTTP) {
     WebString method = newRequest.httpMethod();
@@ skipping 40 matching lines @@
     m_loader->start(webcoreRequest);
   }
 
   if (!m_loader) {
     // FIXME: return meaningful error codes.
     m_clientAdapter->didFail(ResourceError());
   }
   m_clientAdapter->enableErrorNotifications();
 }
 
-void AssociatedURLLoader::cancel() {
+void WebAssociatedURLLoaderImpl::cancel() {
   disposeObserver();
   cancelLoader();
   releaseClient();
 }
 
-void AssociatedURLLoader::clientAdapterDone() {
+void WebAssociatedURLLoaderImpl::clientAdapterDone() {
   disposeObserver();
   releaseClient();
 }
 
-void AssociatedURLLoader::cancelLoader() {
+void WebAssociatedURLLoaderImpl::cancelLoader() {
   if (!m_clientAdapter)
     return;
 
-  // Prevent invocation of the WebURLLoaderClient methods.
+  // Prevent invocation of the WebAssociatedURLLoaderClient methods.
   m_clientAdapter->releaseClient();
 
   if (m_loader) {
     m_loader->cancel();
     m_loader = nullptr;
   }
   m_clientAdapter.reset();
 }
 
-void AssociatedURLLoader::setDefersLoading(bool defersLoading) {
+void WebAssociatedURLLoaderImpl::setDefersLoading(bool defersLoading) {
   if (m_loader)
     m_loader->setDefersLoading(defersLoading);
 }
 
-void AssociatedURLLoader::setLoadingTaskRunner(blink::WebTaskRunner*) {
+void WebAssociatedURLLoaderImpl::setLoadingTaskRunner(blink::WebTaskRunner*) {
   // TODO(alexclarke): Maybe support this one day if it proves worthwhile.
 }
 
-void AssociatedURLLoader::documentDestroyed() {
+void WebAssociatedURLLoaderImpl::documentDestroyed() {
   disposeObserver();
   cancelLoader();
 
   if (!m_client)
     return;
 
-  releaseClient()->didFail(this, ResourceError());
+  releaseClient()->didFail(ResourceError());
   // |this| may be dead here.
 }
 
-void AssociatedURLLoader::disposeObserver() {
+void WebAssociatedURLLoaderImpl::disposeObserver() {
   if (!m_observer)
     return;
 
   // TODO(tyoshino): Remove this assert once Document is fixed so that
   // contextDestroyed() is invoked for all kinds of Documents.
   //
   // Currently, the method of detecting Document destruction implemented here
   // doesn't work for all kinds of Documents. In case we reached here after
   // the Oilpan is destroyed, we just crash the renderer process to prevent
   // UaF.
   //
   // We could consider just skipping the rest of code in case
   // ThreadState::current() is null. However, the fact we reached here
   // without cancelling the loader means that it's possible there're some
   // non-Blink non-on-heap objects still facing on-heap Blink objects. E.g.
   // there could be a WebURLLoader instance behind the
   // DocumentThreadableLoader instance. So, for safety, we chose to just
   // crash here.
-  RELEASE_ASSERT(ThreadState::current());
+  CHECK(ThreadState::current());
 
   m_observer->dispose();
   m_observer = nullptr;
 }
 
 }  // namespace blink