Plumb the net::SSLInfo to the browser process when it's using the network service.

content/network/url_loader_impl.cc

 // Copyright 2017 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/network/url_loader_impl.h"
 
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "content/common/url_loader_factory.mojom.h"
 #include "content/network/net_adapters.h"
 #include "content/network/network_context.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/url_request/url_request_context.h"
 
@@ skipping 128 matching lines @@
 
   return base::MakeUnique<net::ElementsUploadDataStream>(
       std::move(element_readers), body->identifier());
 }
 
 }  // namespace
 
 URLLoaderImpl::URLLoaderImpl(
     NetworkContext* context,
     mojom::URLLoaderAssociatedRequest url_loader_request,
+    int32_t options,
     const ResourceRequest& request,
     mojom::URLLoaderClientPtr url_loader_client)
     : context_(context),
+      options_(options),
       connected_(true),
       binding_(this, std::move(url_loader_request)),
       url_loader_client_(std::move(url_loader_client)),
       writable_handle_watcher_(FROM_HERE,
                                mojo::SimpleWatcher::ArmingPolicy::MANUAL),
       peer_closed_handle_watcher_(FROM_HERE,
                                   mojo::SimpleWatcher::ArmingPolicy::MANUAL),
       weak_ptr_factory_(this) {
   binding_.set_connection_error_handler(
       base::Bind(&URLLoaderImpl::OnConnectionError, base::Unretained(this)));
@@ skipping 68 matching lines @@
 
 void URLLoaderImpl::OnResponseStarted(net::URLRequest* url_request) {
   DCHECK(url_request == url_request_.get());
 
   // TODO: Add support for optional MIME sniffing.
 
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   PopulateResourceResponse(url_request_.get(), response.get());
   response->head.encoded_data_length = url_request_->raw_header_size();
 
+  base::Optional<net::SSLInfo> ssl_info;
+  if (options_ & mojom::kURLLoadOptionSendSSLInfo)
+    ssl_info = url_request_->ssl_info();
   mojom::DownloadedTempFilePtr downloaded_file_ptr;
-  url_loader_client_->OnReceiveResponse(response->head,
+  url_loader_client_->OnReceiveResponse(response->head, ssl_info,
                                         std::move(downloaded_file_ptr));
 
   net::IOBufferWithSize* metadata = url_request->response_info().metadata.get();
   if (metadata) {
     const uint8_t* data = reinterpret_cast<const uint8_t*>(metadata->data());
 
     url_loader_client_->OnReceiveCachedMetadata(
         std::vector<uint8_t>(data, data + metadata->size()));
   }
 
@@ skipping 132 matching lines @@
   ReadMore();
 }
 
 void URLLoaderImpl::DeleteIfNeeded() {
   bool has_data_pipe = pending_write_.get() || response_body_stream_.is_valid();
   if (!connected_ && !has_data_pipe)
     delete this;
 }
 
 }  // namespace content