content: convert SSL notifications to observer usage

content/browser/ssl/ssl_manager.cc

 // Copyright (c) 2012 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 "content/browser/ssl/ssl_manager.h"
 
 #include "base/bind.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
@@ skipping 42 matching lines @@
                  new SSLCertErrorHandler(delegate,
                                          id,
                                          resource_type,
                                          url,
                                          render_process_id,
                                          render_view_id,
                                          ssl_info,
                                          fatal)));
 }
 
-// static
-void SSLManager::NotifySSLInternalStateChanged(
-    NavigationControllerImpl* controller) {
-  NotificationService::current()->Notify(
-      NOTIFICATION_SSL_INTERNAL_STATE_CHANGED,
-      Source<BrowserContext>(controller->GetBrowserContext()),
-      NotificationService::NoDetails());
-}
-
 SSLManager::SSLManager(NavigationControllerImpl* controller)
     : backend_(controller),
       policy_(new SSLPolicy(&backend_)),
       controller_(controller) {
   DCHECK(controller_);
 
   // Subscribe to various notifications.
   registrar_.Add(
       this, NOTIFICATION_RESOURCE_RESPONSE_STARTED,
       Source<WebContents>(controller_->web_contents()));
   registrar_.Add(
       this, NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
       Source<WebContents>(controller_->web_contents()));
   registrar_.Add(
       this, NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
       Source<NavigationController>(controller_));
-  registrar_.Add(
-      this, NOTIFICATION_SSL_INTERNAL_STATE_CHANGED,
-      Source<BrowserContext>(
-          controller_->GetBrowserContext()));
 }
 
 SSLManager::~SSLManager() {
 }
 
 void SSLManager::DidCommitProvisionalLoad(
     const NotificationDetails& in_details) {
   LoadCommittedDetails* details =
       Details<LoadCommittedDetails>(in_details).ptr();
 
@@ skipping 19 matching lines @@
       entry->GetSSL().cert_id = ssl_cert_id;
       entry->GetSSL().cert_status = ssl_cert_status;
       entry->GetSSL().security_bits = ssl_security_bits;
       entry->GetSSL().connection_status = ssl_connection_status;
     }
   }
 
   UpdateEntry(entry);
 }
 
+void SSLManager::DidDisplayInsecureContent() {
+  UpdateEntry(
+      NavigationEntryImpl::FromNavigationEntry(controller_->GetActiveEntry()));
+}
+
 void SSLManager::DidRunInsecureContent(const std::string& security_origin) {
-  policy()->DidRunInsecureContent(
-      NavigationEntryImpl::FromNavigationEntry(controller_->GetActiveEntry()),
-      security_origin);
+  NavigationEntryImpl* navigation_entry =
+      NavigationEntryImpl::FromNavigationEntry(controller_->GetActiveEntry());
+  policy()->DidRunInsecureContent(navigation_entry, security_origin);
+  UpdateEntry(navigation_entry);
+}
+
+void SSLManager::DidChangeInternalSSLState() {
+  UpdateEntry(

[Paweł Hajdan Jr., 2013/01/24 18:53:43]

Question: I'd need to broadcast the notification to all other SSLManagers in the
same BrowserContext (this is needed to get
SSLUITest.TestRunsInsecureContentTwoTabs test to pass).

Do you have any suggestions how to do that?

[jam, 2013/01/30 01:17:51]

there isn't a way to do this now. one suggestion:

BrowserContext derives from SupportsUserData. Perhaps internally in content we
add an object to it that can hold a list of callbacks, and that object can
handle addition/removal of callbacks. it can also have a method that SSLManagers
can call to notify the other callbackst hat internal state change.

all this code can even be inside ssl_manager.cc, since no other class should
know/care about this.

+      NavigationEntryImpl::FromNavigationEntry(controller_->GetActiveEntry()));
 }
 
 void SSLManager::Observe(int type,
                          const NotificationSource& source,
                          const NotificationDetails& details) {
   // Dispatch by type.
   switch (type) {
     case NOTIFICATION_RESOURCE_RESPONSE_STARTED:
       DidStartResourceResponse(
           Details<ResourceRequestDetails>(details).ptr());
       break;
     case NOTIFICATION_RESOURCE_RECEIVED_REDIRECT:
       DidReceiveResourceRedirect(
           Details<ResourceRedirectDetails>(details).ptr());
       break;
     case NOTIFICATION_LOAD_FROM_MEMORY_CACHE:
       DidLoadFromMemoryCache(
           Details<LoadFromMemoryCacheDetails>(details).ptr());
       break;
-    case NOTIFICATION_SSL_INTERNAL_STATE_CHANGED:
-      DidChangeSSLInternalState();
-      break;
     default:
       NOTREACHED() << "The SSLManager received an unexpected notification.";
   }
 }
 
 void SSLManager::DidLoadFromMemoryCache(LoadFromMemoryCacheDetails* 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.
   // This resource must have been loaded with no filtering because filtered
@@ skipping 24 matching lines @@
 }
 
 void SSLManager::DidReceiveResourceRedirect(ResourceRedirectDetails* details) {
   // TODO(abarth): Make sure our redirect behavior is correct.  If we ever see a
   //               non-HTTPS resource in the redirect chain, we want to trigger
   //               insecure content, even if the redirect chain goes back to
   //               HTTPS.  This is because the network attacker can redirect the
   //               HTTP request to https://attacker.com/payload.js.
 }
 
-void SSLManager::DidChangeSSLInternalState() {
-  UpdateEntry(
-      NavigationEntryImpl::FromNavigationEntry(controller_->GetActiveEntry()));
-}
-
 void SSLManager::UpdateEntry(NavigationEntryImpl* entry) {
   // We don't always have a navigation entry to update, for example in the
   // case of the Web Inspector.
   if (!entry)
     return;
 
   SSLStatus original_ssl_status = entry->GetSSL();  // Copy!
 
   policy()->UpdateEntry(entry, controller_->web_contents());
 
-  if (!entry->GetSSL().Equals(original_ssl_status)) {
-    NotificationService::current()->Notify(
-        NOTIFICATION_SSL_VISIBLE_STATE_CHANGED,
-        Source<NavigationController>(controller_),
-        NotificationService::NoDetails());
-  }
+  if (!entry->GetSSL().Equals(original_ssl_status))
+    controller_->web_contents()->DidChangeVisibleSSLState();
 }
 
 }  // namespace content