Stop using CertStore which is not compatible with PlzNavigate.

content/browser/loader/resource_dispatcher_host_impl.cc

 // Copyright (c) 2012 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 "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 19 matching lines @@
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/time/time.h"
 #include "content/browser/appcache/appcache_interceptor.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
-#include "content/browser/cert_store_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/loader/async_resource_handler.h"
 #include "content/browser/loader/async_revalidation_manager.h"
 #include "content/browser/loader/cross_site_resource_handler.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/intercepting_resource_handler.h"
@@ skipping 237 matching lines @@
   }
   request->set_referrer_policy(net_referrer_policy);
 }
 
 void RemoveDownloadFileFromChildSecurityPolicy(int child_id,
                                                const base::FilePath& path) {
   ChildProcessSecurityPolicyImpl::GetInstance()->RevokeAllPermissionsForFile(
       child_id, path);
 }
 
-int GetCertID(CertStore* cert_store, net::URLRequest* request, int child_id) {
-  if (request->ssl_info().cert.get())
-    return cert_store->StoreCert(request->ssl_info().cert.get(), child_id);
-  return 0;
-}
-
 bool IsValidatedSCT(
     const net::SignedCertificateTimestampAndStatus& sct_status) {
   return sct_status.status == net::ct::SCT_STATUS_OK;
 }
 
 storage::BlobStorageContext* GetBlobStorageContext(
     ChromeBlobStorageContext* blob_storage_context) {
   if (!blob_storage_context)
     return NULL;
   return blob_storage_context->context();
@@ skipping 99 matching lines @@
     if (frame_host)
       routing_ids->insert(frame_host->GetGlobalFrameRoutingId());
     if (pending_frame_host)
       routing_ids->insert(pending_frame_host->GetGlobalFrameRoutingId());
   }
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&NotifyForRouteSetOnIO, frame_callback,
                                      base::Passed(std::move(routing_ids))));
 }
 
-void UpdateSSLStatus(int render_process_id,
-                     int render_frame_host_id,
-                     const GURL& url,
-                     CertStore* cert_store) {
-  RenderFrameHostImpl* render_frame_host =
-      RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
-  if (!render_frame_host)
-    return;
-
-  NavigationHandleImpl* navigation_handle =
-      render_frame_host->navigation_handle();
-  if (!navigation_handle || navigation_handle->GetURL() != url)
-    return;
-
-  scoped_refptr<net::X509Certificate> cert;
-  if (!cert_store->RetrieveCert(
-          navigation_handle->ssl_status().cert_id, &cert)) {
-    NOTREACHED() << "Must have set an SSL certificate already.";
-    return;
-  }
-
-  int new_cert_id = cert_store->StoreCert(cert.get(), render_process_id);
-  navigation_handle->UpdateSSLCertId(new_cert_id);
-}
-
 }  // namespace
 
 ResourceDispatcherHostImpl::HeaderInterceptorInfo::HeaderInterceptorInfo() {}
 
 ResourceDispatcherHostImpl::HeaderInterceptorInfo::~HeaderInterceptorInfo() {}
 
 ResourceDispatcherHostImpl::HeaderInterceptorInfo::HeaderInterceptorInfo(
     const HeaderInterceptorInfo& other) {}
 
 // static
 ResourceDispatcherHost* ResourceDispatcherHost::Get() {
   return g_resource_dispatcher_host;
 }
 
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl(
     CreateDownloadHandlerIntercept download_handler_intercept)
     : request_id_(-1),
       is_shutdown_(false),
       num_in_flight_requests_(0),
       max_num_in_flight_requests_(base::SharedMemory::GetHandleLimit()),
       max_num_in_flight_requests_per_process_(static_cast<int>(
           max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       filter_(nullptr),
       delegate_(nullptr),
       loader_delegate_(nullptr),
       allow_cross_origin_auth_prompt_(false),
-      cert_store_for_testing_(nullptr),
       create_download_handler_intercept_(download_handler_intercept) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
   BrowserThread::PostTask(BrowserThread::IO,
@@ skipping 321 matching lines @@
 
   // Don't notify WebContents observers for requests known to be
   // downloads; they aren't really associated with the Webcontents.
   // Note that not all downloads are known before content sniffing.
   if (info->IsDownload())
     return;
 
   // Notify the observers on the UI thread.
   std::unique_ptr<ResourceRedirectDetails> detail(new ResourceRedirectDetails(
       loader->request(),
-      GetCertID(GetCertStore(), loader->request(), info->GetChildID()),
+      !!request->ssl_info().cert,
       new_url));
   loader_delegate_->DidGetRedirectForResourceRequest(
       render_process_id, render_frame_host, std::move(detail));
 }
 
 void ResourceDispatcherHostImpl::DidReceiveResponse(ResourceLoader* loader) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
   net::URLRequest* request = loader->request();
   if (request->was_fetched_via_proxy() &&
       request->was_fetched_via_spdy() &&
@@ skipping 15 matching lines @@
     return;
 
   // Don't notify WebContents observers for requests known to be
   // downloads; they aren't really associated with the Webcontents.
   // Note that not all downloads are known before content sniffing.
   if (info->IsDownload())
     return;
 
   // Notify the observers on the UI thread.
   std::unique_ptr<ResourceRequestDetails> detail(new ResourceRequestDetails(
-      request, GetCertID(GetCertStore(), request, info->GetChildID())));
+      request, !!request->ssl_info().cert));
   loader_delegate_->DidGetResourceResponseStart(
       render_process_id, render_frame_host, std::move(detail));
 }
 
 void ResourceDispatcherHostImpl::DidFinishLoading(ResourceLoader* loader) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
 
   // Record final result of all resource loads.
   if (info->GetResourceType() == RESOURCE_TYPE_MAIN_FRAME) {
     // This enumeration has "3" appended to its name to distinguish it from
@@ skipping 285 matching lines @@
   ResourceLoader* loader_ptr = loader.get();
   pending_loaders_.erase(iter);
 
   // ResourceHandlers should always get state related to the request from the
   // ResourceRequestInfo rather than caching it locally.  This lets us update
   // the info object when a transfer occurs.
   info->UpdateForTransfer(child_id, route_id, request_data.render_frame_id,
                           request_data.origin_pid, request_id,
                           filter_->GetWeakPtr());
 
-  // If a certificate is stored with the ResourceResponse, it has to be
-  // updated to be associated with the new process.
-  if (loader->transferring_response()) {
-    UpdateResponseCertificateForTransfer(loader->transferring_response(),
-                                         loader->request(),
-                                         info);
-  }
-
   // Update maps that used the old IDs, if necessary.  Some transfers in tests
   // do not actually use a different ID, so not all maps need to be updated.
   pending_loaders_[new_request_id] = std::move(loader);
   IncrementOutstandingRequestsMemory(1, *info);
   if (should_update_count)
     IncrementOutstandingRequestsCount(1, info);
   if (old_routing_id != new_routing_id) {
     if (blocked_loaders_map_.find(old_routing_id) !=
             blocked_loaders_map_.end()) {
       blocked_loaders_map_[new_routing_id] =
@@ skipping 482 matching lines @@
   InterceptingResourceHandler* intercepting_handler =
       static_cast<InterceptingResourceHandler*>(handler.get());
 
   ScopedVector<ResourceThrottle> throttles;
 
   // Add a NavigationResourceThrottle for navigations.
   // PlzNavigate: the throttle is unnecessary as communication with the UI
   // thread is handled by the NavigationURLloader.
   if (!IsBrowserSideNavigationEnabled() && IsResourceTypeFrame(resource_type)) {
     throttles.push_back(new NavigationResourceThrottle(
-        request, delegate_, GetCertStore(), fetch_request_context_type));
+        request, delegate_, fetch_request_context_type));
   }
 
   if (delegate_) {
     delegate_->RequestBeginning(request,
                                 resource_context,
                                 appcache_service,
                                 resource_type,
                                 &throttles);
   }
 
@@ skipping 541 matching lines @@
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(),
         blob_context->GetBlobDataFromPublicURL(new_request->url()));
   }
 
   // TODO(davidben): Attach AppCacheInterceptor.
 
   std::unique_ptr<ResourceHandler> handler(
-      new NavigationResourceHandler(new_request.get(), loader, delegate(),
-                                    GetCertStore()));
+      new NavigationResourceHandler(new_request.get(), loader, delegate()));
 
   // TODO(davidben): Pass in the appropriate appcache_service. Also fix the
   // dependency on child_id/route_id. Those are used by the ResourceScheduler;
   // currently it's a no-op.
   handler =
       AddStandardHandlers(new_request.get(), resource_type, resource_context,
                           info.begin_params.request_context_type,
                           nullptr,  // appcache_service
                           -1,       // child_id
                           -1,       // route_id
@@ skipping 78 matching lines @@
     }
 
     IncrementOutstandingRequestsMemory(-1, *info);
 
     // A ResourceHandler must not outlive its associated URLRequest.
     handler.reset();
     return;
   }
 
   std::unique_ptr<ResourceLoader> loader(new ResourceLoader(
-      std::move(request), std::move(handler), GetCertStore(), this));
+      std::move(request), std::move(handler), this));
 
   GlobalFrameRoutingId id(info->GetChildID(), info->GetRenderFrameID());
   BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.find(id);
   if (iter != blocked_loaders_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(std::move(loader));
     return;
   }
 
   StartLoading(info, std::move(loader));
@@ skipping 284 matching lines @@
   } else if (request_data.resource_type == RESOURCE_TYPE_PREFETCH) {
     load_flags |= net::LOAD_PREFETCH;
   }
 
   if (is_sync_load)
     load_flags |= net::LOAD_IGNORE_LIMITS;
 
   return load_flags;
 }
 
-void ResourceDispatcherHostImpl::UpdateResponseCertificateForTransfer(
-    ResourceResponse* response,
-    net::URLRequest* request,
-    ResourceRequestInfoImpl* info) {
-  const net::SSLInfo& ssl_info = request->ssl_info();
-  if (info->GetResourceType() != RESOURCE_TYPE_MAIN_FRAME || !ssl_info.cert)
-    return;
-  int render_process_id, render_frame_id;
-  if (info->GetAssociatedRenderFrame(&render_process_id, &render_frame_id)) {
-    BrowserThread::PostTask(BrowserThread::UI,
-                            FROM_HERE,
-                            base::Bind(UpdateSSLStatus,
-                                       render_process_id,
-                                       render_frame_id,
-                                       request->url(),
-                                       GetCertStore()));
-  }
-}
-
-CertStore* ResourceDispatcherHostImpl::GetCertStore() {
-  return cert_store_for_testing_ ? cert_store_for_testing_
-                                 : CertStore::GetInstance();
-}
-
 bool ResourceDispatcherHostImpl::ShouldServiceRequest(
     int process_type,
     int child_id,
     const ResourceRequest& request_data,
     const net::HttpRequestHeaders& headers,
     ResourceMessageFilter* filter,
     ResourceContext* resource_context) {
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
@@ skipping 59 matching lines @@
         request_info->GetRouteID(), is_content_initiated, true, &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content