WebURLRequest: Track the requesting document's URL through navigations.

Source/platform/network/ResourceRequest.cpp

 /*
  * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2009, 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 22 matching lines @@
 
 double ResourceRequest::s_defaultTimeoutInterval = INT_MAX;
 
 PassOwnPtr<ResourceRequest> ResourceRequest::adopt(PassOwnPtr<CrossThreadResourceRequestData> data)
 {
     OwnPtr<ResourceRequest> request = adoptPtr(new ResourceRequest());
     request->setURL(data->m_url);
     request->setCachePolicy(data->m_cachePolicy);
     request->setTimeoutInterval(data->m_timeoutInterval);
     request->setFirstPartyForCookies(data->m_firstPartyForCookies);
+    request->setRequestorURL(data->m_requestorURL);
     request->setHTTPMethod(AtomicString(data->m_httpMethod));
     request->setPriority(data->m_priority, data->m_intraPriorityValue);
 
     request->m_httpHeaderFields.adopt(data->m_httpHeaders.release());
 
     request->setHTTPBody(data->m_httpBody);
     request->setAllowStoredCredentials(data->m_allowStoredCredentials);
     request->setReportUploadProgress(data->m_reportUploadProgress);
     request->setHasUserGesture(data->m_hasUserGesture);
     request->setDownloadToFile(data->m_downloadToFile);
@@ skipping 17 matching lines @@
     return request.release();
 }
 
 PassOwnPtr<CrossThreadResourceRequestData> ResourceRequest::copyData() const
 {
     OwnPtr<CrossThreadResourceRequestData> data = adoptPtr(new CrossThreadResourceRequestData());
     data->m_url = url().copy();
     data->m_cachePolicy = cachePolicy();
     data->m_timeoutInterval = timeoutInterval();
     data->m_firstPartyForCookies = firstPartyForCookies().copy();
+    data->m_requestorURL = requestorURL().copy();
     data->m_httpMethod = httpMethod().string().isolatedCopy();
     data->m_httpHeaders = httpHeaderFields().copyData();
     data->m_priority = priority();
     data->m_intraPriorityValue = m_intraPriorityValue;
 
     if (m_httpBody)
         data->m_httpBody = m_httpBody->deepCopy();
     data->m_allowStoredCredentials = m_allowStoredCredentials;
     data->m_reportUploadProgress = m_reportUploadProgress;
     data->m_hasUserGesture = m_hasUserGesture;
@@ skipping 70 matching lines @@
 const KURL& ResourceRequest::firstPartyForCookies() const
 {
     return m_firstPartyForCookies;
 }
 
 void ResourceRequest::setFirstPartyForCookies(const KURL& firstPartyForCookies)
 {
     m_firstPartyForCookies = firstPartyForCookies;
 }
 
+const KURL& ResourceRequest::requestorURL() const
+{
+    return m_requestorURL;
+}
+
+void ResourceRequest::setRequestorURL(const KURL& requestorURL)
+{
+    m_requestorURL = requestorURL;
+}
+
 const AtomicString& ResourceRequest::httpMethod() const
 {
     return m_httpMethod;
 }
 
 void ResourceRequest::setHTTPMethod(const AtomicString& httpMethod)
 {
     m_httpMethod = httpMethod;
 }
 
@@ skipping 137 matching lines @@
 
     if (a.cachePolicy() != b.cachePolicy())
         return false;
 
     if (a.timeoutInterval() != b.timeoutInterval())
         return false;
 
     if (a.firstPartyForCookies() != b.firstPartyForCookies())
         return false;
 
+    if (a.requestorURL() != b.requestorURL())

[jochen (gone - plz use gerrit), 2015/04/13 13:07:02]

my main concern is whether this will negatively impact cache hit rates

[Mike West, 2015/04/21 12:46:23]

That's a fair concern. I suppose we can drop this bit for now, and allow
coalescing requests for the same resource. If we end up with interesting
policies associated with the requestor, however, we'd need to break the caching
link. :/

+        return false;
+
     if (a.httpMethod() != b.httpMethod())
         return false;
 
     if (a.allowStoredCredentials() != b.allowStoredCredentials())
         return false;
 
     if (a.priority() != b.priority())
         return false;
 
     if (a.referrerPolicy() != b.referrerPolicy())
@@ skipping 122 matching lines @@
 // This is used by the loader to control the number of issued parallel load requests.
 unsigned initializeMaximumHTTPConnectionCountPerHost()
 {
     // The chromium network stack already handles limiting the number of
     // parallel requests per host, so there's no need to do it here.  Therefore,
     // this is set to a high value that should never be hit in practice.
     return 10000;
 }
 
 } // namespace blink