Adding security info to canceled 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 <vector>
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
@@ skipping 184 matching lines @@
                                                     ResourceHandler* handler) {
   if (!ResourceType::IsFrame(type) || URLRequest::IsHandledURL(url))
     return false;
 
   ui_loop_->PostTask(FROM_HERE, NewRunnableFunction(
       &ExternalProtocolHandler::LaunchUrl, url, render_process_host_id,
       tab_contents_id));
 
   handler->OnResponseCompleted(request_id, URLRequestStatus(
                                                URLRequestStatus::FAILED,
-                                               net::ERR_ABORTED));
+                                               net::ERR_ABORTED),
+                               std::string());  // No security info necessary.
   return true;
 }
 
 void ResourceDispatcherHost::BeginRequest(
     Receiver* receiver,
     base::ProcessHandle render_process_handle,
     int render_process_host_id,
     int render_view_id,
     int request_id,
     const ViewHostMsg_Resource_Request& request_data,
     URLRequestContext* request_context,
     IPC::Message* sync_result) {
   if (is_shutdown_ ||
       !ShouldServiceRequest(render_process_host_id, request_data)) {
     // Tell the renderer that this request was disallowed.
     receiver->Send(new ViewMsg_Resource_RequestComplete(
         render_view_id,
         request_id,
-        URLRequestStatus(URLRequestStatus::FAILED, net::ERR_ABORTED)));
+        URLRequestStatus(URLRequestStatus::FAILED, net::ERR_ABORTED),
+        std::string()));  // No security info needed, connection was not
+                          // established.
     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 674 matching lines @@
   info->memory_cost = CalculateApproximateMemoryCost(request);
   int memory_cost = IncrementOutstandingRequestsMemoryCost(
       info->memory_cost,
       info->render_process_host_id);
 
   // If enqueing/starting this request will exceed our per-process memory
   // bound, abort it right away.
   if (memory_cost > max_outstanding_requests_cost_per_process_) {
     // We call "CancelWithError()" as a way of setting the URLRequest's
     // status -- it has no effect beyond this, since the request hasn't started.
-    request->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
+    request->SimulateError(net::ERR_INSUFFICIENT_RESOURCES);
 
     // TODO(eroman): this is kinda funky -- we insert the unstarted request into
     // |pending_requests_| simply to please OnResponseCompleted().
     GlobalRequestID global_id(info->render_process_host_id, info->request_id);
     pending_requests_[global_id] = request;
     OnResponseCompleted(request);
     return;
   }
 
   std::pair<int, int> pair_id(info->render_process_host_id,
@@ skipping 181 matching lines @@
     return false;
   }
 
   return *bytes_read != 0;
 }
 
 void ResourceDispatcherHost::OnResponseCompleted(URLRequest* request) {
   RESOURCE_LOG("OnResponseCompleted: " << request->url().spec());
   ExtraRequestInfo* info = ExtraInfoForRequest(request);
 
+  std::string security_info;
+  const net::SSLInfo& ssl_info = request->ssl_info();
+  if (ssl_info.cert != NULL) {
+    int cert_id = CertStore::GetSharedInstance()->
+        StoreCert(ssl_info.cert, info->render_process_host_id);
+    security_info = SSLManager::SerializeSecurityInfo(cert_id,
+                                                      ssl_info.cert_status,
+                                                      ssl_info.security_bits);
+  }
+
   if (info->resource_handler->OnResponseCompleted(info->request_id,
-                                                  request->status())) {
+                                                  request->status(),
+                                                  security_info)) {
     NotifyResponseCompleted(request, info->render_process_host_id);
 
     // The request is complete so we can remove it.
     RemovePendingRequest(info->render_process_host_id, info->request_id);
   }
   // If the handler's OnResponseCompleted returns false, we are deferring the
   // call until later.  We will notify the world and clean up when we resume.
 }
 
 void ResourceDispatcherHost::AddObserver(Observer* obs) {
@@ skipping 289 matching lines @@
     IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost,
                                            info->render_process_host_id);
     if (cancel_requests)
       delete req_iter->url_request;
     else
       BeginRequestInternal(req_iter->url_request, req_iter->mixed_content);
   }
 
   delete requests;
 }