Track "display" and "run" separately for mixed content, and make the latter d...

chrome/browser/ssl/ssl_policy_backend.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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_policy_backend.h"
 
 #include "app/resource_bundle.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/ssl/ssl_host_state.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/tab_contents.h"
-#include "chrome/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 
 class SSLInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   SSLInfoBarDelegate(TabContents* contents,
                      const std::wstring message,
                      const std::wstring& button_label,
                      Task* task)
     : ConfirmInfoBarDelegate(contents),
@@ skipping 71 matching lines @@
   if (entry->ssl().security_style() <= SECURITY_STYLE_UNAUTHENTICATED)
     return;
 
   if (controller_->tab_contents()) {
     controller_->tab_contents()->AddInfoBar(
         new SSLInfoBarDelegate(controller_->tab_contents(), msg, link_text,
                                task));
   }
 }
 
-void SSLPolicyBackend::MarkHostAsBroken(const std::string& host, int id) {
-  ssl_host_state_->MarkHostAsBroken(host, id);
-  DispatchSSLInternalStateChanged();
+void SSLPolicyBackend::HostRanInsecureContent(const std::string& host,
+                                              int id) {
+  ssl_host_state_->HostRanInsecureContent(host, id);
+  SSLManager::NotifySSLInternalStateChanged();
 }
 
-bool SSLPolicyBackend::DidMarkHostAsBroken(const std::string& host,
-                                           int pid) const {
-  return ssl_host_state_->DidMarkHostAsBroken(host, pid);
+bool SSLPolicyBackend::DidHostRunInsecureContent(const std::string& host,
+                                                 int pid) const {
+  return ssl_host_state_->DidHostRunInsecureContent(host, pid);
 }
 
 void SSLPolicyBackend::DenyCertForHost(net::X509Certificate* cert,
                                        const std::string& host) {
   ssl_host_state_->DenyCertForHost(cert, host);
 }
 
 void SSLPolicyBackend::AllowCertForHost(net::X509Certificate* cert,
                                         const std::string& host) {
   ssl_host_state_->AllowCertForHost(cert, host);
 }
 
 net::X509Certificate::Policy::Judgment SSLPolicyBackend::QueryPolicy(
     net::X509Certificate* cert, const std::string& host) {
   return ssl_host_state_->QueryPolicy(cert, host);
 }
 
-void SSLPolicyBackend::DispatchSSLInternalStateChanged() {
-  NotificationService::current()->Notify(
-      NotificationType::SSL_INTERNAL_STATE_CHANGED,
-      Source<NavigationController>(controller_),
-      NotificationService::NoDetails());
-}
-
 void SSLPolicyBackend::ShowPendingMessages() {
   std::vector<SSLMessageInfo>::const_iterator iter;
   for (iter = pending_messages_.begin();
        iter != pending_messages_.end(); ++iter) {
     ShowMessageWithLink(iter->message, iter->link_text, iter->action);
   }
   ClearPendingMessages();
 }
 
 void SSLPolicyBackend::ClearPendingMessages() {
   pending_messages_.clear();
 }