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

chrome/browser/task_manager/task_manager_resource_providers.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/task_manager/task_manager_resource_providers.h"
 
 #include "base/basictypes.h"
 #include "base/file_version_info.h"
 #include "base/i18n/rtl.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/background/background_contents_service_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/tab_contents/background_contents.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/browser_child_process_host.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.h"
@@ skipping 278 matching lines @@
 
 void TaskManagerTabContentsResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
   // Add all the existing TabContents.
   for (TabContentsIterator iterator; !iterator.done(); ++iterator)
     Add(*iterator);
 
   // Then we register for notifications to get new tabs.
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_CONNECTED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_SWAPPED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_SWAPPED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
                  NotificationService::AllSources());
   // TAB_CONTENTS_DISCONNECTED should be enough to know when to remove a
   // resource.  This is an attempt at mitigating a crasher that seem to
   // indicate a resource is still referencing a deleted TabContents
   // (http://crbug.com/7321).
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_DESTROYED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                  NotificationService::AllSources());
 }
 
 void TaskManagerTabContentsResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
   // Then we unregister for notifications to get new tabs.
-  registrar_.Remove(this, NotificationType::TAB_CONTENTS_CONNECTED,
+  registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_CONNECTED,
                     NotificationService::AllSources());
-  registrar_.Remove(this, NotificationType::TAB_CONTENTS_SWAPPED,
+  registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_SWAPPED,
                     NotificationService::AllSources());
-  registrar_.Remove(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
+  registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
                     NotificationService::AllSources());
-  registrar_.Remove(this, NotificationType::TAB_CONTENTS_DESTROYED,
+  registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                     NotificationService::AllSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
 }
 
 void TaskManagerTabContentsResourceProvider::AddToTaskManager(
     TabContentsWrapper* tab_contents) {
@@ skipping 42 matching lines @@
 
   // Remove the resource from the Task Manager.
   TaskManagerTabContentsResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
   // And from the provider.
   resources_.erase(iter);
   // Finally, delete the resource.
   delete resource;
 }
 
-void TaskManagerTabContentsResourceProvider::Observe(NotificationType type,
+void TaskManagerTabContentsResourceProvider::Observe(int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   TabContentsWrapper* tab_contents =
       TabContentsWrapper::GetCurrentWrapperForContents(
           Source<TabContents>(source).ptr());
   // A background page does not have a TabContentsWrapper.
   if (!tab_contents)
     return;
-  switch (type.value) {
-    case NotificationType::TAB_CONTENTS_CONNECTED:
+  switch (type) {
+    case content::NOTIFICATION_TAB_CONTENTS_CONNECTED:
       Add(tab_contents);
       break;
-    case NotificationType::TAB_CONTENTS_SWAPPED:
+    case content::NOTIFICATION_TAB_CONTENTS_SWAPPED:
       Remove(tab_contents);
       Add(tab_contents);
       break;
-    case NotificationType::TAB_CONTENTS_DESTROYED:
+    case content::NOTIFICATION_TAB_CONTENTS_DESTROYED:
       // If this DCHECK is triggered, it could explain http://crbug.com/7321 .
       DCHECK(resources_.find(tab_contents) ==
              resources_.end()) << "TAB_CONTENTS_DESTROYED with no associated "
                                   "TAB_CONTENTS_DISCONNECTED";
       // Fall through.
-    case NotificationType::TAB_CONTENTS_DISCONNECTED:
+    case content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED:
       Remove(tab_contents);
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerBackgroundContentsResource class
@@ skipping 108 matching lines @@
         const Extension* extension = extensions_service->GetExtensionById(
             UTF16ToUTF8(application_id), false);
         if (extension)
           application_name = UTF8ToUTF16(extension->name());
       }
       Add(*iterator, application_name);
     }
   }
 
   // Then we register for notifications to get new BackgroundContents.
-  registrar_.Add(this, NotificationType::BACKGROUND_CONTENTS_OPENED,
+  registrar_.Add(this, chrome::NOTIFICATION_BACKGROUND_CONTENTS_OPENED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BACKGROUND_CONTENTS_NAVIGATED,
+  registrar_.Add(this, chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BACKGROUND_CONTENTS_DELETED,
+  registrar_.Add(this, chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED,
                  NotificationService::AllSources());
 }
 
 void TaskManagerBackgroundContentsResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
   // Unregister for notifications
-  registrar_.Remove(this, NotificationType::BACKGROUND_CONTENTS_OPENED,
+  registrar_.Remove(this, chrome::NOTIFICATION_BACKGROUND_CONTENTS_OPENED,
                     NotificationService::AllSources());
-  registrar_.Remove(this, NotificationType::BACKGROUND_CONTENTS_NAVIGATED,
+  registrar_.Remove(this, chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED,
                     NotificationService::AllSources());
-  registrar_.Remove(this, NotificationType::BACKGROUND_CONTENTS_DELETED,
+  registrar_.Remove(this, chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED,
                     NotificationService::AllSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
 }
 
 void TaskManagerBackgroundContentsResourceProvider::AddToTaskManager(
     BackgroundContents* background_contents,
@@ skipping 31 matching lines @@
   // Remove the resource from the Task Manager.
   TaskManagerBackgroundContentsResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
   // And from the provider.
   resources_.erase(iter);
   // Finally, delete the resource.
   delete resource;
 }
 
 void TaskManagerBackgroundContentsResourceProvider::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::BACKGROUND_CONTENTS_OPENED: {
+  switch (type) {
+    case chrome::NOTIFICATION_BACKGROUND_CONTENTS_OPENED: {
       // Get the name from the parent application. If no parent application is
       // found, just pass an empty string - BackgroundContentsResource::GetTitle
       // will display the URL instead in this case. This should never happen
       // except in rare cases when an extension is being unloaded or chrome is
       // exiting while the task manager is displayed.
       string16 application_name;
       ExtensionService* service =
           Source<Profile>(source)->GetExtensionService();
       if (service) {
         std::string application_id = UTF16ToUTF8(
             Details<BackgroundContentsOpenedDetails>(details)->application_id);
         const Extension* extension =
             service->GetExtensionById(application_id, false);
         // Extension can be NULL when running unit tests.
         if (extension)
           application_name = UTF8ToUTF16(extension->name());
       }
       Add(Details<BackgroundContentsOpenedDetails>(details)->contents,
           application_name);
       // Opening a new BackgroundContents needs to force the display to refresh
       // (applications may now be considered "background" that weren't before).
       task_manager_->ModelChanged();
       break;
     }
-    case NotificationType::BACKGROUND_CONTENTS_NAVIGATED: {
+    case chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED: {
       BackgroundContents* contents = Details<BackgroundContents>(details).ptr();
       // Should never get a NAVIGATED before OPENED.
       DCHECK(resources_.find(contents) != resources_.end());
       // Preserve the application name.
       string16 application_name(
           resources_.find(contents)->second->application_name());
       Remove(contents);
       Add(contents, application_name);
       break;
     }
-    case NotificationType::BACKGROUND_CONTENTS_DELETED:
+    case chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED:
       Remove(Details<BackgroundContents>(details).ptr());
       // Closing a BackgroundContents needs to force the display to refresh
       // (applications may now be considered "foreground" that weren't before).
       task_manager_->ModelChanged();
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
@@ skipping 154 matching lines @@
     return iter->second;
   else
     return NULL;
 }
 
 void TaskManagerChildProcessResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
   // Register for notifications to get new child processes.
-  registrar_.Add(this, NotificationType::CHILD_PROCESS_HOST_CONNECTED,
+  registrar_.Add(this, content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::CHILD_PROCESS_HOST_DISCONNECTED,
+  registrar_.Add(this, content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED,
                  NotificationService::AllSources());
 
   // Get the existing child processes.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           this,
           &TaskManagerChildProcessResourceProvider::RetrieveChildProcessInfo));
 }
 
 void TaskManagerChildProcessResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
   // Unregister for notifications to get new plugin processes.
-  registrar_.Remove(this, NotificationType::CHILD_PROCESS_HOST_CONNECTED,
+  registrar_.Remove(this, content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED,
                     NotificationService::AllSources());
   registrar_.Remove(this,
-                    NotificationType::CHILD_PROCESS_HOST_DISCONNECTED,
+                    content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED,
                     NotificationService::AllSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
   pid_to_resources_.clear();
   existing_child_process_info_.clear();
 }
 
 void TaskManagerChildProcessResourceProvider::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::CHILD_PROCESS_HOST_CONNECTED:
+  switch (type) {
+    case content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED:
       Add(*Details<ChildProcessInfo>(details).ptr());
       break;
-    case NotificationType::CHILD_PROCESS_HOST_DISCONNECTED:
+    case content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED:
       Remove(*Details<ChildProcessInfo>(details).ptr());
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 void TaskManagerChildProcessResourceProvider::Add(
     const ChildProcessInfo& child_process_info) {
@@ skipping 182 matching lines @@
           profiles[i]->GetOffTheRecordProfile()->GetExtensionProcessManager();
       if (process_manager) {
       ExtensionProcessManager::const_iterator jt;
       for (jt = process_manager->begin(); jt != process_manager->end(); ++jt)
         AddToTaskManager(*jt);
       }
     }
   }
 
   // Register for notifications about extension process changes.
-  registrar_.Add(this, NotificationType::EXTENSION_PROCESS_CREATED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_CREATED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_HOST_DESTROYED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  NotificationService::AllSources());
 }
 
 void TaskManagerExtensionProcessResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
   // Unregister for notifications about extension process changes.
-  registrar_.Remove(this, NotificationType::EXTENSION_PROCESS_CREATED,
+  registrar_.Remove(this, chrome::NOTIFICATION_EXTENSION_PROCESS_CREATED,
                     NotificationService::AllSources());
-  registrar_.Remove(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
+  registrar_.Remove(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                     NotificationService::AllSources());
-  registrar_.Remove(this, NotificationType::EXTENSION_HOST_DESTROYED,
+  registrar_.Remove(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                     NotificationService::AllSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
   pid_to_resources_.clear();
 }
 
 void TaskManagerExtensionProcessResourceProvider::Observe(
-    NotificationType type,
+    int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::EXTENSION_PROCESS_CREATED:
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_PROCESS_CREATED:
       AddToTaskManager(Details<ExtensionHost>(details).ptr());
       break;
-    case NotificationType::EXTENSION_PROCESS_TERMINATED:
-    case NotificationType::EXTENSION_HOST_DESTROYED:
+    case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED:
+    case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED:
       RemoveFromTaskManager(Details<ExtensionHost>(details).ptr());
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 void TaskManagerExtensionProcessResourceProvider::AddToTaskManager(
     ExtensionHost* extension_host) {
@@ skipping 164 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }