Stop sending serialized SSLStatus to the renderer.

content/browser/loader/detachable_resource_handler.cc

 // Copyright 2013 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 "content/browser/loader/detachable_resource_handler.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 29 matching lines @@
 
 void DetachableResourceHandler::Detach() {
   if (is_detached())
     return;
 
   if (!is_finished_) {
     // Simulate a cancel on the next handler before destroying it.
     net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                  net::ERR_ABORTED);
     bool defer_ignored = false;
-    next_handler_->OnResponseCompleted(status, std::string(), &defer_ignored);
+    next_handler_->OnResponseCompleted(status, &defer_ignored);
     DCHECK(!defer_ignored);
     // If |next_handler_| were to defer its shutdown in OnResponseCompleted,
     // this would destroy it anyway. Fortunately, AsyncResourceHandler never
     // does this anyway, so DCHECK it. MimeTypeResourceHandler and RVH shutdown
     // already ignore deferred ResourceHandler shutdown, but
     // DetachableResourceHandler and the detach-on-renderer-cancel logic
     // introduces a case where this occurs when the renderer cancels a resource.
   }
   // A OnWillRead / OnReadCompleted pair may still be in progress, but
   // OnWillRead passes back a scoped_refptr, so downstream handler's buffer will
@@ skipping 89 matching lines @@
     return true;
 
   bool ret =
       next_handler_->OnReadCompleted(bytes_read, &is_deferred_);
   *defer = is_deferred_;
   return ret;
 }
 
 void DetachableResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
-    const std::string& security_info,
     bool* defer) {
   // No DCHECK(!is_deferred_) as the request may have been cancelled while
   // deferred.
 
   if (!next_handler_)
     return;
 
   is_finished_ = true;
 
-  next_handler_->OnResponseCompleted(status, security_info, &is_deferred_);
+  next_handler_->OnResponseCompleted(status, &is_deferred_);
   *defer = is_deferred_;
 }
 
 void DetachableResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   if (!next_handler_)
     return;
 
   next_handler_->OnDataDownloaded(bytes_downloaded);
 }
 
 void DetachableResourceHandler::Resume() {
   DCHECK(is_deferred_);
   is_deferred_ = false;
   controller()->Resume();
 }
 
 void DetachableResourceHandler::Cancel() {
   controller()->Cancel();
 }
 
 void DetachableResourceHandler::CancelAndIgnore() {
   controller()->CancelAndIgnore();
 }
 
 void DetachableResourceHandler::CancelWithError(int error_code) {
   controller()->CancelWithError(error_code);
 }
 
 }  // namespace content