Factor out ResourceDispatcherHost dependent code around SSLManager

content/browser/renderer_host/resource_dispatcher_host.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/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 371 matching lines @@
     delegate_->DownloadStarting(request, context, child_id, route_id,
                                 request_id, !request->is_pending(), &throttles);
     if (!throttles.empty()) {
       handler = new ThrottlingResourceHandler(this, handler, child_id,
                                               request_id, throttles.Pass());
     }
   }
   return handler;
 }
 
+ResourceType::Type ResourceDispatcherHost::ResourceTypeForInstance(
+    const SSLErrorHandler::instance_id& id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::URLRequest* request = GetURLRequest(id);
+  DCHECK(request);
+  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  DCHECK(info);
+  return info->resource_type();
+}
+
+const GURL& ResourceDispatcherHost::URLForInstance(
+    const SSLErrorHandler::instance_id& id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::URLRequest* request = GetURLRequest(id);
+  DCHECK(request);
+  return request->url();
+}
+
+bool ResourceDispatcherHost::RenderViewForInstance(
+    const SSLErrorHandler::instance_id& id,
+    int* render_process_host_id,
+    int* render_view_host_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return RenderViewForRequest(
+      GetURLRequest(id), render_process_host_id, render_view_host_id);
+}
+
+void ResourceDispatcherHost::CancelRequestForInstance(
+    const SSLErrorHandler::instance_id& id,
+    int error,
+    const net::SSLInfo* ssl_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::URLRequest* request = GetURLRequest(id);
+  // The request can be NULL if it was cancelled by the renderer (as the
+  // request of the user navigating to a new page from the location bar).
+  if (!request)
+    return;
+  DVLOG(1) << "CancelRequestForInstance() url: " << request->url().spec();
+  if (ssl_info)
+    request->SimulateSSLError(error, *ssl_info);
+  else
+    request->SimulateError(error);
+}
+
+void ResourceDispatcherHost::ContinueRequestForInstance(
+    const SSLErrorHandler::instance_id&id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::URLRequest* request = GetURLRequest(id);
+  // The request can be NULL if it was cancelled by the renderer (as the
+  // request of the user navigating to a new page from the location bar).
+  if (!request)
+    return;
+  DVLOG(1) << "ContinueRequestForInstance() url: " << request->url().spec();
+  request->ContinueDespiteLastError();
+}
+
 void ResourceDispatcherHost::SetRequestInfo(
     net::URLRequest* request,
     ResourceDispatcherHostRequestInfo* info) {
   request->SetUserData(NULL, info);
 }
 
 void ResourceDispatcherHost::OnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   is_shutdown_ = true;
   resource_queue_.Shutdown();
@@ skipping 1020 matching lines @@
   info->set_ssl_client_auth_handler(
       new SSLClientAuthHandler(request, cert_request_info));
   info->ssl_client_auth_handler()->SelectCertificate();
 }
 
 void ResourceDispatcherHost::OnSSLCertificateError(
     net::URLRequest* request,
     const net::SSLInfo& ssl_info,
     bool is_hsts_host) {
   DCHECK(request);
-  SSLManager::OnSSLCertificateError(this, request, ssl_info, is_hsts_host);
+  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  SSLErrorHandler::instance_id instance;

[wtc, 2012/02/22 00:36:23]

Nit: 'error_handler_id' seems more clear than 'instance'.

[Takashi Toyoshima, 2012/02/22 08:15:35]

Now, 'request_id' looks better as instance of GlobalRequestID?

+  instance.first = info->child_id();
+  instance.second = info->request_id();
+  SSLManager::OnSSLCertificateError(this, instance, ssl_info, is_hsts_host);
 }
 
 bool ResourceDispatcherHost::CanGetCookies(
     const net::URLRequest* request,
     const net::CookieList& cookie_list) const {
   VLOG(1) << "OnGetCookies: " << request->url().spec();
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return false;
 
@@ skipping 532 matching lines @@
   // This should be running in the IO loop.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PendingRequestList::const_iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())
     return NULL;
 
   return i->second;
 }
 
+net::URLRequest* ResourceDispatcherHost::GetURLRequest(
+    const SSLErrorHandler::instance_id& id) const {
+  content::GlobalRequestID request_id;
+  request_id.child_id = id.first;
+  request_id.request_id = id.second;
+  return GetURLRequest(request_id);
+}
+
 static int GetCertID(net::URLRequest* request, int child_id) {
   if (request->ssl_info().cert) {
     return CertStore::GetInstance()->StoreCert(request->ssl_info().cert,
                                                child_id);
   }
   return 0;
 }
 
 void ResourceDispatcherHost::NotifyResponseStarted(net::URLRequest* request,
                                                    int child_id) {
@@ skipping 306 matching lines @@
   scoped_refptr<ResourceHandler> transferred_resource_handler(
       new DoomedResourceHandler(info->resource_handler()));
   info->set_resource_handler(transferred_resource_handler.get());
 }
 
 bool ResourceDispatcherHost::IsTransferredNavigation(
     const content::GlobalRequestID& transferred_request_id) const {
   return transferred_navigations_.find(transferred_request_id) !=
       transferred_navigations_.end();
 }