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

chrome/browser/profiles/profile_impl.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/profiles/profile_impl.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/file_path.h"
@@ skipping 58 matching lines @@
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/find_bar/find_bar_state.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/ui/webui/extension_icon_source.h"
 #include "chrome/browser/user_style_sheet_watcher.h"
 #include "chrome/browser/visitedlink/visitedlink_event_listener.h"
 #include "chrome/browser/visitedlink/visitedlink_master.h"
 #include "chrome/browser/web_resource/promo_resource_service.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/json_pref_store.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/browser_thread.h"
@@ skipping 213 matching lines @@
       TimeDelta::FromMilliseconds(kCreateSessionServiceDelayMS), this,
       &ProfileImpl::EnsureSessionServiceCreated);
 
   if (delegate_) {
     prefs_.reset(PrefService::CreatePrefService(
         GetPrefFilePath(),
         new ExtensionPrefStore(GetExtensionPrefValueMap(), false),
         true));
     // Wait for the notifcation that prefs has been loaded (successfully or
     // not).
-    registrar_.Add(this, NotificationType::PREF_INITIALIZATION_COMPLETED,
+    registrar_.Add(this, chrome::NOTIFICATION_PREF_INITIALIZATION_COMPLETED,
                    Source<PrefService>(prefs_.get()));
   } else {
     // Load prefs synchronously.
     prefs_.reset(PrefService::CreatePrefService(
         GetPrefFilePath(),
         new ExtensionPrefStore(GetExtensionPrefValueMap(), false),
         false));
     OnPrefsLoaded(true);
   }
 }
@@ skipping 20 matching lines @@
     // It is safe since all other file operations should also be done there.
     BrowserThread::PostTask(BrowserThread::FILE,
                             FROM_HERE,
                             NewRunnableFunction(&file_util::CreateDirectory,
                                                 base_cache_path_));
   }
 
 #if !defined(OS_CHROMEOS)
   // Listen for bookmark model load, to bootstrap the sync service.
   // On CrOS sync service will be initialized after sign in.
-  registrar_.Add(this, NotificationType::BOOKMARK_MODEL_LOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
                  Source<Profile>(this));
 #endif
 
   PrefService* local_state = g_browser_process->local_state();
   ssl_config_service_manager_.reset(
       SSLConfigServiceManager::CreateDefaultManager(local_state));
 
   PinnedTabServiceFactory::InitForProfile(this);
 
   // Initialize the BackgroundModeManager - this has to be done here before
@@ skipping 214 matching lines @@
 FilePath ProfileImpl::last_selected_directory() {
   return GetPrefs()->GetFilePath(prefs::kSelectFileLastDirectory);
 }
 
 void ProfileImpl::set_last_selected_directory(const FilePath& path) {
   GetPrefs()->SetFilePath(prefs::kSelectFileLastDirectory, path);
 }
 
 ProfileImpl::~ProfileImpl() {
   NotificationService::current()->Notify(
-      NotificationType::PROFILE_DESTROYED,
+      chrome::NOTIFICATION_PROFILE_DESTROYED,
       Source<Profile>(this),
       NotificationService::NoDetails());
 
   StopCreateSessionServiceTimer();
 
   // Remove pref observers
   pref_change_registrar_.RemoveAll();
 
   ProfileDependencyManager::GetInstance()->DestroyProfileServices(this);
 
@@ skipping 92 matching lines @@
 bool ProfileImpl::IsOffTheRecord() {
   return false;
 }
 
 Profile* ProfileImpl::GetOffTheRecordProfile() {
   if (!off_the_record_profile_.get()) {
     scoped_ptr<Profile> p(CreateOffTheRecordProfile());
     off_the_record_profile_.swap(p);
 
     NotificationService::current()->Notify(
-        NotificationType::OTR_PROFILE_CREATED,
+        chrome::NOTIFICATION_OTR_PROFILE_CREATED,
         Source<Profile>(off_the_record_profile_.get()),
         NotificationService::NoDetails());
   }
   return off_the_record_profile_.get();
 }
 
 void ProfileImpl::DestroyOffTheRecordProfile() {
   off_the_record_profile_.reset();
   extension_pref_value_map_->ClearAllIncognitoSessionOnlyPreferences();
 }
@@ skipping 147 matching lines @@
   net::URLRequestContextGetter* request_context =
       io_data_.GetMainRequestContextGetter();
   // The first request context is always a normal (non-OTR) request context.
   // Even when Chromium is started in OTR mode, a normal profile is always
   // created first.
   if (!default_request_context_) {
     default_request_context_ = request_context;
     // TODO(eroman): this isn't terribly useful anymore now that the
     // net::URLRequestContext is constructed by the IO thread...
     NotificationService::current()->Notify(
-        NotificationType::DEFAULT_REQUEST_CONTEXT_AVAILABLE,
+        chrome::NOTIFICATION_DEFAULT_REQUEST_CONTEXT_AVAILABLE,
         NotificationService::AllSources(), NotificationService::NoDetails());
   }
 
   return request_context;
 }
 
 net::URLRequestContextGetter* ProfileImpl::GetRequestContextForRenderProcess(
     int renderer_child_id) {
   if (extension_service_.get()) {
     const Extension* installed_app = extension_service_->
@@ skipping 86 matching lines @@
         const std::string& host(*i);
         double zoom_level = 0;
 
         bool success = host_zoom_dictionary->GetDoubleWithoutPathExpansion(
             host, &zoom_level);
         DCHECK(success);
         host_zoom_map_->SetZoomLevel(host, zoom_level);
       }
     }
 
-    registrar_.Add(this, NotificationType::ZOOM_LEVEL_CHANGED,
+    registrar_.Add(this, content::NOTIFICATION_ZOOM_LEVEL_CHANGED,
                  Source<HostZoomMap>(host_zoom_map_));
   }
   return host_zoom_map_.get();
 }
 
 GeolocationContentSettingsMap* ProfileImpl::GetGeolocationContentSettingsMap() {
   if (!geolocation_content_settings_map_.get())
     geolocation_content_settings_map_ = new GeolocationContentSettingsMap(this);
   return geolocation_content_settings_map_.get();
 }
@@ skipping 28 matching lines @@
 
   if (!history_service_created_) {
     history_service_created_ = true;
     scoped_refptr<HistoryService> history(new HistoryService(this));
     if (!history->Init(GetPath(), GetBookmarkModel()))
       return NULL;
     history_service_.swap(history);
 
     // Send out the notification that the history service was created.
     NotificationService::current()->
-        Notify(NotificationType::HISTORY_CREATED, Source<Profile>(this),
+        Notify(chrome::NOTIFICATION_HISTORY_CREATED, Source<Profile>(this),
                Details<HistoryService>(history_service_.get()));
   }
   return history_service_.get();
 }
 
 HistoryService* ProfileImpl::GetHistoryServiceWithoutCreating() {
   return history_service_.get();
 }
 
 TemplateURLFetcher* ProfileImpl::GetTemplateURLFetcher() {
@@ skipping 311 matching lines @@
   if (prefs_.get()) {
     // The session cleanly exited, set kSessionExitedCleanly appropriately.
     prefs_->SetBoolean(prefs::kSessionExitedCleanly, true);
 
     // NOTE: If you change what thread this writes on, be sure and update
     // ChromeFrame::EndSession().
     prefs_->SavePersistentPrefs();
   }
 }
 
-void ProfileImpl::Observe(NotificationType type,
+void ProfileImpl::Observe(int type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::PREF_INITIALIZATION_COMPLETED: {
+  switch (type) {
+    case chrome::NOTIFICATION_PREF_INITIALIZATION_COMPLETED: {
       bool* succeeded = Details<bool>(details).ptr();
       PrefService *prefs = Source<PrefService>(source).ptr();
       DCHECK(prefs == prefs_.get());
-      registrar_.Remove(this, NotificationType::PREF_INITIALIZATION_COMPLETED,
+      registrar_.Remove(this,
+                        chrome::NOTIFICATION_PREF_INITIALIZATION_COMPLETED,
                         Source<PrefService>(prefs));
       OnPrefsLoaded(*succeeded);
       break;
     }
-    case NotificationType::PREF_CHANGED: {
+    case chrome::NOTIFICATION_PREF_CHANGED: {
       std::string* pref_name_in = Details<std::string>(details).ptr();
       PrefService* prefs = Source<PrefService>(source).ptr();
       DCHECK(pref_name_in && prefs);
       if (*pref_name_in == prefs::kSpellCheckDictionary ||
           *pref_name_in == prefs::kEnableSpellCheck) {
         ReinitializeSpellCheckHost(true);
       } else if (*pref_name_in == prefs::kEnableAutoSpellCorrect) {
         bool enabled = prefs->GetBoolean(prefs::kEnableAutoSpellCorrect);
         for (RenderProcessHost::iterator
              i(RenderProcessHost::AllHostsIterator());
@@ skipping 18 matching lines @@
         }
       } else if (*pref_name_in == prefs::kGoogleServicesUsername) {
         ProfileManager* profile_manager = g_browser_process->profile_manager();
         profile_manager->RegisterProfileName(this);
       } else if (*pref_name_in == prefs::kDefaultZoomLevel) {
           GetHostZoomMap()->set_default_zoom_level(
               prefs->GetDouble(prefs::kDefaultZoomLevel));
       }
       break;
     }
-    case NotificationType::BOOKMARK_MODEL_LOADED:
+    case chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED:
       GetProfileSyncService();  // Causes lazy-load if sync is enabled.
-      registrar_.Remove(this, NotificationType::BOOKMARK_MODEL_LOADED,
+      registrar_.Remove(this, chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
                         Source<Profile>(this));
       break;
-    case NotificationType::ZOOM_LEVEL_CHANGED: {
+    case content::NOTIFICATION_ZOOM_LEVEL_CHANGED: {
       const std::string& host = *(Details<const std::string>(details).ptr());
       if (!host.empty()) {
         double level = host_zoom_map_->GetZoomLevel(host);
         DictionaryPrefUpdate update(prefs_.get(), prefs::kPerHostZoomLevels);
         DictionaryValue* host_zoom_dictionary = update.Get();
         if (level == host_zoom_map_->default_zoom_level()) {
           host_zoom_dictionary->RemoveWithoutPathExpansion(host, NULL);
         } else {
           host_zoom_dictionary->SetWithoutPathExpansion(
               host, Value::CreateDoubleValue(level));
@@ skipping 223 matching lines @@
   if (!prerender::PrerenderManager::IsPrerenderingPossible())
     return NULL;
   if (!prerender_manager_.get()) {
     CHECK(g_browser_process->prerender_tracker());
     prerender_manager_.reset(
         new prerender::PrerenderManager(
             this, g_browser_process->prerender_tracker()));
   }
   return prerender_manager_.get();
 }