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

chrome/browser/translate/translate_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 "chrome/browser/translate/translate_manager.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/autofill/autofill_manager.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/language_state.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/translate/page_translated_details.h"
 #include "chrome/browser/translate/translate_infobar_delegate.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/translate/translate_prefs.h"
 #include "chrome/browser/ui/browser.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/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/translate_errors.h"
 #include "chrome/common/url_constants.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/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/content_notification_types.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
-#include "content/common/notification_type.h"
 #include "grit/browser_resources.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_status.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace {
 
 // The list of languages the Google translation server supports.
 // For information, here is the list of languages that Chrome can be run in
 // but that the translation server does not support:
@@ skipping 187 matching lines @@
     return chrome_locale;
   return chrome_locale.substr(0, hypen_index);
 }
 
 // static
 bool TranslateManager::IsSupportedLanguage(const std::string& page_language) {
   InitSupportedLanguages();
   return supported_languages_.Pointer()->count(page_language) != 0;
 }
 
-void TranslateManager::Observe(NotificationType type,
+void TranslateManager::Observe(int type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::NAV_ENTRY_COMMITTED: {
+  switch (type) {
+    case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
       NavigationController* controller =
           Source<NavigationController>(source).ptr();
       content::LoadCommittedDetails* load_details =
           Details<content::LoadCommittedDetails>(details).ptr();
       NavigationEntry* entry = controller->GetActiveEntry();
       if (!entry) {
         NOTREACHED();
         return;
       }
 
@@ skipping 22 matching lines @@
       // current infobars.  Since InitTranslation might add an infobar, it must
       // be done after that.
       MessageLoop::current()->PostTask(FROM_HERE,
           method_factory_.NewRunnableMethod(
               &TranslateManager::InitiateTranslationPosted,
               controller->tab_contents()->render_view_host()->process()->id(),
               controller->tab_contents()->render_view_host()->routing_id(),
               helper->language_state().original_language()));
       break;
     }
-    case NotificationType::TAB_LANGUAGE_DETERMINED: {
+    case chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED: {
       TabContents* tab = Source<TabContents>(source).ptr();
       // We may get this notifications multiple times.  Make sure to translate
       // only once.
       TabContentsWrapper* wrapper =
           TabContentsWrapper::GetCurrentWrapperForContents(tab);
       if (!wrapper || !wrapper->translate_tab_helper())
         return;
 
       LanguageState& language_state =
           wrapper->translate_tab_helper()->language_state();
       if (language_state.page_translatable() &&
           !language_state.translation_pending() &&
           !language_state.translation_declined() &&
           !language_state.IsPageTranslated()) {
         std::string language = *(Details<std::string>(details).ptr());
         InitiateTranslation(tab, language);
       }
       break;
     }
-    case NotificationType::PAGE_TRANSLATED: {
+    case chrome::NOTIFICATION_PAGE_TRANSLATED: {
       // Only add translate infobar if it doesn't exist; if it already exists,
       // just update the state, the actual infobar would have received the same
       //  notification and update the visual display accordingly.
       TabContents* tab = Source<TabContents>(source).ptr();
       PageTranslatedDetails* page_translated_details =
           Details<PageTranslatedDetails>(details).ptr();
       PageTranslated(tab, page_translated_details);
       break;
     }
-    case NotificationType::PROFILE_DESTROYED: {
+    case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       Profile* profile = Source<Profile>(source).ptr();
-      notification_registrar_.Remove(this, NotificationType::PROFILE_DESTROYED,
+      notification_registrar_.Remove(this,
+                                     chrome::NOTIFICATION_PROFILE_DESTROYED,
                                      source);
       size_t count = accept_languages_.erase(profile->GetPrefs());
       // We should know about this profile since we are listening for
       // notifications on it.
       DCHECK(count > 0);
       pref_change_registrar_.Remove(prefs::kAcceptLanguages, this);
       break;
     }
-    case NotificationType::PREF_CHANGED: {
+    case chrome::NOTIFICATION_PREF_CHANGED: {
       DCHECK(*Details<std::string>(details).ptr() == prefs::kAcceptLanguages);
       PrefService* prefs = Source<PrefService>(source).ptr();
       InitAcceptLanguages(prefs);
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
@@ skipping 69 matching lines @@
 }
 
 // static
 bool TranslateManager::IsShowingTranslateInfobar(TabContents* tab) {
   return GetTranslateInfoBarDelegate(tab) != NULL;
 }
 
 TranslateManager::TranslateManager()
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       translate_script_expiration_delay_(kTranslateScriptExpirationDelayMS) {
-  notification_registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+  notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                               NotificationService::AllSources());
-  notification_registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
+  notification_registrar_.Add(this,
+                              chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
                               NotificationService::AllSources());
-  notification_registrar_.Add(this, NotificationType::PAGE_TRANSLATED,
+  notification_registrar_.Add(this, chrome::NOTIFICATION_PAGE_TRANSLATED,
                               NotificationService::AllSources());
 }
 
 void TranslateManager::InitiateTranslation(TabContents* tab,
                                            const std::string& page_lang) {
   PrefService* prefs = tab->profile()->GetOriginalProfile()->GetPrefs();
   if (!prefs->GetBoolean(prefs::kEnableTranslate))
     return;
 
   pref_change_registrar_.Init(prefs);
@@ skipping 210 matching lines @@
 
 bool TranslateManager::IsAcceptLanguage(TabContents* tab,
                                         const std::string& language) {
   PrefService* pref_service = tab->profile()->GetOriginalProfile()->GetPrefs();
   PrefServiceLanguagesMap::const_iterator iter =
       accept_languages_.find(pref_service);
   if (iter == accept_languages_.end()) {
     InitAcceptLanguages(pref_service);
     // Listen for this profile going away, in which case we would need to clear
     // the accepted languages for the profile.
-    notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
+    notification_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                                 Source<Profile>(tab->profile()));
     // Also start listening for changes in the accept languages.
     pref_change_registrar_.Add(prefs::kAcceptLanguages, this);
 
     iter = accept_languages_.find(pref_service);
   }
 
   return iter->second.count(language) != 0;
 }
 
@@ skipping 99 matching lines @@
     return NULL;
 
   for (size_t i = 0; i < wrapper->infobar_count(); ++i) {
     TranslateInfoBarDelegate* delegate =
         wrapper->GetInfoBarDelegateAt(i)->AsTranslateInfoBarDelegate();
     if (delegate)
       return delegate;
   }
   return NULL;
 }