Pass along the referrer policy (renderer side)

content/renderer/render_view_impl.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 95 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerAction.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNodeList.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPageSerializer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPlugin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginParams.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebPoint.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRange.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebReferrerPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScriptSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSearchableFormData.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSettings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageNamespace.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaCallbacks.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
@@ skipping 80 matching lines @@
 using WebKit::WebPageSerializer;
 using WebKit::WebPageSerializerClient;
 using WebKit::WebPlugin;
 using WebKit::WebPluginContainer;
 using WebKit::WebPluginDocument;
 using WebKit::WebPluginParams;
 using WebKit::WebPoint;
 using WebKit::WebPopupMenuInfo;
 using WebKit::WebRange;
 using WebKit::WebRect;
+using WebKit::WebReferrerPolicy;
 using WebKit::WebScriptSource;
 using WebKit::WebSearchableFormData;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebSettings;
 using WebKit::WebSharedWorker;
 using WebKit::WebSize;
 using WebKit::WebStorageNamespace;
 using WebKit::WebStorageQuotaCallbacks;
 using WebKit::WebStorageQuotaError;
@@ skipping 13 matching lines @@
 using WebKit::WebWorker;
 using WebKit::WebWorkerClient;
 using appcache::WebApplicationCacheHostImpl;
 using base::Time;
 using base::TimeDelta;
 using content::DocumentState;
 using content::NavigationState;
 using content::RenderThread;
 using content::RenderViewObserver;
 using content::RenderViewVisitor;
+using content::Referrer;
 using content::V8ValueConverter;
 using webkit_glue::AltErrorPageResourceFetcher;
 using webkit_glue::FormField;
 using webkit_glue::PasswordForm;
 using webkit_glue::PasswordFormDomManager;
 using webkit_glue::ResourceFetcher;
 
 //-----------------------------------------------------------------------------
 
 typedef std::map<WebKit::WebView*, RenderViewImpl*> ViewMap;
@@ skipping 36 matching lines @@
       document_state->set_alt_error_page_fetcher(NULL);
   }
 }
 
 static bool IsReload(const ViewMsg_Navigate_Params& params) {
   return
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD ||
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
 }
 
+static WebReferrerPolicy getReferrerPolicyFromRequest(
+    const WebURLRequest& request) {
+  return request.extraData() ?
+      static_cast<RequestExtraData*>(request.extraData())->referrer_policy() :
+      WebKit::WebReferrerPolicyDefault;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 int32 RenderViewImpl::next_page_id_ = 1;
 
 struct RenderViewImpl::PendingFileChooser {
   PendingFileChooser(const content::FileChooserParams& p,
                      WebFileChooserCompletion* c)
       : params(p),
         completion(c) {
   }
@@ skipping 449 matching lines @@
   } else {
     // Navigate to the given URL.
     WebURLRequest request(params.url);
 
     // A session history navigation should have been accompanied by state.
     DCHECK_EQ(params.page_id, -1);
 
     if (main_frame->isViewSourceModeEnabled())
       request.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad);
 
-    if (params.referrer.is_valid()) {
-      if (!WebSecurityPolicy::shouldHideReferrer(
-              params.url,
-              WebString::fromUTF8(params.referrer.spec()))) {
-        request.setHTTPHeaderField(WebString::fromUTF8("Referer"),
-                                   WebString::fromUTF8(params.referrer.spec()));
-      }
+    if (params.referrer.url.is_valid()) {
+      WebString referrer = WebSecurityPolicy::generateReferrerHeader(
+          params.referrer.policy,
+          params.url,
+          WebString::fromUTF8(params.referrer.url.spec()));
+      if (!referrer.isEmpty())
+        request.setHTTPHeaderField(WebString::fromUTF8("Referer"), referrer);
     }
 
     if (!params.extra_headers.empty()) {
       for (net::HttpUtil::HeadersIterator i(params.extra_headers.begin(),
                                             params.extra_headers.end(), "\n");
            i.GetNext(); ) {
         request.addHTTPHeaderField(WebString::fromUTF8(i.name()),
                                    WebString::fromUTF8(i.values()));
       }
     }
@@ skipping 345 matching lines @@
       //    MANUAL_SUBFRAME, it will be that same transition type here.
       // We don't want that, because any navigation that changes the toplevel
       // frame should be tracked as a toplevel navigation (this allows us to
       // update the URL bar, etc).
       params.transition = content::PAGE_TRANSITION_LINK;
     }
 
     // If we have a valid consumed client redirect source,
     // the page contained a client redirect (meta refresh, document.loc...),
     // so we set the referrer and transition to match.
-    if (completed_client_redirect_src_.is_valid()) {
-      DCHECK(completed_client_redirect_src_ == params.redirects[0]);
+    if (completed_client_redirect_src_.url.is_valid()) {
+      DCHECK(completed_client_redirect_src_.url == params.redirects[0]);
       params.referrer = completed_client_redirect_src_;
       params.transition = static_cast<content::PageTransition>(
           params.transition | content::PAGE_TRANSITION_CLIENT_REDIRECT);
     } else {
       // Bug 654101: the referrer will be empty on https->http transitions. It
       // would be nice if we could get the real referrer from somewhere.
-      params.referrer = GURL(
-          original_request.httpHeaderField(WebString::fromUTF8("Referer")));
+      params.referrer = Referrer(GURL(
+          original_request.httpHeaderField(WebString::fromUTF8("Referer"))),
+          getReferrerPolicyFromRequest(original_request));
     }
 
     string16 method = request.httpMethod();
     if (EqualsASCII(method, "POST"))
       params.is_post = true;
 
     // Save some histogram data so we can compute the average memory used per
     // page load of the glyphs.
     UMA_HISTOGRAM_COUNTS_10000("Memory.GlyphPagesPerLoad",
                                webkit_glue::GetGlyphPageCount());
@@ skipping 64 matching lines @@
       webview()->mainFrame()->previousHistoryItem();
   if (item.isNull())
     return;
 
   Send(new ViewHostMsg_UpdateState(
       routing_id_, page_id_, webkit_glue::HistoryItemToString(item)));
 }
 
 void RenderViewImpl::OpenURL(WebFrame* frame,
                              const GURL& url,
-                             const GURL& referrer,
+                             const Referrer& referrer,
                              WebNavigationPolicy policy) {
   Send(new ViewHostMsg_OpenURL(
       routing_id_,
       url,
       referrer,
       NavigationPolicyToDisposition(policy),
       frame->identifier()));
 }
 
 // WebViewDelegate ------------------------------------------------------------
@@ skipping 723 matching lines @@
 
 void RenderViewImpl::loadURLExternally(
     WebFrame* frame, const WebURLRequest& request,
     WebNavigationPolicy policy,
     const WebString& suggested_name) {
   GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
   if (policy == WebKit::WebNavigationPolicyDownload) {
     Send(new ViewHostMsg_DownloadUrl(routing_id_, request.url(), referrer,
                                      suggested_name));
   } else {
-    OpenURL(frame, request.url(), referrer, policy);
+    OpenURL(frame, request.url(),
+            Referrer(referrer, getReferrerPolicyFromRequest(request)), policy);
   }
 }
 
 WebNavigationPolicy RenderViewImpl::decidePolicyForNavigation(
     WebFrame* frame, const WebURLRequest& request, WebNavigationType type,
     const WebNode&, WebNavigationPolicy default_policy, bool is_redirect) {
   // TODO(creis): Remove this when we fix OnSwapOut to not need a navigation.
   if (is_swapped_out_) {
     DCHECK(request.url() == GURL("about:swappedout"));
     return default_policy;
@@ skipping 16 matching lines @@
   // boundaries.  This is currently expected to break some script calls and
   // navigations, such as form submissions.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableStrictSiteIsolation) &&
       !frame->parent() && (is_content_initiated || is_redirect)) {
     WebString origin_str = frame->document().securityOrigin().toString();
     GURL frame_url(origin_str.utf8().data());
     // TODO(cevans): revisit whether this origin check is still necessary once
     // crbug.com/101395 is fixed.
     if (frame_url.GetOrigin() != url.GetOrigin()) {
-      GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
+      Referrer referrer(
+          GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
+          getReferrerPolicyFromRequest(request));
       OpenURL(frame, url, referrer, default_policy);
       return WebKit::WebNavigationPolicyIgnore;
     }
   }
 
   // If the browser is interested, then give it a chance to look at top level
   // navigations.
   if (is_content_initiated &&
       renderer_preferences_.browser_handles_top_level_requests &&
       IsNonLocalTopLevelNavigation(url, frame, type)) {
-    GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
+    Referrer referrer(
+        GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
+        getReferrerPolicyFromRequest(request));
     // Reset these counters as the RenderView could be reused for the next
     // navigation.
     page_id_ = -1;
     last_page_id_sent_to_browser_ = -1;
     OpenURL(frame, url, referrer, default_policy);
     return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
   }
 
   // Detect when we're crossing a permission-based boundary (e.g. into or out of
   // an extension or app origin, leaving a WebUI page, etc). We only care about
@@ skipping 22 matching lines @@
 
     if (!should_fork) {
       // Give the embedder a chance.
       bool is_initial_navigation = page_id_ == -1;
       should_fork = content::GetContentClient()->renderer()->ShouldFork(
           frame, url, is_content_initiated, is_initial_navigation,
           &send_referrer);
     }
 
     if (should_fork) {
-      GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
-      OpenURL(frame, url, send_referrer ? referrer : GURL(), default_policy);
+      Referrer referrer(
+          GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
+          getReferrerPolicyFromRequest(request));
+      OpenURL(
+          frame, url, send_referrer ? referrer : Referrer(), default_policy);
       return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // Use the frame's original request's URL rather than the document's URL for
   // this check.  For a popup, the document's URL may become the opener window's
   // URL if the opener has called document.write.  See http://crbug.com/93517.
   GURL old_url(frame->dataSource()->request().url());
 
   // Detect when a page is "forking" a new tab that can be safely rendered in
@@ skipping 49 matching lines @@
       frame->name().isNull() &&
       // Another frame (with a non-empty creator) should have initiated the
       // request, targeted at this frame.
       !creator_url_.is_empty() &&
       is_content_initiated &&
       default_policy == WebKit::WebNavigationPolicyCurrentTab &&
       type == WebKit::WebNavigationTypeOther;
 
   if (is_fork || is_noreferrer_and_blank_target) {
     // Open the URL via the browser, not via WebKit.
-    OpenURL(frame, url, GURL(), default_policy);
+    OpenURL(frame, url, Referrer(), default_policy);
     return WebKit::WebNavigationPolicyIgnore;
   }
 
   return default_policy;
 }
 
 bool RenderViewImpl::canHandleRequest(
     WebFrame* frame, const WebURLRequest& request) {
   // We allow WebKit to think that everything can be handled even though
   // browser-side we limit what we load.
@@ skipping 77 matching lines @@
       WillPerformClientRedirect(frame, from, to, interval, fire_time));
 }
 
 void RenderViewImpl::didCancelClientRedirect(WebFrame* frame) {
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidCancelClientRedirect(frame));
 }
 
 void RenderViewImpl::didCompleteClientRedirect(
     WebFrame* frame, const WebURL& from) {
-  if (!frame->parent())
-    completed_client_redirect_src_ = from;
+  if (!frame->parent()) {
+    WebDataSource* ds = frame->provisionalDataSource();
+    // If there's no provisional data source, it's a reference fragment
+    // navigation.
+    completed_client_redirect_src_ = Referrer(
+        from, ds ? getReferrerPolicyFromRequest(ds->request()) :
+        frame->referrerPolicy());
+  }
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidCompleteClientRedirect(frame, from));
 }
 
 void RenderViewImpl::didCreateDataSource(WebFrame* frame, WebDataSource* ds) {
   DocumentState* document_state = DocumentState::FromDataSource(ds);
   if (!document_state) {
     document_state = new DocumentState;
     ds->setExtraData(document_state);
   }
@@ skipping 113 matching lines @@
 
   // Start time is only set after request time.
   document_state->set_start_load_time(Time::Now());
 
   bool is_top_most = !frame->parent();
   if (is_top_most) {
     navigation_gesture_ = frame->isProcessingUserGesture() ?
         NavigationGestureUser : NavigationGestureAuto;
 
     // Make sure redirect tracking state is clear for the new load.
-    completed_client_redirect_src_ = GURL();
+    completed_client_redirect_src_ = Referrer();
   } else if (frame->parent()->isLoading()) {
     // Take note of AUTO_SUBFRAME loads here, so that we can know how to
     // load an error page.  See didFailProvisionalLoad.
     document_state->navigation_state()->set_transition_type(
         content::PAGE_TRANSITION_AUTO_SUBFRAME);
   }
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidStartProvisionalLoad(frame));
 
@@ skipping 169 matching lines @@
   // the session history again.  We do this regardless of whether this is
   // a session history navigation, because if we attempted a session history
   // navigation without valid HistoryItem state, WebCore will think it is a
   // new navigation.
   navigation_state->set_request_committed(true);
 
   UpdateURL(frame);
 
   // If this committed load was initiated by a client redirect, we're
   // at the last stop now, so clear it.
-  completed_client_redirect_src_ = GURL();
+  completed_client_redirect_src_ = Referrer();
 
   // Check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
 void RenderViewImpl::didClearWindowObject(WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidClearWindowObject(frame));
 
   GURL frame_url = frame->document().url();
@@ skipping 1350 matching lines @@
 void RenderViewImpl::OnGetAllSavableResourceLinksForCurrentPage(
     const GURL& page_url) {
   // Prepare list to storage all savable resource links.
   std::vector<GURL> resources_list;
   std::vector<GURL> referrers_list;
   std::vector<GURL> frames_list;
   webkit_glue::SavableResourcesResult result(&resources_list,
                                              &referrers_list,
                                              &frames_list);
 
+  // FIXME(rdsmith): When GetAllSavableResourceLinksForCurrentPage starts to
+  // return referrers, it should also return the referrer policies.
   if (!webkit_glue::GetAllSavableResourceLinksForCurrentPage(
           webview(),
           page_url,
           &result,
           chrome::GetSavableSchemes())) {
     // If something is wrong when collecting all savable resource links,
     // send empty list to embedder(browser) to tell it failed.
     referrers_list.clear();
     resources_list.clear();
     frames_list.clear();
@@ skipping 812 matching lines @@
   return !!RenderThreadImpl::current()->compositor_thread();
 }
 
 void RenderViewImpl::OnJavaBridgeInit(
     const IPC::ChannelHandle& channel_handle) {
   DCHECK(!java_bridge_dispatcher_.get());
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_.reset(new JavaBridgeDispatcher(this, channel_handle));
 #endif
 }