Stop sending serialized SSLStatus to the renderer.

content/child/web_url_loader_impl.cc

 // Copyright 2014 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/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 164 matching lines @@
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(std::string()));
   int result = net::URLRequestDataJob::BuildResponse(
       url, &mime_type, &charset, data, headers.get());
   if (result != net::OK)
     return result;
 
   info->headers = headers;
   info->mime_type.swap(mime_type);
   info->charset.swap(charset);
-  info->security_info.clear();
   info->content_length = data->length();
   info->encoded_data_length = 0;
   info->encoded_body_length = 0;
 
   return net::OK;
 }
 
 // Convert a net::SignedCertificateTimestampAndStatus object to a
 // blink::WebURLResponse::SignedCertificateTimestamp object.
 blink::WebURLResponse::SignedCertificateTimestamp NetSCTToBlinkSCT(
@@ skipping 149 matching lines @@
   void OnUploadProgress(uint64_t position, uint64_t size);
   bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
                           const ResourceResponseInfo& info);
   void OnReceivedResponse(const ResourceResponseInfo& info);
   void OnDownloadedData(int len, int encoded_data_length);
   void OnReceivedData(std::unique_ptr<ReceivedData> data);
   void OnReceivedCachedMetadata(const char* data, int len);
   void OnCompletedRequest(int error_code,
                           bool was_ignored_by_handler,
                           bool stale_copy_in_cache,
-                          const std::string& security_info,
                           const base::TimeTicks& completion_time,
                           int64_t total_transfer_size);
 
  private:
   friend class base::RefCounted<Context>;
   ~Context();
 
   // Called when the body data stream is detached from the reader side.
   void CancelBodyStreaming();
   // We can optimize the handling of data URLs in most cases.
@@ skipping 27 matching lines @@
   void OnUploadProgress(uint64_t position, uint64_t size) override;
   bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
                           const ResourceResponseInfo& info) override;
   void OnReceivedResponse(const ResourceResponseInfo& info) override;
   void OnDownloadedData(int len, int encoded_data_length) override;
   void OnReceivedData(std::unique_ptr<ReceivedData> data) override;
   void OnReceivedCachedMetadata(const char* data, int len) override;
   void OnCompletedRequest(int error_code,
                           bool was_ignored_by_handler,
                           bool stale_copy_in_cache,
-                          const std::string& security_info,
                           const base::TimeTicks& completion_time,
                           int64_t total_transfer_size) override;
 
  private:
   scoped_refptr<Context> context_;
   DISALLOW_COPY_AND_ASSIGN(RequestPeerImpl);
 };
 
 // WebURLLoaderImpl::Context --------------------------------------------------
 
@@ skipping 357 matching lines @@
   TRACE_EVENT_WITH_FLOW0(
       "loading", "WebURLLoaderImpl::Context::OnReceivedCachedMetadata",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
   client_->didReceiveCachedMetadata(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
     int error_code,
     bool was_ignored_by_handler,
     bool stale_copy_in_cache,
-    const std::string& security_info,
     const base::TimeTicks& completion_time,
     int64_t total_transfer_size) {
   if (ftp_listing_delegate_) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   }
 
   if (body_stream_writer_ && error_code != net::OK)
     body_stream_writer_->Fail();
   body_stream_writer_.reset();
@@ skipping 100 matching lines @@
   int error_code = GetInfoFromDataURL(request_.url(), &info, &data);
 
   if (error_code == net::OK) {
     OnReceivedResponse(info);
     auto size = data.size();
     if (size != 0)
       OnReceivedData(
           base::MakeUnique<FixedReceivedData>(data.data(), size, 0, size));
   }
 
-  OnCompletedRequest(error_code, false, false, info.security_info,
-                     base::TimeTicks::Now(), 0);
+  OnCompletedRequest(error_code, false, false, base::TimeTicks::Now(), 0);
 }
 
 // WebURLLoaderImpl::RequestPeerImpl ------------------------------------------
 
 WebURLLoaderImpl::RequestPeerImpl::RequestPeerImpl(Context* context)
     : context_(context) {}
 
 void WebURLLoaderImpl::RequestPeerImpl::OnUploadProgress(uint64_t position,
                                                          uint64_t size) {
   context_->OnUploadProgress(position, size);
@@ skipping 24 matching lines @@
 void WebURLLoaderImpl::RequestPeerImpl::OnReceivedCachedMetadata(
     const char* data,
     int len) {
   context_->OnReceivedCachedMetadata(data, len);
 }
 
 void WebURLLoaderImpl::RequestPeerImpl::OnCompletedRequest(
     int error_code,
     bool was_ignored_by_handler,
     bool stale_copy_in_cache,
-    const std::string& security_info,
     const base::TimeTicks& completion_time,
     int64_t total_transfer_size) {
   context_->OnCompletedRequest(error_code, was_ignored_by_handler,
-                               stale_copy_in_cache, security_info,
-                               completion_time, total_transfer_size);
+                               stale_copy_in_cache, completion_time,
+                               total_transfer_size);
 }
 
 // WebURLLoaderImpl -----------------------------------------------------------
 
 WebURLLoaderImpl::WebURLLoaderImpl(ResourceDispatcher* resource_dispatcher,
                                    mojom::URLLoaderFactory* url_loader_factory)
     : context_(new Context(this, resource_dispatcher, url_loader_factory)) {}
 
 WebURLLoaderImpl::~WebURLLoaderImpl() {
   cancel();
 }
 
 void WebURLLoaderImpl::PopulateURLResponse(const GURL& url,
                                            const ResourceResponseInfo& info,
                                            WebURLResponse* response,
                                            bool report_security_info) {
   response->setURL(url);
   response->setResponseTime(info.response_time.ToInternalValue());
   response->setMIMEType(WebString::fromUTF8(info.mime_type));
   response->setTextEncodingName(WebString::fromUTF8(info.charset));
   response->setExpectedContentLength(info.content_length);
-  response->setSecurityInfo(info.security_info);
   response->setHasMajorCertificateErrors(info.has_major_certificate_errors);
   response->setAppCacheID(info.appcache_id);
   response->setAppCacheManifestURL(info.appcache_manifest_url);
   response->setWasCached(!info.load_timing.request_start_time.is_null() &&
       info.response_time < info.load_timing.request_start_time);
   response->setRemoteIPAddress(
       WebString::fromUTF8(info.socket_address.HostForURL()));
   response->setRemotePort(info.socket_address.port());
   response->setConnectionID(info.load_timing.socket_log_id);
   response->setConnectionReused(info.load_timing.socket_reused);
@@ skipping 252 matching lines @@
     response->clearHTTPHeaderField(webStringName);
     while (response_headers->EnumerateHeader(&iterator, name, &value)) {
       response->addHTTPHeaderField(webStringName,
                                    WebString::fromLatin1(value));
     }
   }
   return true;
 }
 
 }  // namespace content