Add enableReferrers and enableHyperlinkAuditing to contentSettings.misc API.

content/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 394 matching lines @@
   if (HandleExternalProtocol(request_id, child_id, route_id,
                              request_data.url, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
   net::URLRequest* request = new net::URLRequest(request_data.url, this);
   request->set_method(request_data.method);
   request->set_first_party_for_cookies(request_data.first_party_for_cookies);
-  request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kNoReferrers) ? std::string() : request_data.referrer.spec());
+  request->set_referrer(ReferrersEnabled() ? request_data.referrer.spec()
+                                           : std::string());
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(request_data.headers);
   request->SetExtraRequestHeaders(headers);
 
   int load_flags = request_data.load_flags;
   // Although EV status is irrelevant to sub-frames and sub-resources, we have
   // to perform EV certificate verification on all resources because an HTTP
   // keep-alive connection created to load a sub-frame or a sub-resource could
   // be reused to load a main frame.
   load_flags |= net::LOAD_VERIFY_EV_CERT;
@@ skipping 288 matching lines @@
                                                 ResourceType::MAIN_FRAME);
   }
 
   if (!net::URLRequest::IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     return;
   }
 
   request->set_method("GET");
-  request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kNoReferrers) ? std::string() : referrer.spec());
+  request->set_referrer(ReferrersEnabled() ? referrer.spec()
+                                           : std::string());
   request->set_context(request_context);
   request->set_load_flags(request->load_flags() |
       net::LOAD_IS_DOWNLOAD);
 
   ResourceDispatcherHostRequestInfo* extra_info =
       CreateRequestInfoForBrowserRequest(handler, child_id, route_id, true);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
 
   BeginRequestInternal(request);
 }
@@ skipping 19 matching lines @@
   if (!known_proto) {
     // Since any URLs which have non-standard scheme have been filtered
     // by save manager(see GURL::SchemeIsStandard). This situation
     // should not happen.
     NOTREACHED();
     return;
   }
 
   net::URLRequest* request = new net::URLRequest(url, this);
   request->set_method("GET");
-  request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kNoReferrers) ? std::string() : referrer.spec());
+  request->set_referrer(ReferrersEnabled() ? referrer.spec()
+                                           : std::string());
   // So far, for saving page, we need fetch content from cache, in the
   // future, maybe we can use a configuration to configure this behavior.
   request->set_load_flags(net::LOAD_PREFERRING_CACHE);
   request->set_context(request_context);
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceDispatcherHostRequestInfo* extra_info =
       CreateRequestInfoForBrowserRequest(handler, child_id, route_id, false);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
 
@@ skipping 1160 matching lines @@
 
 bool ResourceDispatcherHost::IsPrerenderingChildRoutePair(int child_id,
                                                           int route_id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   std::pair<int, int> c_r_pair = std::make_pair(child_id, route_id);
   return (prerender_child_route_pairs_.find(c_r_pair) !=
             prerender_child_route_pairs_.end());
 }
 
 
+bool ResourceDispatcherHost::ReferrersEnabled() {
+  // If we're not being called through the ResourceMessageFilter, referrers
+  // should have been stripped beforehand.
+  if (!filter_)
+    return true;
+  return filter_->referrers_enabled();
+}
+
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled() {
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
   is_prefetch_enabled_ = value;
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled_ = false;