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

chrome/browser/extensions/extension_event_router.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 "chrome/browser/extensions/extension_event_router.h"
 
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_devtools_manager.h"
 #include "chrome/browser/extensions/extension_processes_api.h"
 #include "chrome/browser/extensions/extension_processes_api_constants.h"
@@ skipping 47 matching lines @@
   ListValue args;
   args.Set(0, Value::CreateStringValue(event_name));
   args.Set(1, Value::CreateStringValue(event_args));
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(MSG_ROUTING_CONTROL,
       extension_id, kDispatchEvent, args, event_url));
 }
 
 ExtensionEventRouter::ExtensionEventRouter(Profile* profile)
     : profile_(profile),
       extension_devtools_manager_(profile->GetExtensionDevToolsManager()) {
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_TERMINATED,
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_CLOSED,
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  NotificationService::AllSources());
 }
 
 ExtensionEventRouter::~ExtensionEventRouter() {
 }
 
 void ExtensionEventRouter::AddEventListener(
     const std::string& event_name,
     RenderProcessHost* process,
     const std::string& extension_id) {
@@ skipping 133 matching lines @@
                       event_name, cross_incognito_args, event_url);
       }
       continue;
     }
 
     DispatchEvent(listener->process, listener->extension_id,
                   event_name, event_args, event_url);
   }
 }
 
-void ExtensionEventRouter::Observe(NotificationType type,
+void ExtensionEventRouter::Observe(int type,
                                    const NotificationSource& source,
                                    const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::RENDERER_PROCESS_TERMINATED:
-    case NotificationType::RENDERER_PROCESS_CLOSED: {
+  switch (type) {
+    case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
+    case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       RenderProcessHost* renderer = Source<RenderProcessHost>(source).ptr();
       // Remove all event listeners associated with this renderer
       for (ListenerMap::iterator it = listeners_.begin();
            it != listeners_.end(); ) {
         ListenerMap::iterator current_it = it++;
         for (std::set<EventListener>::iterator jt = current_it->second.begin();
              jt != current_it->second.end(); ) {
           std::set<EventListener>::iterator current_jt = jt++;
           if (current_jt->process == renderer) {
             RemoveEventListener(current_it->first,
                                 current_jt->process,
                                 current_jt->extension_id);
           }
         }
       }
       break;
     }
     default:
       NOTREACHED();
       return;
   }
 }