Fix our handling of mixed SSL / non-SSL content....

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/browser/browser_process.h"
 #include "chrome/browser/load_from_memory_cache_details.h"
@@ skipping 103 matching lines @@
   registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(controller_));
   registrar_.Add(this, NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
                  Source<NavigationController>(controller_));
   registrar_.Add(this, NotificationType::RESOURCE_RESPONSE_STARTED,
                  Source<NavigationController>(controller_));
   registrar_.Add(this, NotificationType::RESOURCE_RECEIVED_REDIRECT,
                  Source<NavigationController>(controller_));
   registrar_.Add(this, NotificationType::LOAD_FROM_MEMORY_CACHE,
                  Source<NavigationController>(controller_));
+  registrar_.Add(this, NotificationType::SSL_INTERNAL_STATE_CHANGED,
+                 NotificationService::AllSources());
 }
 
 SSLManager::~SSLManager() {
 }
 
 // Delegate API method.
 void SSLManager::ShowMessage(const std::wstring& msg) {
   ShowMessageWithLink(msg, std::wstring(), NULL);
 }
 
@@ skipping 20 matching lines @@
     return;
 
   if (controller_->active_contents()) {
     controller_->active_contents()->AddInfoBar(
         new SSLInfoBarDelegate(controller_->active_contents(), msg, link_text,
                                task));
   }
 }
 
 // Delegate API method.
-bool SSLManager::SetMaxSecurityStyle(SecurityStyle style) {
-  NavigationEntry* entry = controller_->GetActiveEntry();
-  if (!entry) {
-    NOTREACHED();
-    return false;
-  }
-
-  if (entry->ssl().security_style() > style) {
-    entry->ssl().set_security_style(style);
-    return true;
-  }
-  return false;
-}
-
-// Delegate API method.
 void SSLManager::AddMessageToConsole(const std::wstring& msg,
                                      ConsoleMessageLevel level) {
   TabContents* tab_contents = controller_->GetTabContents(TAB_CONTENTS_WEB);
   if (!tab_contents)
     return;
   WebContents* web_contents = tab_contents->AsWebContents();
   if (!web_contents)
     return;
 
   web_contents->render_view_host()->AddMessageToConsole(
       std::wstring(), msg, level);
 }
 
 // Delegate API method.
+void SSLManager::MarkHostAsBroken(const std::string& host) {
+  ssl_host_state_->MarkHostAsBroken(host);
+  DispatchSSLInternalStateChanged();
+}
+
+// Delegate API method.
+bool SSLManager::DidMarkHostAsBroken(const std::string& host) const {
+  return ssl_host_state_->DidMarkHostAsBroken(host);
+}
+
+// Delegate API method.
 void SSLManager::DenyCertForHost(net::X509Certificate* cert,
                                  const std::string& host) {
   // Remember that we don't like this cert for this host.
   ssl_host_state_->DenyCertForHost(cert, host);
+  DispatchSSLInternalStateChanged();
 }
 
 // Delegate API method.
 void SSLManager::AllowCertForHost(net::X509Certificate* cert,
                                   const std::string& host) {
   ssl_host_state_->AllowCertForHost(cert, host);
+  DispatchSSLInternalStateChanged();
 }
 
 // Delegate API method.
 net::X509Certificate::Policy::Judgment SSLManager::QueryPolicy(
     net::X509Certificate* cert, const std::string& host) {
   return ssl_host_state_->QueryPolicy(cert, host);
 }
 
-bool SSLManager::CanShowInsecureContent(const GURL& url) {
-  return ssl_host_state_->CanShowInsecureContent(url);
+// Delegate API method.
+void SSLManager::AllowMixedContentForHost(const std::string& host) {
+  ssl_host_state_->AllowMixedContentForHost(host);
+  DispatchSSLInternalStateChanged();
 }
 
-void SSLManager::AllowShowInsecureContentForURL(const GURL& url) {
-  ssl_host_state_->AllowShowInsecureContentForURL(url);
+// Delegate API method.
+bool SSLManager::DidAllowMixedContentForHost(const std::string& host) const {
+  return ssl_host_state_->DidAllowMixedContentForHost(host);
 }
 
 bool SSLManager::ProcessedSSLErrorFromRequest() const {
   NavigationEntry* entry = controller_->GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return false;
   }
 
   return net::IsCertStatusError(entry->ssl().cert_status());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ErrorHandler
 
 SSLManager::ErrorHandler::ErrorHandler(ResourceDispatcherHost* rdh,
                                        URLRequest* request,
+                                       ResourceType::Type resource_type,
+                                       const std::string& frame_origin,
+                                       const std::string& main_frame_origin,
                                        MessageLoop* ui_loop)
     : ui_loop_(ui_loop),
       io_loop_(MessageLoop::current()),
       manager_(NULL),
       request_id_(0, 0),
       resource_dispatcher_host_(rdh),
       request_url_(request->url()),
+      resource_type_(resource_type),
+      frame_origin_(frame_origin),
+      main_frame_origin_(main_frame_origin),
       request_has_been_notified_(false) {
   DCHECK(MessageLoop::current() != ui_loop);
 
   ResourceDispatcherHost::ExtraRequestInfo* info =
       ResourceDispatcherHost::ExtraInfoForRequest(request);
   request_id_.process_id = info->process_id;
   request_id_.request_id = info->request_id;
 
   if (!tab_util::GetTabContentsID(request,
                                   &render_process_host_id_,
@@ skipping 170 matching lines @@
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // CertError
 
 SSLManager::CertError::CertError(
     ResourceDispatcherHost* rdh,
     URLRequest* request,
     ResourceType::Type resource_type,
+    const std::string& frame_origin,
+    const std::string& main_frame_origin,
     int cert_error,
     net::X509Certificate* cert,
     MessageLoop* ui_loop)
-    : ErrorHandler(rdh, request, ui_loop),
-      cert_error_(cert_error),
-      resource_type_(resource_type) {
+    : ErrorHandler(rdh, request, resource_type, frame_origin,
+                   main_frame_origin, ui_loop),
+      cert_error_(cert_error) {
   DCHECK(request == resource_dispatcher_host_->GetURLRequest(request_id_));
 
   // We cannot use the request->ssl_info(), it's not been initialized yet, so
   // we have to set the fields manually.
   ssl_info_.cert = cert;
   ssl_info_.SetCertError(cert_error);
 }
 
 // static
 void SSLManager::OnSSLCertificateError(ResourceDispatcherHost* rdh,
                                        URLRequest* request,
                                        int cert_error,
                                        net::X509Certificate* cert,
                                        MessageLoop* ui_loop) {
   DLOG(INFO) << "OnSSLCertificateError() cert_error: " << cert_error <<
                 " url: " << request->url().spec();
 
   ResourceDispatcherHost::ExtraRequestInfo* info =
       ResourceDispatcherHost::ExtraInfoForRequest(request);
   DCHECK(info);
 
   // A certificate error occurred.  Construct a CertError object and hand it
   // over to the UI thread for processing.
   ui_loop->PostTask(FROM_HERE,
-      NewRunnableMethod(new CertError(rdh, request, info->resource_type,
-                                      cert_error, cert, ui_loop),
+      NewRunnableMethod(new CertError(rdh,
+                                      request,
+                                      info->resource_type,
+                                      info->frame_origin,
+                                      info->main_frame_origin,
+                                      cert_error,
+                                      cert,
+                                      ui_loop),
                         &CertError::Dispatch));
 }
 
 // static
-void SSLManager::OnMixedContentRequest(ResourceDispatcherHost* rdh,
-                                       URLRequest* request,
-                                       MessageLoop* ui_loop) {
+bool SSLManager::ShouldDelayRequest(ResourceDispatcherHost* rdh,
+                                    URLRequest* request,
+                                    MessageLoop* ui_loop) {
+  ResourceDispatcherHost::ExtraRequestInfo* info =
+      ResourceDispatcherHost::ExtraInfoForRequest(request);
+  DCHECK(info);
+
+  // We cheat here and talk to the SSLPolicy on the IO channel because we need
+  // to respond synchronously to avoid delaying all network requests...
+  SSLPolicy::IsMixedContent(request->url(),

[jcampan, 2009/03/16 18:43:54]

Don't you want to return false if IsMixedContent returns false?

[abarth-chromium, 2009/03/16 21:34:21]

Yes.  :)

+                            info->resource_type,
+                            info->frame_origin);
+
+
   ui_loop->PostTask(FROM_HERE,
-      NewRunnableMethod(new MixedContentHandler(rdh, request, ui_loop),
+      NewRunnableMethod(new MixedContentHandler(rdh, request,
+                                                info->resource_type,
+                                                info->frame_origin,
+                                                info->main_frame_origin,
+                                                ui_loop),
                         &MixedContentHandler::Dispatch));
+  return true;
 }
 
 void SSLManager::OnCertError(CertError* error) {
-  // Ask our delegate to deal with the error.
-  NavigationEntry* entry = controller_->GetActiveEntry();
-  // We might not have a navigation entry in some cases (e.g. when a
-  // HTTPS page opens a popup with no URL and then populate it with
-  // document.write()). See bug http://crbug.com/3845.
-  if (!entry)
-    return;
-
-  delegate()->OnCertError(entry->url(), error);
+  delegate()->OnCertError(error);
 }
 
 void SSLManager::OnMixedContent(MixedContentHandler* mixed_content) {
-  // Ask our delegate to deal with the mixed content.
-  NavigationEntry* entry = controller_->GetActiveEntry();
-  // We might not have a navigation entry in some cases (e.g. when a
-  // HTTPS page opens a popup with no URL and then populate it with
-  // document.write()). See bug http://crbug.com/3845.
-  if (!entry)
-    return;
-
-  delegate()->OnMixedContent(controller_, entry->url(), mixed_content);
+  delegate()->OnMixedContent(mixed_content);
 }
 
 void SSLManager::Observe(NotificationType type,
                          const NotificationSource& source,
                          const NotificationDetails& details) {
-  // We should only be getting notifications from our controller.
-  DCHECK(source == Source<NavigationController>(controller_));
-
   // Dispatch by type.
   switch (type.value) {
     case NotificationType::NAV_ENTRY_COMMITTED:
       DidCommitProvisionalLoad(details);
       break;
     case NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR:
       DidFailProvisionalLoadWithError(
           Details<ProvisionalLoadDetails>(details).ptr());
       break;
     case NotificationType::RESOURCE_RESPONSE_STARTED:
       DidStartResourceResponse(Details<ResourceRequestDetails>(details).ptr());
       break;
     case NotificationType::RESOURCE_RECEIVED_REDIRECT:
       DidReceiveResourceRedirect(
           Details<ResourceRedirectDetails>(details).ptr());
       break;
     case NotificationType::LOAD_FROM_MEMORY_CACHE:
       DidLoadFromMemoryCache(
           Details<LoadFromMemoryCacheDetails>(details).ptr());
       break;
+    case NotificationType::SSL_INTERNAL_STATE_CHANGED:
+      DidChangeSSLInternalState();
+      break;
     default:
       NOTREACHED() << "The SSLManager received an unexpected notification.";
   }
 }
 
-void SSLManager::InitializeEntryIfNeeded(NavigationEntry* entry) {
+void SSLManager::DispatchSSLInternalStateChanged() {
+  NotificationService::current()->Notify(
+      NotificationType::SSL_INTERNAL_STATE_CHANGED,
+      Source<NavigationController>(controller_),
+      NotificationService::NoDetails());
+}
+
+void SSLManager::DispatchSSLVisibleStateChanged() {
+  NotificationService::current()->Notify(
+      NotificationType::SSL_VISIBLE_STATE_CHANGED,
+      Source<NavigationController>(controller_),
+      NotificationService::NoDetails());
+}
+
+void SSLManager::UpdateEntry(NavigationEntry* entry) {
   DCHECK(entry);
 
-  // If the security style of the entry is SECURITY_STYLE_UNKNOWN, then it is a
-  // fresh entry and should get the default style.
-  if (entry->ssl().security_style() == SECURITY_STYLE_UNKNOWN) {
-    entry->ssl().set_security_style(
-        delegate()->GetDefaultStyle(entry->url()));
-  }
+  NavigationEntry::SSLStatus original_status = entry->ssl();  // Copy!
+
+  delegate()->UpdateEntry(this, entry);
+
+  if (original_status.security_style() != entry->ssl().security_style() ||
+      original_status.has_mixed_content() != entry->ssl().has_mixed_content() ||
+      original_status.has_unsafe_content() != entry->ssl().has_unsafe_content())
+    DispatchSSLVisibleStateChanged();
 }
 
 void SSLManager::NavigationStateChanged() {
-  NavigationEntry* active_entry = controller_->GetActiveEntry();
-  if (!active_entry)
+  NavigationEntry* entry = controller_->GetActiveEntry();
+  if (!entry)
     return;  // Nothing showing yet.
 
   // This might be a new entry we've never seen before.
-  InitializeEntryIfNeeded(active_entry);
+  UpdateEntry(entry);
 }
 
 void SSLManager::DidLoadFromMemoryCache(LoadFromMemoryCacheDetails* details) {
   DCHECK(details);
 
-  // Simulate loading this resource through the usual path.
   // Note that we specify SUB_RESOURCE as the resource type as WebCore only
   // caches sub-resources.
-  delegate()->OnRequestStarted(this, details->url(),
-                               ResourceType::SUB_RESOURCE,
-                               details->ssl_cert_id(),
-                               details->ssl_cert_status());
+  scoped_refptr<RequestInfo> info = new RequestInfo(
+      this,
+      details->url(),
+      ResourceType::SUB_RESOURCE,
+      details->frame_origin(),
+      details->main_frame_origin(),
+      details->ssl_cert_id(),
+      details->ssl_cert_status());
+
+  // Simulate loading this resource through the usual path.
+  delegate()->OnRequestStarted(info.get());
+}
+
+void SSLManager::DidChangeSSLInternalState() {
+  NavigationEntry* entry = controller_->GetActiveEntry();
+  if (!entry)
+    return;  // Nothing showing yet.
+
+  // We might have to update the current entry if our SSL state changes.
+  UpdateEntry(entry);
 }
 
 void SSLManager::DidCommitProvisionalLoad(
     const NotificationDetails& in_details) {
   NavigationController::LoadCommittedDetails* details =
       Details<NavigationController::LoadCommittedDetails>(in_details).ptr();
 
   // Ignore in-page navigations, they should not change the security style or
   // the info-bars.
   if (details->is_in_page)
     return;
 
   // Decode the security details.
   int ssl_cert_id, ssl_cert_status, ssl_security_bits;
   DeserializeSecurityInfo(details->serialized_security_info,
                           &ssl_cert_id, &ssl_cert_status, &ssl_security_bits);
 
-  bool changed = false;
+  bool entry_changed = false;
   if (details->is_main_frame) {
     // Update the SSL states of the pending entry.
     NavigationEntry* entry = controller_->GetActiveEntry();
     if (entry) {
       // We may not have an entry if this is a navigation to an initial blank
       // page. Reset the SSL information and add the new data we have.
       entry->ssl() = NavigationEntry::SSLStatus();
-      InitializeEntryIfNeeded(entry);  // For security_style.
+      UpdateEntry(entry);  // For security_style.
       entry->ssl().set_cert_id(ssl_cert_id);
       entry->ssl().set_cert_status(ssl_cert_status);
       entry->ssl().set_security_bits(ssl_security_bits);
-      changed = true;
+      entry_changed = true;
     }
 
     ShowPendingMessages();
   }
 
   // An HTTPS response may not have a certificate for some reason.  When that
   // happens, use the unauthenticated (HTTP) rather than the authentication
   // broken security style so that we can detect this error condition.
   if (net::IsCertStatusError(ssl_cert_status) &&
       !details->is_content_filtered) {
-    changed |= SetMaxSecurityStyle(SECURITY_STYLE_AUTHENTICATION_BROKEN);
+    // TODO(abarth): This is wrong.  It's the SSLPolicy's job to set the max
+    //               security style.
+    //SetMaxSecurityStyle(SECURITY_STYLE_AUTHENTICATION_BROKEN);
     if (!details->is_main_frame &&
         !details->entry->ssl().has_unsafe_content()) {
       details->entry->ssl().set_has_unsafe_content();
-      changed = true;
+      entry_changed = true;
     }
   } else if (details->entry->url().SchemeIsSecure() && !ssl_cert_id) {
     if (details->is_main_frame) {
-      changed |= SetMaxSecurityStyle(SECURITY_STYLE_UNAUTHENTICATED);
+      // TODO(abarth): This is wrong.  It's the SSLPolicy's job to set the max
+      //               security style.
+      //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 &&
           !details->entry->ssl().has_mixed_content()) {
         details->entry->ssl().set_has_mixed_content();
-        changed = true;
+        entry_changed = true;
       }
     }
   }
 
-  if (changed) {
-    // Only send the notification when something actually changed.
-    NotificationService::current()->Notify(
-        NotificationType::SSL_STATE_CHANGED,
-        Source<NavigationController>(controller_),
-        NotificationService::NoDetails());
-  }
+  if (entry_changed)
+    DispatchSSLVisibleStateChanged();
 }
 
 void SSLManager::DidFailProvisionalLoadWithError(
     ProvisionalLoadDetails* details) {
   DCHECK(details);
 
   // Ignore in-page navigations.
   if (details->in_page_navigation())
     return;
 
   if (details->main_frame())
     ClearPendingMessages();
 }
 
 void SSLManager::DidStartResourceResponse(ResourceRequestDetails* details) {
   DCHECK(details);
 
+  scoped_refptr<RequestInfo> info = new RequestInfo(
+      this,
+      details->url(),
+      details->resource_type(),
+      details->frame_origin(),
+      details->main_frame_origin(),
+      details->ssl_cert_id(),
+      details->ssl_cert_status());
+
   // Notify our delegate that we started a resource request.  Ideally, the
   // delegate should have the ability to cancel the request, but we can't do
   // that yet.
-  delegate()->OnRequestStarted(this, details->url(),
-                               details->resource_type(),
-                               details->ssl_cert_id() ,
-                               details->ssl_cert_status());
+  delegate()->OnRequestStarted(info.get());
 }
 
 void SSLManager::DidReceiveResourceRedirect(ResourceRedirectDetails* details) {
   // TODO(jcampan): when we receive a redirect for a sub-resource, we may want
   // to clear any mixed/unsafe content error that it may have triggered.
+  // Really???  I'm not sure that's right.  -- abarth (3/14/2009)
 }
 
 void SSLManager::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();
 }
@@ skipping 56 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;
 }