Adding security info to canceled requests

chrome/browser/ssl/ssl_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_SSL_SSL_MANAGER_H_
 #define CHROME_BROWSER_SSL_SSL_MANAGER_H_
 
 #include <string>
 #include <map>
 #include <vector>
@@ skipping 31 matching lines @@
 // listens for various events that influence when these elements should or
 // should not be displayed and adjusts them accordingly.
 //
 // There is one SSLManager per tab.
 // The security state (secure/insecure) is stored in the navigation entry.
 // Along with it are stored any SSL error code and the associated cert.
 //
 
 class SSLManager : public NotificationObserver {
  public:
+  class CertError;
+
   // An ErrorHandler carries information from the IO thread to the UI thread
   // and is dispatched to the appropriate SSLManager when it arrives on the
   // UI thread.  Subclasses should override the OnDispatched/OnDispatchFailed
   // methods to implement the actions that should be taken on the UI thread.
   // These methods can call the different convenience methods ContinueRequest/
   // CancelRequest/StartRequest to perform any required action on the URLRequest
   // the ErrorHandler was created with.
   // IMPORTANT NOTE: if you are not doing anything in
   // OnDispatched/OnDispatchFailed, make sure you call TakeNoAction().  This is
   // necessary for ensuring the instance is not leaked.
   class ErrorHandler : public base::RefCountedThreadSafe<ErrorHandler> {
    public:
     virtual ~ErrorHandler() { }
 
+    virtual CertError* AsCertError() { return NULL; }
+
     // Find the appropriate SSLManager for the URLRequest and begin handling
     // this error.
     //
     // Call on UI thread.
     void Dispatch();
 
     // Available on either thread.
     const GURL& request_url() const { return request_url_; }
 
     // Call on the UI thread.
@@ skipping 84 matching lines @@
     int render_process_host_id_;
     int tab_contents_id_;
 
     // This read-only member can be accessed on any thread.
     const GURL request_url_;  // The URL that we requested.
 
     // Should only be accessed on the IO thread
     bool request_has_been_notified_;  // A flag to make sure we notify the
                                       // URLRequest exactly once.
 
-    DISALLOW_EVIL_CONSTRUCTORS(ErrorHandler);
+    DISALLOW_COPY_AND_ASSIGN(ErrorHandler);
   };
 
   // A CertError represents an error that occurred with the certificate in an
   // SSL session.  A CertError object exists both on the IO thread and on the UI
   // thread and allows us to cancel/continue a request it is associated with.
   class CertError : public ErrorHandler {
    public:
+
+    virtual CertError* AsCertError() { return this; }
+
     // These accessors are available on either thread
     const net::SSLInfo& ssl_info() const { return ssl_info_; }
     int cert_error() const { return cert_error_; }
 
     ResourceType::Type resource_type() const { return resource_type_; }
    private:
     // SSLManager is responsible for creating CertError objects.
     friend class SSLManager;
 
     // Construct on the IO thread.
@@ skipping 11 matching lines @@
     virtual void OnDispatched() { manager_->OnCertError(this); }
 
     // These read-only members can be accessed on any thread.
     net::SSLInfo ssl_info_;
     const int cert_error_;  // The error we represent.
 
     // What kind of resource is associated with the requested that generated
     // that error.
     ResourceType::Type resource_type_;
 
-    DISALLOW_EVIL_CONSTRUCTORS(CertError);
+    DISALLOW_COPY_AND_ASSIGN(CertError);
   };
 
   // The MixedContentHandler class is used to query what to do with
   // mixed content, from the IO thread to the UI thread.
   class MixedContentHandler : public ErrorHandler {
    public:
     // Created on the IO thread.
     MixedContentHandler(ResourceDispatcherHost* rdh,
                         URLRequest* request,
                         MessageLoop* ui_loop)
         : ErrorHandler(rdh, request, ui_loop) { }
 
    protected:
     virtual void OnDispatchFailed() { TakeNoAction(); }
     virtual void OnDispatched() { manager()->OnMixedContent(this); }
 
    private:
-    DISALLOW_EVIL_CONSTRUCTORS(MixedContentHandler);
+    DISALLOW_COPY_AND_ASSIGN(MixedContentHandler);
   };
 
   // The SSLManager will ask its delegate to decide how to handle events
   // relevant to SSL.  Delegates are expected to be stateless and intended to be
   // easily implementable.
   //
   // Delegates should interact with the rest of the browser only through their
   // parameters and through the delegate API of the SSLManager.
   //
   // If a delegate needs to do something tricky, consider having the SSLManager
@@ skipping 216 matching lines @@
   SSLHostState* ssl_host_state_;
 
   // The list of messages that should be displayed (in info bars) when the page
   // currently loading had loaded.
   std::vector<SSLMessageInfo> pending_messages_;
 
   DISALLOW_COPY_AND_ASSIGN(SSLManager);
 };
 
 #endif  // CHROME_BROWSER_SSL_SSL_MANAGER_H_