Adding security info to canceled requests

chrome/browser/renderer_host/cross_site_resource_handler.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.
 
+#include <string>
+
 #include "chrome/browser/renderer_host/cross_site_resource_handler.h"
 
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tab_contents/web_contents.h"
 
 namespace {
 // Task to notify the WebContents that a cross-site response has begun, so that
 // WebContents can tell the old page to run its onunload handler.
 class CrossSiteNotifyTabTask : public Task {
@@ skipping 107 matching lines @@
 bool CrossSiteResourceHandler::OnReadCompleted(int request_id,
                                                int* bytes_read) {
   if (!in_cross_site_transition_) {
     return next_handler_->OnReadCompleted(request_id, bytes_read);
   }
   return true;
 }
 
 bool CrossSiteResourceHandler::OnResponseCompleted(
     int request_id,
-    const URLRequestStatus& status) {
+    const URLRequestStatus& status,
+    const std::string& security_info) {
   if (!in_cross_site_transition_) {
     if (has_started_response_) {
       // We've already completed the transition, so just pass it through.
-      return next_handler_->OnResponseCompleted(request_id, status);
+      return next_handler_->OnResponseCompleted(request_id, status,
+                                                security_info);
     } else {
       // Some types of failures will call OnResponseCompleted without calling
       // CrossSiteResourceHandler::OnResponseStarted.
       if (status.status() == URLRequestStatus::CANCELED) {
         // Here the request was canceled, which happens when selecting "take me
         // back" from an interstitial.  Nothing to do but cancel the pending
         // render view host.
         CancelPendingRenderViewTask* task =
             new CancelPendingRenderViewTask(render_process_host_id_,
                                             render_view_id_);
         rdh_->ui_loop()->PostTask(FROM_HERE, task);
-        return next_handler_->OnResponseCompleted(request_id, status);
+        return next_handler_->OnResponseCompleted(request_id, status,
+                                                  security_info);
       } else {
         // An error occured, we should wait now for the cross-site transition,
         // so that the error message (e.g., 404) can be displayed to the user.
         // Also continue with the logic below to remember that we completed
         // during the cross-site transition.
         ResourceDispatcherHost::GlobalRequestID global_id(
             render_process_host_id_, request_id);
         StartCrossSiteTransition(request_id, NULL, global_id);
       }
     }
   }
 
   // We have to buffer the call until after the transition completes.
   completed_during_transition_ = true;
   completed_status_ = status;
+  completed_security_info_ = security_info;
 
   // Return false to tell RDH not to notify the world or clean up the
   // pending request.  We will do so in ResumeResponse.
   return false;
 }
 
 // We can now send the response to the new renderer, which will cause
 // WebContents to swap in the new renderer and destroy the old one.
 void CrossSiteResourceHandler::ResumeResponse() {
   DCHECK(request_id_ != -1);
@@ skipping 20 matching lines @@
     // directed toward the new renderer.
     rdh_->PauseRequest(render_process_host_id_, request_id_, false);
   }
 
   // Remove ourselves from the ExtraRequestInfo.
   info->cross_site_handler = NULL;
 
   // If the response completed during the transition, notify the next
   // event handler.
   if (completed_during_transition_) {
-    next_handler_->OnResponseCompleted(request_id_, completed_status_);
+    next_handler_->OnResponseCompleted(request_id_, completed_status_,
+                                       completed_security_info_);
 
     // Since we didn't notify the world or clean up the pending request in
     // RDH::OnResponseCompleted during the transition, we should do it now.
     rdh_->NotifyResponseCompleted(request, render_process_host_id_);
     rdh_->RemovePendingRequest(render_process_host_id_, request_id_);
   }
 }
 
 // Prepare to render the cross-site response in a new RenderViewHost, by
 // telling the old RenderViewHost to run its onunload handler.
@@ skipping 27 matching lines @@
 
   // Tell the tab responsible for this request that a cross-site response is
   // starting, so that it can tell its old renderer to run its onunload
   // handler now.  We will wait to hear the corresponding ClosePage_ACK.
   CrossSiteNotifyTabTask* task =
       new CrossSiteNotifyTabTask(render_process_host_id_,
                                  render_view_id_,
                                  request_id);
   rdh_->ui_loop()->PostTask(FROM_HERE, task);
 }