More progress towards removing content settings code from the content layer. We can't use Cookie...

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 22 matching lines @@
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ssl/ssl_client_auth_handler.h"
 #include "chrome/browser/ssl/ssl_manager.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/cert_store.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/chrome_blob_storage_context.h"
+#include "content/browser/content_browser_client.h"
 #include "content/browser/cross_site_request_manager.h"
 #include "content/browser/in_process_webkit/webkit_thread.h"
 #include "content/browser/plugin_service.h"
 #include "content/browser/resource_context.h"
 #include "content/browser/renderer_host/async_resource_handler.h"
 #include "content/browser/renderer_host/buffered_resource_handler.h"
 #include "content/browser/renderer_host/cross_site_resource_handler.h"
 #include "content/browser/renderer_host/global_request_id.h"
 #include "content/browser/renderer_host/redirect_to_file_resource_handler.h"
 #include "content/browser/renderer_host/render_view_host.h"
@@ skipping 507 matching lines @@
       new ResourceDispatcherHostRequestInfo(
           handler,
           process_type,
           child_id,
           route_id,
           request_id,
           request_data.resource_type,
           upload_size,
           false,  // is download
           ResourceType::IsFrame(request_data.resource_type),  // allow_download
-          request_data.has_user_gesture);
+          request_data.has_user_gesture,
+          &resource_context);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
   chrome_browser_net::SetOriginPIDForRequest(
       request_data.origin_pid, request);
 
   if (request->url().SchemeIs(chrome::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     webkit_blob::BlobStorageController* controller =
         resource_context.blob_storage_context()->controller();
     extra_info->set_requested_blob_data(
@@ skipping 109 matching lines @@
 
 ResourceHandler* ResourceDispatcherHost::CreateSafeBrowsingResourceHandler(
     ResourceHandler* handler, int child_id, int route_id,
     ResourceType::Type resource_type) {
   return SafeBrowsingResourceHandler::Create(
       handler, child_id, route_id, resource_type, safe_browsing_, this);
 }
 
 ResourceDispatcherHostRequestInfo*
 ResourceDispatcherHost::CreateRequestInfoForBrowserRequest(
-    ResourceHandler* handler, int child_id, int route_id, bool download) {
+    ResourceHandler* handler,
+    int child_id,
+    int route_id,
+    bool download,
+    const content::ResourceContext& context) {
   return new ResourceDispatcherHostRequestInfo(handler,
                                                ChildProcessInfo::RENDER_PROCESS,
                                                child_id,
                                                route_id,
                                                request_id_,
                                                ResourceType::SUB_RESOURCE,
                                                0,         // upload_size
                                                download,  // is_download
                                                download,  // allow_download
-                                               false);    // has_user_gesture
+                                               false,     // has_user_gesture
+                                               &context);
 }
 
 void ResourceDispatcherHost::OnClosePageACK(
     const ViewMsg_ClosePage_Params& params) {
   if (params.for_cross_site_transition) {
     // Closes for cross-site transitions are handled such that the cross-site
     // transition continues.
     GlobalRequestID global_id(params.new_render_process_host_id,
                               params.new_request_id);
     PendingRequestList::iterator i = pending_requests_.find(global_id);
@@ skipping 16 matching lines @@
 }
 
 // We are explicitly forcing the download of 'url'.
 void ResourceDispatcherHost::BeginDownload(
     const GURL& url,
     const GURL& referrer,
     const DownloadSaveInfo& save_info,
     bool prompt_for_save_location,
     int child_id,
     int route_id,
-    net::URLRequestContext* request_context) {
+    const content::ResourceContext& context) {
   if (is_shutdown_)
     return;
 
   // Check if the renderer is permitted to request the requested URL.
   if (!ChildProcessSecurityPolicy::GetInstance()->
           CanRequestURL(child_id, url)) {
     VLOG(1) << "Denied unauthorized download request for "
             << url.possibly_invalid_spec();
     return;
   }
@@ skipping 24 matching lines @@
   }
 
   if (!net::URLRequest::IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     return;
   }
 
   request->set_method("GET");
   request->set_referrer(MaybeStripReferrer(referrer).spec());
-  request->set_context(request_context);
+  request->set_context(context.request_context());
   request->set_load_flags(request->load_flags() |
       net::LOAD_IS_DOWNLOAD);
 
   ResourceDispatcherHostRequestInfo* extra_info =
-      CreateRequestInfoForBrowserRequest(handler, child_id, route_id, true);
+      CreateRequestInfoForBrowserRequest(
+          handler, child_id, route_id, true, context);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
 
   BeginRequestInternal(request);
 }
 
 // This function is only used for saving feature.
 void ResourceDispatcherHost::BeginSaveFile(
     const GURL& url,
     const GURL& referrer,
     int child_id,
     int route_id,
-    net::URLRequestContext* request_context) {
+    const content::ResourceContext& context) {
   if (is_shutdown_)
     return;
 
   scoped_refptr<ResourceHandler> handler(
       new SaveFileResourceHandler(child_id,
                                   route_id,
                                   url,
                                   save_file_manager_.get()));
   request_id_--;
 
   bool known_proto = net::URLRequest::IsHandledURL(url);
   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(MaybeStripReferrer(referrer).spec());
   // 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);
+  request->set_context(context.request_context());
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceDispatcherHostRequestInfo* extra_info =
-      CreateRequestInfoForBrowserRequest(handler, child_id, route_id, false);
+      CreateRequestInfoForBrowserRequest(
+          handler, child_id, route_id, false, context);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
 
   BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::FollowDeferredRedirect(
     int child_id,
     int request_id,
     bool has_new_first_party_for_cookies,
     const GURL& new_first_party_for_cookies) {
@@ skipping 271 matching lines @@
 }
 
 void ResourceDispatcherHost::OnSSLCertificateError(
     net::URLRequest* request,
     int cert_error,
     net::X509Certificate* cert) {
   DCHECK(request);
   SSLManager::OnSSLCertificateError(this, request, cert_error, cert);
 }
 
-void ResourceDispatcherHost::OnGetCookies(
-    net::URLRequest* request,
-    bool blocked_by_policy) {
+bool ResourceDispatcherHost::CanGetCookies(net::URLRequest* request) {
   VLOG(1) << "OnGetCookies: " << request->url().spec();
-
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
-    return;
+    return false;
 
   net::URLRequestContext* context = request->context();
-
   net::CookieMonster* cookie_monster =
       context->cookie_store()->GetCookieMonster();
   net::CookieList cookie_list =
       cookie_monster->GetAllCookiesForURL(request->url());
-  CallRenderViewHostContentSettingsDelegate(
-      render_process_id, render_view_id,
-      &RenderViewHostDelegate::ContentSettings::OnCookiesRead,
-      request->url(), cookie_list, blocked_by_policy);
+  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+
+  return content::GetContentClient()->browser()->AllowGetCookie(
+      request->url(), request->first_party_for_cookies(), cookie_list,
+      *info->context(), render_process_id, render_view_id);
 }
 
-void ResourceDispatcherHost::OnSetCookie(net::URLRequest* request,
-                                         const std::string& cookie_line,
-                                         const net::CookieOptions& options,
-                                         bool blocked_by_policy) {
+bool ResourceDispatcherHost::CanSetCookie(net::URLRequest* request,
+                                          const std::string& cookie_line,
+                                          net::CookieOptions* options) {
   VLOG(1) << "OnSetCookie: " << request->url().spec();
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
-    return;
+    return false;
 
-  CallRenderViewHostContentSettingsDelegate(
-      render_process_id, render_view_id,
-      &RenderViewHostDelegate::ContentSettings::OnCookieChanged,
-      request->url(), cookie_line, options, blocked_by_policy);
+  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  return content::GetContentClient()->browser()->AllowSetCookie(
+      request->url(), request->first_party_for_cookies(), cookie_line,
+      *info->context(), render_process_id, render_view_id, options);
 }
 
 void ResourceDispatcherHost::OnResponseStarted(net::URLRequest* request) {
   VLOG(1) << "OnResponseStarted: " << request->url().spec();
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (PauseRequestIfNeeded(info)) {
     VLOG(1) << "OnResponseStarted pausing: " << request->url().spec();
     return;
   }
 
@@ skipping 826 matching lines @@
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
   is_prefetch_enabled_ = value;
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled_ = false;