SSLPolicy fix: Step 9.

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 252 matching lines @@
   // RequestInfo wraps up the information SSLPolicy needs about a request in
   // order to update our security IU.  RequestInfo is RefCounted in case we need
   // to deal with the request asynchronously.
   class RequestInfo : public base::RefCounted<RequestInfo> {
    public:
     RequestInfo(SSLManager* manager,
                 const GURL& url,
                 ResourceType::Type resource_type,
                 const std::string& frame_origin,
                 const std::string& main_frame_origin,
+                FilterPolicy::Type filter_policy,
                 int ssl_cert_id,
                 int ssl_cert_status)
         : manager_(manager),
           url_(url),
           resource_type_(resource_type),
           frame_origin_(frame_origin),
           main_frame_origin_(main_frame_origin),
+          filter_policy_(filter_policy),
           ssl_cert_id_(ssl_cert_id),
           ssl_cert_status_(ssl_cert_status) {
     }
 
     SSLManager* manager() const { return manager_; }
     const GURL& url() const { return url_; }
     ResourceType::Type resource_type() const { return resource_type_; }
     const std::string& frame_origin() const { return frame_origin_; }
     const std::string& main_frame_origin() const { return main_frame_origin_; }
+    FilterPolicy::Type filter_policy() const { return filter_policy_; }
     int ssl_cert_id() const { return ssl_cert_id_; }
     int ssl_cert_status() const { return ssl_cert_status_; }
 
    private:
     SSLManager* manager_;
     GURL url_;
     ResourceType::Type resource_type_;
     std::string frame_origin_;
     std::string main_frame_origin_;
+    FilterPolicy::Type filter_policy_;
     int ssl_cert_id_;
     int ssl_cert_status_;
 
     DISALLOW_COPY_AND_ASSIGN(RequestInfo);
   };
 
   // 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
   // do it instead.
   class Delegate {
    public:
     // An error occurred with the certificate in an SSL connection.
     virtual void OnCertError(CertError* error) = 0;
 
     // A request for a mixed-content resource was made.  Note that the resource
     // request was not started yet and the delegate is responsible for starting
     // it.
     virtual void OnMixedContent(MixedContentHandler* handler) = 0;
 
     // We have started a resource request with the given info.
     virtual void OnRequestStarted(RequestInfo* info) = 0;
 
-    // Returns the default security style for a given URL.
-    virtual SecurityStyle GetDefaultStyle(const GURL& url) = 0;
+    // Update the SSL information in |entry| to match the current state.
+    virtual void UpdateEntry(SSLManager* manager, NavigationEntry* entry) = 0;
   };
 
   static void RegisterUserPrefs(PrefService* prefs);
 
   // Construct an SSLManager for the specified tab.
   // If |delegate| is NULL, SSLPolicy::GetDefaultPolicy() is used.
   SSLManager(NavigationController* controller, Delegate* delegate);
 
   ~SSLManager();
 
@@ skipping 96 matching lines @@
   void OnMixedContent(MixedContentHandler* handler);
 
   // Entry point for navigation.  This function begins the process of updating
   // the security UI when the main frame navigates to a new URL.
   //
   // Called on the UI thread.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
-  // Entry point for navigation.  This function begins the process of updating
-  // the security UI when the main frame navigates.
-  //
-  // Called on the UI thread.
-  void NavigationStateChanged();
-
   // Called to determine if there were any processed SSL errors from request.
   bool ProcessedSSLErrorFromRequest() const;
 
+  // The navigation controller associated with this SSLManager.  The
+  // NavigationController is guaranteed to outlive the SSLManager.
   NavigationController* controller() { return controller_; }
 
   // Convenience methods for serializing/deserializing the security info.
   static std::string SerializeSecurityInfo(int cert_id,
                                            int cert_status,
                                            int security_bits);
   static bool DeserializeSecurityInfo(const std::string& state,
                                       int* cert_id,
                                       int* cert_status,
                                       int* security_bits);
@@ skipping 40 matching lines @@
   void DidStartResourceResponse(ResourceRequestDetails* details);
   void DidReceiveResourceRedirect(ResourceRedirectDetails* details);
   void DidChangeSSLInternalState();
 
   // Dispatch NotificationType::SSL_INTERNAL_STATE_CHANGED notification.
   void DispatchSSLInternalStateChanged();
 
   // Dispatch NotificationType::SSL_VISIBLE_STATE_CHANGED notification.
   void DispatchSSLVisibleStateChanged();
 
-  // Convenience method for initializing navigation entries.
-  void InitializeEntryIfNeeded(NavigationEntry* entry);
+  // Update the NavigationEntry with our current state.
+  void UpdateEntry(NavigationEntry* entry);
 
   // Shows the pending messages (in info-bars) if any.
   void ShowPendingMessages();
 
   // Clears any pending messages.
   void ClearPendingMessages();
 
   // Our delegate.  The delegate is responsible for making policy decisions.
   // Must not be NULL.
   Delegate* delegate_;
 
   // The NavigationController that owns this SSLManager.  We are responsible
   // for the security UI of this tab.
   NavigationController* controller_;
 
   // Handles registering notifications with the NotificationService.
   NotificationRegistrar registrar_;
 
   // SSL state specific for each host.
   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_