Refactor the inner classes from SSLManager to their own files to reduce the c...

chrome/browser/ssl/ssl_manager.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/ssl/ssl_manager.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/load_from_memory_cache_details.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/resource_request_details.h"
+#include "chrome/browser/ssl/ssl_cert_error_handler.h"
 #include "chrome/browser/ssl/ssl_error_info.h"
+#include "chrome/browser/ssl/ssl_error_handler.h"
 #include "chrome/browser/ssl/ssl_host_state.h"
+#include "chrome/browser/ssl/ssl_mixed_content_handler.h"
 #include "chrome/browser/ssl/ssl_policy.h"
+#include "chrome/browser/ssl/ssl_request_info.h"
 #include "chrome/browser/tab_contents/infobar_delegate.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/provisional_load_details.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/generated_resources.h"
@@ skipping 55 matching lines @@
   // Labels for the InfoBar's message and button.
   std::wstring message_;
   std::wstring button_label_;
 
   // A task to run when the InfoBar is accepted.
   scoped_ptr<Task> task_;
 
   DISALLOW_COPY_AND_ASSIGN(SSLInfoBarDelegate);
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// SSLManager
-
 // static
 void SSLManager::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(prefs::kMixedContentFiltering,
                              FilterPolicy::DONT_FILTER);
 }
 
 SSLManager::SSLManager(NavigationController* controller, Delegate* delegate)
     : delegate_(delegate),
       controller_(controller),
       ssl_host_state_(controller->profile()->GetSSLHostState()) {
@@ skipping 118 matching lines @@
 bool SSLManager::ProcessedSSLErrorFromRequest() const {
   NavigationEntry* entry = controller_->GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return false;
   }
 
   return net::IsCertStatusError(entry->ssl().cert_status());
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ErrorHandler
-
-SSLManager::ErrorHandler::ErrorHandler(ResourceDispatcherHost* rdh,
-                                       URLRequest* request,
-                                       ResourceType::Type resource_type,
-                                       const std::string& frame_origin,
-                                       const std::string& main_frame_origin,
-                                       MessageLoop* ui_loop)
-    : ui_loop_(ui_loop),
-      io_loop_(MessageLoop::current()),
-      manager_(NULL),
-      request_id_(0, 0),
-      resource_dispatcher_host_(rdh),
-      request_url_(request->url()),
-      resource_type_(resource_type),
-      frame_origin_(frame_origin),
-      main_frame_origin_(main_frame_origin),
-      request_has_been_notified_(false) {
-  DCHECK(MessageLoop::current() != ui_loop);
-
-  ResourceDispatcherHost::ExtraRequestInfo* info =
-      ResourceDispatcherHost::ExtraInfoForRequest(request);
-  request_id_.process_id = info->process_id;
-  request_id_.request_id = info->request_id;
-
-  if (!tab_util::GetTabContentsID(request,
-                                  &render_process_host_id_,
-                                  &tab_contents_id_))
-    NOTREACHED();
-
-  // This makes sure we don't disappear on the IO thread until we've given an
-  // answer to the URLRequest.
-  //
-  // Release in CompleteCancelRequest, CompleteContinueRequest,
-  // CompleteStartRequest or CompleteTakeNoAction.
-  AddRef();
-}
-
-void SSLManager::ErrorHandler::Dispatch() {
-  DCHECK(MessageLoop::current() == ui_loop_);
-
-  TabContents* tab_contents =
-      tab_util::GetTabContentsByID(render_process_host_id_, tab_contents_id_);
-
-  if (!tab_contents) {
-    // We arrived on the UI thread, but the tab we're looking for is no longer
-    // here.
-    OnDispatchFailed();
-    return;
-  }
-
-  // Hand ourselves off to the SSLManager.
-  manager_ = tab_contents->controller().ssl_manager();
-  OnDispatched();
-}
-
-TabContents* SSLManager::ErrorHandler::GetTabContents() {
-  return tab_util::GetTabContentsByID(render_process_host_id_,
-                                      tab_contents_id_);
-}
-
-void SSLManager::ErrorHandler::CancelRequest() {
-  DCHECK(MessageLoop::current() == ui_loop_);
-
-  // We need to complete this task on the IO thread.
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-       this, &SSLManager::ErrorHandler::CompleteCancelRequest,
-       net::ERR_ABORTED));
-}
-
-void SSLManager::ErrorHandler::DenyRequest() {
-  DCHECK(MessageLoop::current() == ui_loop_);
-
-  // We need to complete this task on the IO thread.
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SSLManager::ErrorHandler::CompleteCancelRequest,
-      net::ERR_INSECURE_RESPONSE));
-}
-
-void SSLManager::ErrorHandler::ContinueRequest() {
-  DCHECK(MessageLoop::current() == ui_loop_);
-
-  // We need to complete this task on the IO thread.
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SSLManager::ErrorHandler::CompleteContinueRequest));
-}
-
-void SSLManager::ErrorHandler::StartRequest(FilterPolicy::Type filter_policy) {
-  DCHECK(MessageLoop::current() == ui_loop_);
-
-  // We need to complete this task on the IO thread.
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SSLManager::ErrorHandler::CompleteStartRequest, filter_policy));
-}
-
-void SSLManager::ErrorHandler::TakeNoAction() {
-  DCHECK(MessageLoop::current() == ui_loop_);
-
-  // We need to complete this task on the IO thread.
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SSLManager::ErrorHandler::CompleteTakeNoAction));
-}
-
-void SSLManager::ErrorHandler::CompleteCancelRequest(int error) {
-  DCHECK(MessageLoop::current() == io_loop_);
-
-  // It is important that we notify the URLRequest only once.  If we try to
-  // notify the request twice, it may no longer exist and |this| might have
-  // already have been deleted.
-  DCHECK(!request_has_been_notified_);
-
-  if (!request_has_been_notified_) {
-    URLRequest* request = resource_dispatcher_host_->GetURLRequest(request_id_);
-    if (request) {
-      // The request can be NULL if it was cancelled by the renderer (as the
-      // result of the user navigating to a new page from the location bar).
-      DLOG(INFO) << "CompleteCancelRequest() url: " << request->url().spec();
-      SSLManager::CertError* cert_error = AsCertError();
-      if (cert_error)
-        request->SimulateSSLError(error, cert_error->ssl_info());
-      else
-        request->SimulateError(error);
-    }
-    request_has_been_notified_ = true;
-
-    // We're done with this object on the IO thread.
-    Release();
-  }
-}
-
-void SSLManager::ErrorHandler::CompleteContinueRequest() {
-  DCHECK(MessageLoop::current() == io_loop_);
-
-  // It is important that we notify the URLRequest only once.  If we try to
-  // notify the request twice, it may no longer exist and |this| might have
-  // already have been deleted.
-  DCHECK(!request_has_been_notified_);
-
-  if (!request_has_been_notified_) {
-    URLRequest* request = resource_dispatcher_host_->GetURLRequest(request_id_);
-    if (request) {
-      // The request can be NULL if it was cancelled by the renderer (as the
-      // result of the user navigating to a new page from the location bar).
-      DLOG(INFO) << "CompleteContinueRequest() url: " << request->url().spec();
-      request->ContinueDespiteLastError();
-    }
-    request_has_been_notified_ = true;
-
-    // We're done with this object on the IO thread.
-    Release();
-  }
-}
-
-void SSLManager::ErrorHandler::CompleteStartRequest(
-    FilterPolicy::Type filter_policy) {
-  DCHECK(MessageLoop::current() == io_loop_);
-
-  // It is important that we notify the URLRequest only once.  If we try to
-  // notify the request twice, it may no longer exist and |this| might have
-  // already have been deleted.
-  DCHECK(!request_has_been_notified_);
-
-  if (request_has_been_notified_)
-    return;
-
-  URLRequest* request = resource_dispatcher_host_->GetURLRequest(request_id_);
-  if (request) {
-    // The request can be NULL if it was cancelled by the renderer (as the
-    // result of the user navigating to a new page from the location bar).
-    DLOG(INFO) << "CompleteStartRequest() url: " << request->url().spec();
-    // The request should not have been started (SUCCESS is the initial state).
-    DCHECK(request->status().status() == URLRequestStatus::SUCCESS);
-    ResourceDispatcherHost::ExtraRequestInfo* info =
-        ResourceDispatcherHost::ExtraInfoForRequest(request);
-    info->filter_policy = filter_policy;
-    request->Start();
-  }
-  request_has_been_notified_ = true;
-
-  // We're done with this object on the IO thread.
-  Release();
-}
-
-void SSLManager::ErrorHandler::CompleteTakeNoAction() {
-  DCHECK(MessageLoop::current() == io_loop_);
-
-  // It is important that we notify the URLRequest only once.  If we try to
-  // notify the request twice, it may no longer exist and |this| might have
-  // already have been deleted.
-  DCHECK(!request_has_been_notified_);
-
-  if (!request_has_been_notified_) {
-    request_has_been_notified_ = true;
-
-    // We're done with this object on the IO thread.
-    Release();
-  }
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// CertError
-
-SSLManager::CertError::CertError(
-    ResourceDispatcherHost* rdh,
-    URLRequest* request,
-    ResourceType::Type resource_type,
-    const std::string& frame_origin,
-    const std::string& main_frame_origin,
-    int cert_error,
-    net::X509Certificate* cert,
-    MessageLoop* ui_loop)
-    : ErrorHandler(rdh, request, resource_type, frame_origin,
-                   main_frame_origin, ui_loop),
-      cert_error_(cert_error) {
-  DCHECK(request == resource_dispatcher_host_->GetURLRequest(request_id_));
-
-  // We cannot use the request->ssl_info(), it's not been initialized yet, so
-  // we have to set the fields manually.
-  ssl_info_.cert = cert;
-  ssl_info_.SetCertError(cert_error);
-}
-
 // static
 void SSLManager::OnSSLCertificateError(ResourceDispatcherHost* rdh,
                                        URLRequest* request,
                                        int cert_error,
                                        net::X509Certificate* cert,
                                        MessageLoop* ui_loop) {
   DLOG(INFO) << "OnSSLCertificateError() cert_error: " << cert_error <<
                 " url: " << request->url().spec();
 
   ResourceDispatcherHost::ExtraRequestInfo* info =
       ResourceDispatcherHost::ExtraInfoForRequest(request);
   DCHECK(info);
 
-  // A certificate error occurred.  Construct a CertError object and hand it
-  // over to the UI thread for processing.
+  // A certificate error occurred.  Construct a SSLCertErrorHandler object and
+  // hand it over to the UI thread for processing.
   ui_loop->PostTask(FROM_HERE,
-      NewRunnableMethod(new CertError(rdh,
-                                      request,
-                                      info->resource_type,
-                                      info->frame_origin,
-                                      info->main_frame_origin,
-                                      cert_error,
-                                      cert,
-                                      ui_loop),
-                        &CertError::Dispatch));
+      NewRunnableMethod(new SSLCertErrorHandler(rdh,
+                                                request,
+                                                info->resource_type,
+                                                info->frame_origin,
+                                                info->main_frame_origin,
+                                                cert_error,
+                                                cert,
+                                                ui_loop),
+                        &SSLCertErrorHandler::Dispatch));
 }
 
 // static
 bool SSLManager::ShouldStartRequest(ResourceDispatcherHost* rdh,
                                     URLRequest* request,
                                     MessageLoop* ui_loop) {
   ResourceDispatcherHost::ExtraRequestInfo* info =
       ResourceDispatcherHost::ExtraInfoForRequest(request);
   DCHECK(info);
 
   // We cheat here and talk to the SSLPolicy on the IO thread because we need
   // to respond synchronously to avoid delaying all network requests...
   if (!SSLPolicy::IsMixedContent(request->url(),
                                  info->resource_type,
                                  info->filter_policy,
                                  info->frame_origin))
     return true;
 
 
   ui_loop->PostTask(FROM_HERE,
-      NewRunnableMethod(new MixedContentHandler(rdh, request,
-                                                info->resource_type,
-                                                info->frame_origin,
-                                                info->main_frame_origin,
-                                                info->process_id,
-                                                ui_loop),
-                        &MixedContentHandler::Dispatch));
+      NewRunnableMethod(new SSLMixedContentHandler(rdh,
+                                                   request,
+                                                   info->resource_type,
+                                                   info->frame_origin,
+                                                   info->main_frame_origin,
+                                                   info->process_id,
+                                                   ui_loop),
+                        &SSLMixedContentHandler::Dispatch));
   return false;
 }
 
-void SSLManager::OnCertError(CertError* error) {
-  delegate()->OnCertError(error);
+void SSLManager::OnCertError(SSLCertErrorHandler* handler) {
+  delegate()->OnCertError(handler);
 }
 
-void SSLManager::OnMixedContent(MixedContentHandler* handler) {
+void SSLManager::OnMixedContent(SSLMixedContentHandler* handler) {
   delegate()->OnMixedContent(handler);
 }
 
 void SSLManager::Observe(NotificationType type,
                          const NotificationSource& source,
                          const NotificationDetails& details) {
   // Dispatch by type.
   switch (type.value) {
     case NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR:
       DidFailProvisionalLoadWithError(
@@ skipping 47 matching lines @@
 }
 
 void SSLManager::DidLoadFromMemoryCache(LoadFromMemoryCacheDetails* details) {
   DCHECK(details);
 
   // Simulate loading this resource through the usual path.
   // Note that we specify SUB_RESOURCE as the resource type as WebCore only
   // caches sub-resources.
   // This resource must have been loaded with FilterPolicy::DONT_FILTER because
   // filtered resouces aren't cachable.
-  scoped_refptr<RequestInfo> info = new RequestInfo(
+  scoped_refptr<SSLRequestInfo> info = new SSLRequestInfo(
       this,
       details->url(),
       ResourceType::SUB_RESOURCE,
       details->frame_origin(),
       details->main_frame_origin(),
       FilterPolicy::DONT_FILTER,
       details->pid(),
       details->ssl_cert_id(),
       details->ssl_cert_status());
 
@@ skipping 43 matching lines @@
   if (details->in_page_navigation())
     return;
 
   if (details->main_frame())
     ClearPendingMessages();
 }
 
 void SSLManager::DidStartResourceResponse(ResourceRequestDetails* details) {
   DCHECK(details);
 
-  scoped_refptr<RequestInfo> info = new RequestInfo(
+  scoped_refptr<SSLRequestInfo> info = new SSLRequestInfo(
       this,
       details->url(),
       details->resource_type(),
       details->frame_origin(),
       details->main_frame_origin(),
       details->filter_policy(),
       details->origin_pid(),
       details->ssl_cert_id(),
       details->ssl_cert_status());
 
@@ skipping 81 matching lines @@
   }
 
   if (ca_name) {
     // TODO(wtc): should we show the root CA's name instead?
     *ca_name = l10n_util::GetStringF(
         IDS_SECURE_CONNECTION_EV_CA,
         UTF8ToWide(cert.issuer().organization_names[0]));
   }
   return true;
 }