Home | History | Annotate | Download | only in ssl 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/browser/ssl/ssl_error_handler.h"
      6 
      7 #include "base/bind.h"
      8 #include "content/browser/frame_host/navigation_controller_impl.h"
      9 #include "content/browser/frame_host/render_frame_host_impl.h"
     10 #include "content/browser/ssl/ssl_cert_error_handler.h"
     11 #include "content/browser/web_contents/web_contents_impl.h"
     12 #include "content/public/browser/browser_thread.h"
     13 #include "content/public/browser/resource_request_info.h"
     14 #include "net/base/net_errors.h"
     15 #include "net/url_request/url_request.h"
     16 
     17 using net::SSLInfo;
     18 
     19 namespace content {
     20 
     21 SSLErrorHandler::SSLErrorHandler(const base::WeakPtr<Delegate>& delegate,
     22                                  const GlobalRequestID& id,
     23                                  ResourceType resource_type,
     24                                  const GURL& url,
     25                                  int render_process_id,
     26                                  int render_frame_id)
     27     : manager_(NULL),
     28       request_id_(id),
     29       delegate_(delegate),
     30       render_process_id_(render_process_id),
     31       render_frame_id_(render_frame_id),
     32       request_url_(url),
     33       resource_type_(resource_type),
     34       request_has_been_notified_(false) {
     35   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
     36   DCHECK(delegate.get());
     37 
     38   // This makes sure we don't disappear on the IO thread until we've given an
     39   // answer to the net::URLRequest.
     40   //
     41   // Release in CompleteCancelRequest, CompleteContinueRequest, or
     42   // CompleteTakeNoAction.
     43   AddRef();
     44 }
     45 
     46 SSLErrorHandler::~SSLErrorHandler() {}
     47 
     48 void SSLErrorHandler::OnDispatchFailed() {
     49   TakeNoAction();
     50 }
     51 
     52 void SSLErrorHandler::OnDispatched() {
     53   TakeNoAction();
     54 }
     55 
     56 SSLCertErrorHandler* SSLErrorHandler::AsSSLCertErrorHandler() {
     57   return NULL;
     58 }
     59 
     60 void SSLErrorHandler::Dispatch() {
     61   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     62 
     63   WebContents* web_contents = NULL;
     64   RenderFrameHost* render_frame_host =
     65       RenderFrameHost::FromID(render_process_id_, render_frame_id_);
     66   web_contents = WebContents::FromRenderFrameHost(render_frame_host);
     67 
     68   if (!web_contents) {
     69     // We arrived on the UI thread, but the tab we're looking for is no longer
     70     // here.
     71     OnDispatchFailed();
     72     return;
     73   }
     74 
     75   // Hand ourselves off to the SSLManager.
     76   manager_ =
     77       static_cast<NavigationControllerImpl*>(&web_contents->GetController())->
     78           ssl_manager();
     79   OnDispatched();
     80 }
     81 
     82 void SSLErrorHandler::CancelRequest() {
     83   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     84 
     85   // We need to complete this task on the IO thread.
     86   BrowserThread::PostTask(
     87       BrowserThread::IO, FROM_HERE,
     88       base::Bind(
     89           &SSLErrorHandler::CompleteCancelRequest, this, net::ERR_ABORTED));
     90 }
     91 
     92 void SSLErrorHandler::DenyRequest() {
     93   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     94 
     95   // We need to complete this task on the IO thread.
     96   BrowserThread::PostTask(
     97       BrowserThread::IO, FROM_HERE,
     98       base::Bind(
     99           &SSLErrorHandler::CompleteCancelRequest, this,
    100           net::ERR_INSECURE_RESPONSE));
    101 }
    102 
    103 void SSLErrorHandler::ContinueRequest() {
    104   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    105 
    106   // We need to complete this task on the IO thread.
    107   BrowserThread::PostTask(
    108       BrowserThread::IO, FROM_HERE,
    109       base::Bind(&SSLErrorHandler::CompleteContinueRequest, this));
    110 }
    111 
    112 void SSLErrorHandler::TakeNoAction() {
    113   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    114 
    115   // We need to complete this task on the IO thread.
    116   BrowserThread::PostTask(
    117       BrowserThread::IO, FROM_HERE,
    118       base::Bind(&SSLErrorHandler::CompleteTakeNoAction, this));
    119 }
    120 
    121 void SSLErrorHandler::CompleteCancelRequest(int error) {
    122   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    123 
    124   // It is important that we notify the net::URLRequest only once.  If we try
    125   // to notify the request twice, it may no longer exist and |this| might have
    126   // already have been deleted.
    127   DCHECK(!request_has_been_notified_);
    128   if (request_has_been_notified_)
    129     return;
    130 
    131   SSLCertErrorHandler* cert_error = AsSSLCertErrorHandler();
    132   const SSLInfo* ssl_info = NULL;
    133   if (cert_error)
    134     ssl_info = &cert_error->ssl_info();
    135   if (delegate_.get())
    136     delegate_->CancelSSLRequest(request_id_, error, ssl_info);
    137   request_has_been_notified_ = true;
    138 
    139   // We're done with this object on the IO thread.
    140   Release();
    141 }
    142 
    143 void SSLErrorHandler::CompleteContinueRequest() {
    144   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    145 
    146   // It is important that we notify the net::URLRequest only once. If we try to
    147   // notify the request twice, it may no longer exist and |this| might have
    148   // already have been deleted.
    149   DCHECK(!request_has_been_notified_);
    150   if (request_has_been_notified_)
    151     return;
    152 
    153   if (delegate_.get())
    154     delegate_->ContinueSSLRequest(request_id_);
    155   request_has_been_notified_ = true;
    156 
    157   // We're done with this object on the IO thread.
    158   Release();
    159 }
    160 
    161 void SSLErrorHandler::CompleteTakeNoAction() {
    162   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    163 
    164   // It is important that we notify the net::URLRequest only once. If we try to
    165   // notify the request twice, it may no longer exist and |this| might have
    166   // already have been deleted.
    167   DCHECK(!request_has_been_notified_);
    168   if (request_has_been_notified_)
    169     return;
    170 
    171   request_has_been_notified_ = true;
    172 
    173   // We're done with this object on the IO thread.
    174   Release();
    175 }
    176 
    177 }  // namespace content
    178