Privacy Blacklist Unblock...

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/blocked_response.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/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_request_details.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
@@ skipping 375 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->blacklist() ?
       context->blacklist()->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 ?
-        BlockedResponse::GetHTML(match) : BlockedResponse::GetImage(match);
+        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_FAILED),
             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_, request_data.url, sync_result);
+    handler = new SyncResourceHandler(receiver_, gurl, sync_result);
   } else {
     handler = new AsyncResourceHandler(receiver_,
                                        child_id,
                                        route_id,
                                        receiver_->handle(),
-                                       request_data.url,
+                                       gurl,
                                        this);
   }
 
   if (HandleExternalProtocol(request_id, child_id, route_id,
-                             request_data.url, request_data.resource_type,
+                             gurl, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
-  URLRequest* request = new URLRequest(request_data.url, this);
+  URLRequest* request = new URLRequest(gurl, this);
   if (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);
@@ skipping 21 matching lines @@
 
   // Set upload data.
   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.
-  if (request_data.resource_type == ResourceType::MAIN_FRAME &&
+  // 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 &&
       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(request_data.url)) {
+      safe_browsing_->CanCheckUrl(gurl)) {
     handler = new SafeBrowsingResourceHandler(handler,
                                               child_id,
                                               route_id,
-                                              request_data.url,
+                                              gurl,
                                               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 1185 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }