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

chrome/browser/content_settings/tab_specific_content_settings.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/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/lazy_instance.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_appcache_helper.h"
 #include "chrome/browser/browsing_data_database_helper.h"
 #include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/browser/browsing_data_indexed_db_helper.h"
 #include "chrome/browser/browsing_data_local_storage_helper.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/cookies_tree_model.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/common/notification_service.h"
 #include "content/common/view_messages.h"
 #include "net/base/cookie_monster.h"
 #include "webkit/fileapi/file_system_types.h"
@@ skipping 17 matching lines @@
 TabSpecificContentSettings::TabSpecificContentSettings(TabContents* tab)
     : TabContentsObserver(tab),
       allowed_local_shared_objects_(tab->profile()),
       blocked_local_shared_objects_(tab->profile()),
       geolocation_settings_state_(tab->profile()),
       load_plugins_link_enabled_(true) {
   ClearBlockedContentSettingsExceptForCookies();
   ClearCookieSpecificContentSettings();
   g_tab_specific.Get().push_back(this);
 
-  registrar_.Add(this, NotificationType::CONTENT_SETTINGS_CHANGED,
+  registrar_.Add(this, chrome::NOTIFICATION_CONTENT_SETTINGS_CHANGED,
                  Source<HostContentSettingsMap>(
                      tab->profile()->GetHostContentSettingsMap()));
 }
 
 TabSpecificContentSettings::~TabSpecificContentSettings() {
   g_tab_specific.Get().remove(this);
 }
 
 TabSpecificContentSettings* TabSpecificContentSettings::Get(
     int render_process_id, int render_view_id) {
@@ skipping 138 matching lines @@
     const std::string& resource_identifier) {
   DCHECK(type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by OnGeolocationPermissionSet";
   content_accessed_[type] = true;
   if (!resource_identifier.empty())
     AddBlockedResource(type, resource_identifier);
   if (!content_blocked_[type]) {
     content_blocked_[type] = true;
     // TODO: it would be nice to have a way of mocking this in tests.
     NotificationService::current()->Notify(
-        NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+        chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
         Source<TabContents>(tab_contents()),
         NotificationService::NoDetails());
   }
 }
 
 void TabSpecificContentSettings::OnContentAccessed(ContentSettingsType type) {
   DCHECK(type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by OnGeolocationPermissionSet";
   if (!content_accessed_[type]) {
     content_accessed_[type] = true;
     NotificationService::current()->Notify(
-        NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+        chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
         Source<TabContents>(tab_contents()),
         NotificationService::NoDetails());
   }
 }
 
 void TabSpecificContentSettings::OnCookiesRead(
     const GURL& url,
     const net::CookieList& cookie_list,
     bool blocked_by_policy) {
   if (cookie_list.empty())
@@ skipping 105 matching lines @@
         fileapi::kFileSystemTypeTemporary, 0);
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 void TabSpecificContentSettings::OnGeolocationPermissionSet(
     const GURL& requesting_origin,
     bool allowed) {
   geolocation_settings_state_.OnGeolocationPermissionSet(requesting_origin,
                                                          allowed);
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+      chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
       Source<TabContents>(tab_contents()),
       NotificationService::NoDetails());
 }
 
 void TabSpecificContentSettings::ClearBlockedContentSettingsExceptForCookies() {
   for (size_t i = 0; i < arraysize(content_blocked_); ++i) {
     if (i == CONTENT_SETTINGS_TYPE_COOKIES)
       continue;
     blocked_resources_[i].reset();
     content_blocked_[i] = false;
     content_accessed_[i] = false;
     content_blockage_indicated_to_user_[i] = false;
   }
   load_plugins_link_enabled_ = true;
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+      chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
       Source<TabContents>(tab_contents()),
       NotificationService::NoDetails());
 }
 
 void TabSpecificContentSettings::ClearCookieSpecificContentSettings() {
   blocked_local_shared_objects_.Reset();
   allowed_local_shared_objects_.Reset();
   content_blocked_[CONTENT_SETTINGS_TYPE_COOKIES] = false;
   content_accessed_[CONTENT_SETTINGS_TYPE_COOKIES] = false;
   content_blockage_indicated_to_user_[CONTENT_SETTINGS_TYPE_COOKIES] = false;
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+      chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
       Source<TabContents>(tab_contents()),
       NotificationService::NoDetails());
 }
 
 void TabSpecificContentSettings::SetPopupsBlocked(bool blocked) {
   content_blocked_[CONTENT_SETTINGS_TYPE_POPUPS] = blocked;
   content_blockage_indicated_to_user_[CONTENT_SETTINGS_TYPE_POPUPS] = false;
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+      chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
       Source<TabContents>(tab_contents()),
       NotificationService::NoDetails());
 }
 
 void TabSpecificContentSettings::GeolocationDidNavigate(
       const content::LoadCommittedDetails& details) {
   geolocation_settings_state_.DidNavigate(details);
 }
 
 void TabSpecificContentSettings::ClearGeolocationContentSettings() {
@@ skipping 47 matching lines @@
     return;
 
   // If we're displaying a network error page do not reset the content
   // settings delegate's cookies so the user has a chance to modify cookie
   // settings.
   if (!is_error_page)
     ClearCookieSpecificContentSettings();
   ClearGeolocationContentSettings();
 }
 
-void TabSpecificContentSettings::Observe(NotificationType type,
+void TabSpecificContentSettings::Observe(int type,
                                          const NotificationSource& source,
                                          const NotificationDetails& details) {
-  DCHECK(type.value == NotificationType::CONTENT_SETTINGS_CHANGED);
+  DCHECK(type == chrome::NOTIFICATION_CONTENT_SETTINGS_CHANGED);
 
   Details<const ContentSettingsDetails> settings_details(details);
   const NavigationController& controller = tab_contents()->controller();
   NavigationEntry* entry = controller.GetActiveEntry();
   GURL entry_url;
   if (entry)
     entry_url = entry->url();
   if (settings_details.ptr()->update_all() ||
       // The active NavigationEntry is the URL in the URL field of a tab.
       // Currently this should be matched by the |primary_pattern|.
@@ skipping 44 matching lines @@
 TabSpecificContentSettings::LocalSharedObjectsContainer::GetCookiesTreeModel() {
   return new CookiesTreeModel(cookies_,
                               databases_->Clone(),
                               local_storages_->Clone(),
                               session_storages_->Clone(),
                               appcaches_->Clone(),
                               indexed_dbs_->Clone(),
                               file_systems_->Clone(),
                               true);
 }