Implement delaying resource requests until privacy blacklists are ready.

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2009 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 "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 11 matching lines @@
 #include "chrome/browser/download/download_request_manager.h"
 #include "chrome/browser/download/save_file_manager.h"
 #include "chrome/browser/extensions/user_script_listener.h"
 #include "chrome/browser/external_protocol_handler.h"
 #include "chrome/browser/in_process_webkit/webkit_thread.h"
 #include "chrome/browser/login_prompt.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/url_request_tracking.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
+#include "chrome/browser/privacy_blacklist/blacklist_listener.h"
+#include "chrome/browser/privacy_blacklist/blacklist_manager.h"
+#include "chrome/browser/privacy_blacklist/blacklist_request_info.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/async_resource_handler.h"
 #include "chrome/browser/renderer_host/buffered_resource_handler.h"
 #include "chrome/browser/renderer_host/cross_site_resource_handler.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
 #include "chrome/browser/renderer_host/global_request_id.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "chrome/browser/renderer_host/resource_queue.h"
@@ skipping 211 matching lines @@
       safe_browsing_(new SafeBrowsingService),
       socket_stream_dispatcher_host_(new SocketStreamDispatcherHost),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       receiver_(NULL) {
   ResourceQueue::DelegateSet resource_queue_delegates;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnablePrivacyBlacklists)) {
+    blacklist_listener_ = new BlacklistListener(&resource_queue_);
+    resource_queue_delegates.insert(blacklist_listener_.get());
+  }
   resource_queue_delegates.insert(user_script_listener_.get());
   resource_queue_.Initialize(resource_queue_delegates);
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
 
   // Clear blocked requests if any left.
   // Note that we have to do this in 2 passes as we cannot call
@@ skipping 144 matching lines @@
       // Tell the renderer that this request was disallowed.
       receiver_->Send(new ViewMsg_Resource_RequestComplete(
           route_id,
           request_id,
           status,
           std::string()));  // No security info needed, connection was not
                             // established.
     }
     return;
   }
-  std::string url = request_data.url.spec();
-
-  // Note that context can still be NULL here when running unit tests.
-  Blacklist::Match* match = context && context->GetBlacklist() ?
-      context->GetBlacklist()->findMatch(request_data.url) : NULL;
-  if (match && match->IsBlocked(request_data.url)) {
-    // This is a special path where calling happens without the URLRequest
-    // being created, so we must delete the match ourselves. Ensures this
-    // happens by using a scoped pointer.
-    scoped_ptr<Blacklist::Match> match_scope(match);
-
-    URLRequestStatus status(URLRequestStatus::SUCCESS, 0);
-    std::string data =
-        request_data.resource_type != ResourceType::SUB_RESOURCE ?
-        blocked_.GetHTML(url, match) : blocked_.GetImage(match);
-    std::string headers = blocked_.GetHeaders(url);
-
-    if (sync_result) {
-      SyncLoadResult result;
-      result.status = status;
-      result.final_url = request_data.url;
-      result.data.swap(data);
-      ViewHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
-      receiver_->Send(sync_result);
-    } else {
-      bool success = false;
-      base::SharedMemory shared;
-      if (shared.Create(std::wstring(), false, false, data.size())) {
-        if (shared.Map(data.size())) {
-          std::copy(data.c_str(), data.c_str() + data.size(),
-                    static_cast<std::string::value_type*>(shared.memory()));
-          base::SharedMemoryHandle handle;
-          if (shared.GiveToProcess(receiver_->handle(), &handle)) {
-            ResourceResponseHead header;
-            header.mime_type = "text/html";
-            header.content_length = -1;
-            header.status = status;
-            header.headers = new net::HttpResponseHeaders(headers);
-            receiver_->Send(new ViewMsg_Resource_ReceivedResponse(
-                route_id, request_id, header));
-            receiver_->Send(new ViewMsg_Resource_DataReceived(
-                route_id, request_id, handle, data.size()));
-            receiver_->Send(new ViewMsg_Resource_RequestComplete(
-                route_id, request_id, status, std::string()));
-            success = true;
-          }
-        }
-      }
-      if (!success) {
-        // Cannot send a substitution response, just cancel.
-        receiver_->Send(new ViewMsg_Resource_RequestComplete(
-            route_id,
-            request_id,
-            URLRequestStatus(URLRequestStatus::CANCELED, net::ERR_ABORTED),
-            std::string()));
-      }
-    }
-    return;
-  }
 
-  // To fetch a blocked resource, convert the unblock URL to the original one.
-  GURL gurl = request_data.url.scheme() != chrome::kUnblockScheme ?
-      request_data.url : GURL(blocked_.GetOriginalURL(url));
-
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
   // TODO(mpcomplete): This takes 200 ms!  Investigate parallelizing this by
   // starting the load earlier in a BG thread.
   PluginService::GetInstance()->LoadChromePlugins(this);
 
   // Construct the event handler.
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
-    handler = new SyncResourceHandler(receiver_, gurl, sync_result);
+    handler = new SyncResourceHandler(receiver_, request_data.url, sync_result);
   } else {
     handler = new AsyncResourceHandler(receiver_,
                                        child_id,
                                        route_id,
                                        receiver_->handle(),
-                                       gurl,
+                                       request_data.url,
                                        this);
   }
 
   if (HandleExternalProtocol(request_id, child_id, route_id,
-                             gurl, request_data.resource_type,
+                             request_data.url, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
-  URLRequest* request = new URLRequest(gurl, this);
-  if (match) {
-    request->SetUserData(&Blacklist::kRequestDataKey, match);
-  }
+  URLRequest* request = new URLRequest(request_data.url, this);
   request->set_method(request_data.method);
   request->set_first_party_for_cookies(request_data.first_party_for_cookies);
-
-  if (!match || !(match->attributes() & Blacklist::kDontSendReferrer))
-    request->set_referrer(request_data.referrer.spec());
-
+  request->set_referrer(request_data.referrer.spec());
   request->SetExtraRequestHeaders(request_data.headers);
 
   int load_flags = request_data.load_flags;
   // EV certificate verification could be expensive.  We don't want to spend
   // time performing EV certificate verification on all resources because
   // EV status is irrelevant to sub-frames and sub-resources.
   if (request_data.resource_type == ResourceType::MAIN_FRAME)
     load_flags |= net::LOAD_VERIFY_EV_CERT;
   request->set_load_flags(load_flags);
   request->set_context(context);
@@ skipping 21 matching lines @@
   uint64 upload_size = 0;
   if (request_data.upload_data) {
     request->set_upload(request_data.upload_data);
     upload_size = request_data.upload_data->GetContentLength();
   }
 
   // Install a CrossSiteResourceHandler if this request is coming from a
   // RenderViewHost with a pending cross-site request.  We only check this for
   // MAIN_FRAME requests. Unblock requests only come from a blocked page, do
   // not count as cross-site, otherwise it gets blocked indefinitely.
-  if (request_data.url.scheme() != chrome::kUnblockScheme &&
-      request_data.resource_type == ResourceType::MAIN_FRAME &&
+  if (request_data.resource_type == ResourceType::MAIN_FRAME &&
       process_type == ChildProcessInfo::RENDER_PROCESS &&
       Singleton<CrossSiteRequestManager>::get()->
           HasPendingCrossSiteRequest(child_id, route_id)) {
     // Wrap the event handler to be sure the current page's onunload handler
     // has a chance to run before we render the new page.
     handler = new CrossSiteResourceHandler(handler,
                                            child_id,
                                            route_id,
                                            this);
   }
 
   if (safe_browsing_->enabled() &&
-      safe_browsing_->CanCheckUrl(gurl)) {
+      safe_browsing_->CanCheckUrl(request_data.url)) {
     handler = new SafeBrowsingResourceHandler(handler,
                                               child_id,
                                               route_id,
-                                              gurl,
+                                              request_data.url,
                                               request_data.resource_type,
                                               safe_browsing_,
                                               this,
                                               receiver_);
   }
 
   // Insert a buffered event handler before the actual one.
   handler = new BufferedResourceHandler(handler, this, request);
 
   // Make extra info and read footer (contains request ID).
@@ skipping 14 matching lines @@
           request_data.host_render_view_id);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
   chrome_browser_net::SetOriginProcessUniqueIDForRequest(
       request_data.origin_child_id, request);
 
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
       request, context ? context->appcache_service() : NULL, child_id,
       request_data.appcache_host_id, request_data.resource_type);
 
+  // Associate Privacy Blacklist information with the request.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnablePrivacyBlacklists)) {
+    request->SetUserData(&BlacklistRequestInfo::kURLRequestDataKey,
+        new BlacklistRequestInfo(request_data.url, request_data.resource_type,
+            context ? context->GetBlacklistManager() : NULL));
+  }
+
   BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::OnDataReceivedACK(int request_id) {
   DataReceivedACK(receiver_->id(), request_id);
 }
 
 void ResourceDispatcherHost::DataReceivedACK(int child_id,
                                              int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
@@ skipping 509 matching lines @@
     OnResponseCompleted(request);
   }
 }
 
 bool ResourceDispatcherHost::CompleteResponseStarted(URLRequest* request) {
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   scoped_refptr<ResourceResponse> response = new ResourceResponse;
   PopulateResourceResponse(request, info->filter_policy(), response);
 
-  const URLRequest::UserData* d =
-      request->GetUserData(&Blacklist::kRequestDataKey);
-  if (d) {
-    const Blacklist::Match* match = static_cast<const Blacklist::Match*>(d);
-    if (match->attributes() & Blacklist::kBlockByType) {
+  BlacklistRequestInfo* request_info =
+      BlacklistRequestInfo::FromURLRequest(request);
+  if (request_info) {
+    const BlacklistManager* blacklist_manager =
+        request_info->GetBlacklistManager();
+    const Blacklist* blacklist = blacklist_manager->GetCompiledBlacklist();
+    scoped_ptr<Blacklist::Match> match(blacklist->findMatch(request->url()));
+    if (match.get() && match->attributes() & Blacklist::kBlockByType) {
       if (match->MatchType(response->response_head.mime_type))
         return false;  // TODO(idanan): Generate a replacement response.
     }
   }
 
   if (request->ssl_info().cert) {
     int cert_id =
         CertStore::GetSharedInstance()->StoreCert(request->ssl_info().cert,
                                                   info->child_id());
     response->response_head.security_info =
@@ skipping 657 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }