Delete NetworkingContext and its subclasses.

Source/core/platform/network/ResourceHandle.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 15 matching lines @@
  * 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 "config.h"
 #include "core/platform/network/ResourceHandle.h"
 
 #include "core/platform/chromium/support/WrappedResourceRequest.h"
 #include "core/platform/chromium/support/WrappedResourceResponse.h"
-#include "core/platform/network/NetworkingContext.h"
 #include "core/platform/network/ResourceError.h"
 #include "core/platform/network/ResourceHandleClient.h"
 #include "core/platform/network/ResourceHandleInternal.h"
 #include "core/platform/network/ResourceRequest.h"
 #include "core/platform/network/ResourceResponse.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURLError.h"
 #include "public/platform/WebURLLoader.h"
 #include "public/platform/WebURLLoaderClient.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/WebURLResponse.h"
 
 using namespace WebKit;
 
 namespace WebCore {
 
 // ResourceHandleInternal -----------------------------------------------------
-ResourceHandleInternal::ResourceHandleInternal(NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client)
-    : m_context(context)
-    , m_request(request)
+ResourceHandleInternal::ResourceHandleInternal(const ResourceRequest& request, ResourceHandleClient* client)
+    : m_request(request)
     , m_owner(0)
     , m_client(client)
     , m_state(ConnectionStateNew)
 {
 }
 
 void ResourceHandleInternal::start(StoredCredentials storedCredentials)
 {
     if (m_state != ConnectionStateNew)
         CRASH();
@@ skipping 99 matching lines @@
     m_client->didFail(m_owner, error);
 }
 
 ResourceHandleInternal* ResourceHandleInternal::FromResourceHandle(ResourceHandle* handle)
 {
     return handle->d.get();
 }
 
 // ResourceHandle -------------------------------------------------------------
 
-ResourceHandle::ResourceHandle(NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool shouldContentSniff)
-    : d(adoptPtr(new ResourceHandleInternal(context, request, client)))
+ResourceHandle::ResourceHandle(const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool shouldContentSniff)
+    : d(adoptPtr(new ResourceHandleInternal(request, client)))
 {
     d->setOwner(this);
 
     // FIXME: Figure out what to do with the bool params.
 }
 
-PassRefPtr<ResourceHandle> ResourceHandle::create(NetworkingContext* context,
-                                                  const ResourceRequest& request,
+PassRefPtr<ResourceHandle> ResourceHandle::create(const ResourceRequest& request,
                                                   ResourceHandleClient* client,
                                                   bool defersLoading,
                                                   bool shouldContentSniff,
                                                   StoredCredentials storedCredentials)
 {
-    RefPtr<ResourceHandle> newHandle = adoptRef(new ResourceHandle(
-        context, request, client, defersLoading, shouldContentSniff));
+    RefPtr<ResourceHandle> newHandle = adoptRef(new ResourceHandle(request, client, defersLoading, shouldContentSniff));
 
-    if (newHandle->start(storedCredentials))
-        return newHandle.release();
-
-    return 0;
+    newHandle->start(storedCredentials);
+    return newHandle.release();
 }
 
 ResourceRequest& ResourceHandle::firstRequest()
 {
     return d->request();
 }
 
-NetworkingContext* ResourceHandle::context() const
-{
-    return d->context();
-}
-
 ResourceHandleClient* ResourceHandle::client() const
 {
     return d->client();
 }
 
 void ResourceHandle::setClient(ResourceHandleClient* client)
 {
     d->setClient(client);
 }
 
 void ResourceHandle::setDefersLoading(bool value)
 {
     d->setDefersLoading(value);
 }
 
-bool ResourceHandle::start(StoredCredentials storedCredentials)
+void ResourceHandle::start(StoredCredentials storedCredentials)
 {
-    if (!d->context())
-        return false;

[abarth-chromium, 2013/06/03 21:11:53]

This probably allows data URLs in SVG in <img> to work again.

[pdr., 2013/06/03 21:34:42]

Not quite, but very close.

-
     d->start(storedCredentials);
-    return true;
 }
 
 void ResourceHandle::cancel()
 {
     d->cancel();
 }
 
 ResourceHandle::~ResourceHandle()
 {
     d->setOwner(0);
 }
 
 // static
-void ResourceHandle::loadResourceSynchronously(NetworkingContext* context,
-                                               const ResourceRequest& request,
+void ResourceHandle::loadResourceSynchronously(const ResourceRequest& request,
                                                StoredCredentials storedCredentials,
                                                ResourceError& error,
                                                ResourceResponse& response,
                                                Vector<char>& data)
 {
     OwnPtr<WebURLLoader> loader = adoptPtr(Platform::current()->createURLLoader());
     ASSERT(loader);
 
     WrappedResourceRequest requestIn(request);
     requestIn.setAllowStoredCredentials(storedCredentials == AllowStoredCredentials);
@@ skipping 13 matching lines @@
     d->didChangePriority(static_cast<WebURLRequest::Priority>(newPriority));
 }
 
 // static
 void ResourceHandle::cacheMetadata(const ResourceResponse& response, const Vector<char>& data)
 {
     WebKit::Platform::current()->cacheMetadata(response.url(), response.responseTime(), data.data(), data.size());
 }
 
 } // namespace WebCore