Return Error Status Upon Blocking Requests...

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2006-2008 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 346 matching lines @@
           std::string()));  // No security info needed, connection was not
                             // established.
     }
     return;
   }
 
   // Note that context can still be NULL here when running unit tests.
   Blacklist::Match* match = context && context->blacklist() ?
       context->blacklist()->findMatch(request_data.url) : NULL;
   if (match && match->IsBlocked(request_data.url)) {
-    // TODO(idanan): Send a ResourceResponse to replace the blocked resource.
+    // TODO(idanan): Send a ResourceResponse to replace the blocked resource
+    // instead of the FAILED return code below.
     delete match;
+    URLRequestStatus status(URLRequestStatus::FAILED, net::ERR_ABORTED);
+    if (sync_result) {
+      SyncLoadResult result;
+      result.status = status;
+      ViewHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
+      receiver_->Send(sync_result);
+    } else {
+      // Tell the renderer that this request was disallowed.
+      receiver_->Send(new ViewMsg_Resource_RequestComplete(
+          route_id,
+          request_id,
+          status,
+          std::string()));  // No connection, security info not needed.
+    }
     return;
   }
 
   // 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.
   plugin_service_->LoadChromePlugins(this);
 
   // Construct the event handler.
@@ skipping 11 matching lines @@
 
   if (HandleExternalProtocol(request_id, process_id, route_id,
                              request_data.url, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
   URLRequest* request = new URLRequest(request_data.url, this);
   if (match) {
-    request->SetUserData((void*)&Blacklist::kRequestDataKey, match);
+    request->SetUserData(&Blacklist::kRequestDataKey, match);
   }
   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->SetExtraRequestHeaders(request_data.headers);
 
   int load_flags = request_data.load_flags;
@@ skipping 593 matching lines @@
   response->response_head.status = request->status();
   response->response_head.request_time = request->request_time();
   response->response_head.response_time = request->response_time();
   response->response_head.headers = request->response_headers();
   request->GetCharset(&response->response_head.charset);
   response->response_head.filter_policy = info->filter_policy;
   response->response_head.content_length = request->GetExpectedContentSize();
   response->response_head.app_cache_id = WebAppCacheContext::kNoAppCacheId;
   request->GetMimeType(&response->response_head.mime_type);
 
+  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) {
+      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->process_id);
     response->response_head.security_info =
         SSLManager::SerializeSecurityInfo(cert_id,
                                           request->ssl_info().cert_status,
                                           request->ssl_info().security_bits);
   } else {
@@ skipping 596 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }