Moving notification types which are chrome specific to a new header file chrome_notification_type...

content/browser/ssl/ssl_manager.cc

 // Copyright (c) 2011 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/utf_string_conversions.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/load_from_memory_cache_details.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
@@ skipping 29 matching lines @@
                                                 request,
                                                 info->resource_type(),
                                                 cert_error,
                                                 cert),
                         &SSLCertErrorHandler::Dispatch));
 }
 
 // static
 void SSLManager::NotifySSLInternalStateChanged() {
   NotificationService::current()->Notify(
-      NotificationType::SSL_INTERNAL_STATE_CHANGED,
+      content::NOTIFICATION_SSL_INTERNAL_STATE_CHANGED,
       NotificationService::AllSources(),
       NotificationService::NoDetails());
 }
 
 // static
 std::string SSLManager::SerializeSecurityInfo(int cert_id,
                                               int cert_status,
                                               int security_bits,
                                               int ssl_connection_status) {
   Pickle pickle;
@@ skipping 29 matching lines @@
          pickle.ReadInt(&iter, ssl_connection_status);
 }
 
 SSLManager::SSLManager(NavigationController* controller)
     : backend_(controller),
       policy_(new SSLPolicy(&backend_)),
       controller_(controller) {
   DCHECK(controller_);
 
   // Subscribe to various notifications.
-  registrar_.Add(this, NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
+  registrar_.Add(this, content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
                  Source<NavigationController>(controller_));
-  registrar_.Add(this, NotificationType::RESOURCE_RESPONSE_STARTED,
+  registrar_.Add(this, content::NOTIFICATION_RESOURCE_RESPONSE_STARTED,
                  Source<RenderViewHostDelegate>(controller_->tab_contents()));
-  registrar_.Add(this, NotificationType::RESOURCE_RECEIVED_REDIRECT,
+  registrar_.Add(this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
                  Source<RenderViewHostDelegate>(controller_->tab_contents()));
-  registrar_.Add(this, NotificationType::LOAD_FROM_MEMORY_CACHE,
+  registrar_.Add(this, content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
                  Source<NavigationController>(controller_));
-  registrar_.Add(this, NotificationType::SSL_INTERNAL_STATE_CHANGED,
+  registrar_.Add(this, content::NOTIFICATION_SSL_INTERNAL_STATE_CHANGED,
                  NotificationService::AllSources());
 }
 
 SSLManager::~SSLManager() {
 }
 
 void SSLManager::DidCommitProvisionalLoad(
     const NotificationDetails& in_details) {
   content::LoadCommittedDetails* details =
       Details<content::LoadCommittedDetails>(in_details).ptr();
@@ skipping 32 matching lines @@
 bool SSLManager::ProcessedSSLErrorFromRequest() const {
   NavigationEntry* entry = controller_->GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return false;
   }
 
   return net::IsCertStatusError(entry->ssl().cert_status());
 }
 
-void SSLManager::Observe(NotificationType type,
+void SSLManager::Observe(int type,
                          const NotificationSource& source,
                          const NotificationDetails& details) {
   // Dispatch by type.
-  switch (type.value) {
-    case NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR:
+  switch (type) {
+    case content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR:
       // Do nothing.
       break;
-    case NotificationType::RESOURCE_RESPONSE_STARTED:
+    case content::NOTIFICATION_RESOURCE_RESPONSE_STARTED:
       DidStartResourceResponse(Details<ResourceRequestDetails>(details).ptr());
       break;
-    case NotificationType::RESOURCE_RECEIVED_REDIRECT:
+    case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT:
       DidReceiveResourceRedirect(
           Details<ResourceRedirectDetails>(details).ptr());
       break;
-    case NotificationType::LOAD_FROM_MEMORY_CACHE:
+    case content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE:
       DidLoadFromMemoryCache(
           Details<LoadFromMemoryCacheDetails>(details).ptr());
       break;
-    case NotificationType::SSL_INTERNAL_STATE_CHANGED:
+    case content::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
@@ skipping 42 matching lines @@
   // case of the Web Inspector.
   if (!entry)
     return;
 
   NavigationEntry::SSLStatus original_ssl_status = entry->ssl();  // Copy!
 
   policy()->UpdateEntry(entry, controller_->tab_contents());
 
   if (!entry->ssl().Equals(original_ssl_status)) {
     NotificationService::current()->Notify(
-        NotificationType::SSL_VISIBLE_STATE_CHANGED,
+        content::NOTIFICATION_SSL_VISIBLE_STATE_CHANGED,
         Source<NavigationController>(controller_),
         NotificationService::NoDetails());
   }
 }