Changeset 89086 in webkit

Timestamp:

Jun 16, 2011 4:45:15 PM (13 years ago)

Author:

Nate Chapin

Message:

2011-06-16 Nate Chapin <Nate Chapin>

Reviewed by Alexey Proskuryakov.

Set the referrer on a ResourceRequest from a WorkerThreadableLoader
as soon as the request reaches the main thread and remove the
optionalOutgoingReferrer parameter from some functions.
​https://bugs.webkit.org/show_bug.cgi?id=62806

• loader/DocumentThreadableLoader.cpp: (WebCore::DocumentThreadableLoader::loadResourceSynchronously): (WebCore::DocumentThreadableLoader::create): (WebCore::DocumentThreadableLoader::DocumentThreadableLoader): (WebCore::DocumentThreadableLoader::loadRequest):
• loader/DocumentThreadableLoader.h:
• loader/ResourceLoadScheduler.cpp: (WebCore::ResourceLoadScheduler::scheduleSubresourceLoad):
• loader/ResourceLoadScheduler.h:
• loader/SubresourceLoader.cpp: (WebCore::SubresourceLoader::create):
• loader/SubresourceLoader.h:
• loader/WorkerThreadableLoader.cpp: (WebCore::WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• loader/DocumentThreadableLoader.cpp (modified) (4 diffs)
• loader/DocumentThreadableLoader.h (modified) (3 diffs)
• loader/ResourceLoadScheduler.cpp (modified) (1 diff)
• loader/ResourceLoadScheduler.h (modified) (1 diff)
• loader/SubresourceLoader.cpp (modified) (2 diffs)
• loader/SubresourceLoader.h (modified) (1 diff)
• loader/WorkerThreadableLoader.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-06-16  Nate Chapin  <japhet@chromium.org>
+
+        Reviewed by Alexey Proskuryakov.
+
+        Set the referrer on a ResourceRequest from a WorkerThreadableLoader
+        as soon as the request reaches the main thread and remove the
+        optionalOutgoingReferrer parameter from some functions.
+        https://bugs.webkit.org/show_bug.cgi?id=62806
+
+        * loader/DocumentThreadableLoader.cpp:
+        (WebCore::DocumentThreadableLoader::loadResourceSynchronously):
+        (WebCore::DocumentThreadableLoader::create):
+        (WebCore::DocumentThreadableLoader::DocumentThreadableLoader):
+        (WebCore::DocumentThreadableLoader::loadRequest):
+        * loader/DocumentThreadableLoader.h:
+        * loader/ResourceLoadScheduler.cpp:
+        (WebCore::ResourceLoadScheduler::scheduleSubresourceLoad):
+        * loader/ResourceLoadScheduler.h:
+        * loader/SubresourceLoader.cpp:
+        (WebCore::SubresourceLoader::create):
+        * loader/SubresourceLoader.h:
+        * loader/WorkerThreadableLoader.cpp:
+        (WebCore::WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader):
+
 2011-06-16  Eric Seidel  <eric@webkit.org>
 

trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

@@ -52 +52 @@
 {
     // The loader will be deleted as soon as this function exits.
-    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, &client, LoadSynchronously, request, options, String()));
+    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, &client, LoadSynchronously, request, options));
     ASSERT(loader->hasOneRef());
 }
 
-PassRefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, const ThreadableLoaderOptions& options, const String& optionalOutgoingReferrer)
-{
-    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, request, options, optionalOutgoingReferrer));
+PassRefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, const ThreadableLoaderOptions& options)
+{
+    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, request, options));
     if (!loader->m_loader)
         loader = 0;
@@ -64 +64 @@
 }
 
-DocumentThreadableLoader::DocumentThreadableLoader(Document* document, ThreadableLoaderClient* client, BlockingBehavior blockingBehavior, const ResourceRequest& request, const ThreadableLoaderOptions& options, const String& optionalOutgoingReferrer)
+DocumentThreadableLoader::DocumentThreadableLoader(Document* document, ThreadableLoaderClient* client, BlockingBehavior blockingBehavior, const ResourceRequest& request, const ThreadableLoaderOptions& options)
     : m_client(client)
     , m_document(document)
     , m_options(options)
-    , m_optionalOutgoingReferrer(optionalOutgoingReferrer)
     , m_sameOriginRequest(securityOrigin()->canRequest(request.url()))
     , m_async(blockingBehavior == LoadAsynchronously)
@@ -75 +74 @@
     ASSERT(client);
     // Setting an outgoing referer is only supported in the async code path.
-    ASSERT(m_async || m_optionalOutgoingReferrer.isEmpty());
+    ASSERT(m_async || request.httpReferrer().isEmpty());
 
     if (m_sameOriginRequest || m_options.crossOriginRequestPolicy == AllowCrossOriginRequests) {
@@ -328 +327 @@
         m_loader = 0;
         m_loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_document->frame(), this, request, ResourceLoadPriorityMedium, securityCheck, sendLoadCallbacks,
-                                                                    sniffContent, m_optionalOutgoingReferrer, shouldBufferData);
+                                                                    sniffContent, shouldBufferData);
         return;
     }

trunk/Source/WebCore/loader/DocumentThreadableLoader.h

@@ -53 +53 @@
     public:
         static void loadResourceSynchronously(Document*, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
-        static PassRefPtr<DocumentThreadableLoader> create(Document*, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&, const String& optionalOutgoingReferrer = String());
+        static PassRefPtr<DocumentThreadableLoader> create(Document*, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&);
         virtual ~DocumentThreadableLoader();
 
@@ -72 +72 @@
         };
 
-        DocumentThreadableLoader(Document*, ThreadableLoaderClient*, BlockingBehavior, const ResourceRequest&, const ThreadableLoaderOptions&, const String& optionalOutgoingReferrer);
+        DocumentThreadableLoader(Document*, ThreadableLoaderClient*, BlockingBehavior, const ResourceRequest&, const ThreadableLoaderOptions&);
 
         virtual void willSendRequest(SubresourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
@@ -103 +103 @@
         Document* m_document;
         ThreadableLoaderOptions m_options;
-        String m_optionalOutgoingReferrer;
         bool m_sameOriginRequest;
         bool m_async;

trunk/Source/WebCore/loader/ResourceLoadScheduler.cpp

@@ -85 +85 @@
 
 PassRefPtr<SubresourceLoader> ResourceLoadScheduler::scheduleSubresourceLoad(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, ResourceLoadPriority priority, SecurityCheckPolicy securityCheck,
-                                                                             bool sendResourceLoadCallbacks, bool shouldContentSniff, const String& optionalOutgoingReferrer, bool shouldBufferData)
-{
-    RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, client, request, securityCheck, sendResourceLoadCallbacks, shouldContentSniff, optionalOutgoingReferrer, shouldBufferData);
+                                                                             bool sendResourceLoadCallbacks, bool shouldContentSniff, bool shouldBufferData)
+{
+    RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, client, request, securityCheck, sendResourceLoadCallbacks, shouldContentSniff, shouldBufferData);
     if (loader)
         scheduleLoad(loader.get(), priority);

trunk/Source/WebCore/loader/ResourceLoadScheduler.h

@@ -51 +51 @@
     friend ResourceLoadScheduler* resourceLoadScheduler();
 
-    PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, SubresourceLoaderClient*, const ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityLow, SecurityCheckPolicy = DoSecurityCheck, bool sendResourceLoadCallbacks = true, bool shouldContentSniff = true, const String& optionalOutgoingReferrer = String(), bool shouldBufferData = true);
+    PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, SubresourceLoaderClient*, const ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityLow, SecurityCheckPolicy = DoSecurityCheck, bool sendResourceLoadCallbacks = true, bool shouldContentSniff = true, bool shouldBufferData = true);
     PassRefPtr<NetscapePlugInStreamLoader> schedulePluginStreamLoad(Frame*, NetscapePlugInStreamLoaderClient*, const ResourceRequest&);
     void addMainResourceLoad(ResourceLoader*);

trunk/Source/WebCore/loader/SubresourceLoader.cpp

@@ -62 +62 @@
 }
 
-PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, SecurityCheckPolicy securityCheck, bool sendResourceLoadCallbacks, bool shouldContentSniff, const String& optionalOutgoingReferrer, bool shouldBufferData)
+PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, SecurityCheckPolicy securityCheck, bool sendResourceLoadCallbacks, bool shouldContentSniff, bool shouldBufferData)
 {
     if (!frame)
@@ -84 +84 @@
     String outgoingReferrer;
     String outgoingOrigin;
-    if (optionalOutgoingReferrer.isNull()) {
+    if (request.httpReferrer().isNull()) {
         outgoingReferrer = fl->outgoingReferrer();
         outgoingOrigin = fl->outgoingOrigin();
     } else {
-        outgoingReferrer = optionalOutgoingReferrer;
+        outgoingReferrer = request.httpReferrer();
         outgoingOrigin = SecurityOrigin::createFromString(outgoingReferrer)->toString();
     }

trunk/Source/WebCore/loader/SubresourceLoader.h

@@ -42 +42 @@
     class SubresourceLoader : public ResourceLoader {
     public:
-        static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&, SecurityCheckPolicy = DoSecurityCheck, bool sendResourceLoadCallbacks = true, bool shouldContentSniff = true, const String& optionalOutgoingReferrer = String(), bool shouldBufferData = true);
+        static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&, SecurityCheckPolicy = DoSecurityCheck, bool sendResourceLoadCallbacks = true, bool shouldContentSniff = true, bool shouldBufferData = true);
 
         void clearClient() { m_client = 0; }

trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp

@@ -112 +112 @@
 
     OwnPtr<ResourceRequest> request(ResourceRequest::adopt(requestData));
+    request->setHTTPReferrer(outgoingReferrer);
     // FIXME: If the a site requests a local resource, then this will return a non-zero value but the sync path
     // will return a 0 value.  Either this should return 0 or the other code path should do a callback with
     // a failure.
-    thisPtr->m_mainThreadLoader = DocumentThreadableLoader::create(document, thisPtr, *request, options, outgoingReferrer);
+    thisPtr->m_mainThreadLoader = DocumentThreadableLoader::create(document, thisPtr, *request, options);
     ASSERT(thisPtr->m_mainThreadLoader);
 }