Remember that we've white listed a certificate when we switch to a new tab....

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 "base/message_loop.h"
 #include "base/string_util.h"
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/load_notification_details.h"
 #include "chrome/browser/load_from_memory_cache_details.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/resource_request_details.h"
 #include "chrome/browser/ssl/ssl_error_info.h"
+#include "chrome/browser/ssl/ssl_host_state.h"
 #include "chrome/browser/ssl/ssl_policy.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/browser/tab_contents/web_contents.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/resource_bundle.h"
 #include "chrome/views/decision.h"
 #include "chrome/views/link.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_type.h"
 #include "generated_resources.h"
 
 class SSLInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
-   SSLInfoBarDelegate(TabContents* contents,
-                      const std::wstring message,
-                      const std::wstring& button_label,
-                      Task* task)
-      : ConfirmInfoBarDelegate(contents),
-        message_(message),
-        button_label_(button_label),
-        task_(task) {
+  SSLInfoBarDelegate(TabContents* contents,
+                     const std::wstring message,
+                     const std::wstring& button_label,
+                     Task* task)
+    : ConfirmInfoBarDelegate(contents),
+      message_(message),
+      button_label_(button_label),
+      task_(task) {
   }
   virtual ~SSLInfoBarDelegate() {}
 
   // Overridden from ConfirmInfoBarDelegate:
   virtual void InfoBarClosed() {
     delete this;
   }
   virtual std::wstring GetMessageText() const {
     return message_;
   }
@@ skipping 30 matching lines @@
 // SSLManager
 
 // static
 void SSLManager::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(prefs::kMixedContentFiltering,
                              FilterPolicy::DONT_FILTER);
 }
 
 SSLManager::SSLManager(NavigationController* controller, Delegate* delegate)
     : controller_(controller),
-      delegate_(delegate) {
+      delegate_(delegate),
+      ssl_host_state_(controller->profile()->GetSSLHostState()) {
   DCHECK(controller_);
 
   // If do delegate is supplied, use the default policy.
   if (!delegate_)
     delegate_ = SSLPolicy::GetDefaultPolicy();
 
   // Subscribe to various notifications.
   registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(controller_));
   registrar_.Add(this, NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
@@ skipping 69 matching lines @@
     return;
 
   web_contents->render_view_host()->AddMessageToConsole(
       std::wstring(), msg, level);
 }
 
 // Delegate API method.
 void SSLManager::DenyCertForHost(net::X509Certificate* cert,
                                  const std::string& host) {
   // Remember that we don't like this cert for this host.
-  // TODO(abarth): Do we want to persist this information in the user's profile?
-  cert_policy_for_host_[host].Deny(cert);
+  ssl_host_state_->DenyCertForHost(cert, host);
 }
 
 // Delegate API method.
 void SSLManager::AllowCertForHost(net::X509Certificate* cert,
                                   const std::string& host) {
-  // Remember that we do like this cert for this host.
-  // TODO(abarth): Do we want to persist this information in the user's profile?
-  cert_policy_for_host_[host].Allow(cert);
+  ssl_host_state_->AllowCertForHost(cert, host);
 }
 
 // Delegate API method.
 net::X509Certificate::Policy::Judgment SSLManager::QueryPolicy(
     net::X509Certificate* cert, const std::string& host) {
-  // TODO(abarth): Do we want to read this information from the user's profile?
-  return cert_policy_for_host_[host].Check(cert);
+  return ssl_host_state_->QueryPolicy(cert, host);
 }
 
 bool SSLManager::CanShowInsecureContent(const GURL& url) {
-  // TODO(jcampan): Do we want to read this information from the user's profile?
-  return (can_show_insecure_content_for_host_.find(url.host()) !=
-      can_show_insecure_content_for_host_.end());
+  return ssl_host_state_->CanShowInsecureContent(url);
 }
 
 void SSLManager::AllowShowInsecureContentForURL(const GURL& url) {
-  can_show_insecure_content_for_host_.insert(url.host());
+  ssl_host_state_->AllowShowInsecureContentForURL(url);
 }
 
 bool SSLManager::ProcessedSSLErrorFromRequest() const {
   NavigationEntry* entry = controller_->GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return false;
   }
 
   return net::IsCertStatusError(entry->ssl().cert_status());
@@ skipping 371 matching lines @@
       details->entry->ssl().set_has_unsafe_content();
       changed = true;
     }
   } else if (details->entry->url().SchemeIsSecure() && !ssl_cert_id) {
     if (details->is_main_frame) {
       changed |= SetMaxSecurityStyle(SECURITY_STYLE_UNAUTHENTICATED);
     } else {
       // If the frame has been blocked we keep our security style as
       // authenticated in that case as nothing insecure is actually showing or
       // loaded.
-      if (!details->is_content_filtered && 
+      if (!details->is_content_filtered &&
           !details->entry->ssl().has_mixed_content()) {
         details->entry->ssl().set_has_mixed_content();
         changed = true;
       }
     }
   }
 
   if (changed) {
     // Only send the notification when something actually changed.
     NotificationService::current()->Notify(
@@ skipping 100 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;
 }