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

content/browser/tab_contents/navigation_controller.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 "content/browser/tab_contents/navigation_controller.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 24 matching lines @@
 // Invoked when entries have been pruned, or removed. For example, if the
 // current entries are [google, digg, yahoo], with the current entry google,
 // and the user types in cnet, then digg and yahoo are pruned.
 void NotifyPrunedEntries(NavigationController* nav_controller,
                          bool from_front,
                          int count) {
   content::PrunedDetails details;
   details.from_front = from_front;
   details.count = count;
   NotificationService::current()->Notify(
-      NotificationType::NAV_LIST_PRUNED,
+      content::NOTIFICATION_NAV_LIST_PRUNED,
       Source<NavigationController>(nav_controller),
       Details<content::PrunedDetails>(&details));
 }
 
 // Ensure the given NavigationEntry has a valid state, so that WebKit does not
 // get confused if we navigate back to it.
 //
 // An empty state is treated as a new navigation by WebKit, which would mean
 // losing the navigation entries and generating a new navigation entry after
 // this one. We don't want that. To avoid this we create a valid state which
@@ skipping 70 matching lines @@
   if (!session_storage_namespace_) {
     session_storage_namespace_ = new SessionStorageNamespace(
         profile_->GetWebKitContext());
   }
 }
 
 NavigationController::~NavigationController() {
   DiscardNonCommittedEntriesInternal();
 
   NotificationService::current()->Notify(
-      NotificationType::TAB_CLOSED,
+      content::NOTIFICATION_TAB_CLOSED,
       Source<NavigationController>(this),
       NotificationService::NoDetails());
 }
 
 void NavigationController::Restore(
     int selected_navigation,
     bool from_last_session,
     std::vector<NavigationEntry*>* entries) {
   // Verify that this controller is unused and that the input is valid.
   DCHECK(entry_count() == 0 && !pending_entry());
@@ skipping 29 matching lines @@
   if (current_index == -1) {
     return;
   }
 
   if (check_for_repost_ && check_for_repost &&
       GetEntryAtIndex(current_index)->has_post_data()) {
     // The user is asking to reload a page with POST data. Prompt to make sure
     // they really want to do this. If they do, the dialog will call us back
     // with check_for_repost = false.
     NotificationService::current()->Notify(
-        NotificationType::REPOST_WARNING_SHOWN,
+        content::NOTIFICATION_REPOST_WARNING_SHOWN,
         Source<NavigationController>(this),
         NotificationService::NoDetails());
 
     pending_reload_ = reload_type;
     tab_contents_->Activate();
     tab_contents_->delegate()->ShowRepostFormWarningDialog(tab_contents_);
   } else {
     DiscardNonCommittedEntriesInternal();
 
     pending_entry_index_ = current_index;
@@ skipping 66 matching lines @@
     delete entry;
     return;
   }
 
   // When navigating to a new page, we don't know for sure if we will actually
   // end up leaving the current page.  The new page load could for example
   // result in a download or a 'no content' response (e.g., a mailto: URL).
   DiscardNonCommittedEntriesInternal();
   pending_entry_ = entry;
   NotificationService::current()->Notify(
-      NotificationType::NAV_ENTRY_PENDING,
+      content::NOTIFICATION_NAV_ENTRY_PENDING,
       Source<NavigationController>(this),
       NotificationService::NoDetails());
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 NavigationEntry* NavigationController::GetActiveEntry() const {
   if (transient_entry_index_ != -1)
     return entries_[transient_entry_index_].get();
   if (pending_entry_)
     return pending_entry_;
@@ skipping 770 matching lines @@
   // location bar will have up-to-date information about the security style
   // when it wants to draw.  See http://crbug.com/11157
   ssl_manager_.DidCommitProvisionalLoad(notification_details);
 
   // TODO(pkasting): http://b/1113079 Probably these explicit notification paths
   // should be removed, and interested parties should just listen for the
   // notification below instead.
   tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 
   NotificationService::current()->Notify(
-      NotificationType::NAV_ENTRY_COMMITTED,
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       Source<NavigationController>(this),
       notification_details);
 }
 
 // static
 void NavigationController::DisablePromptOnRepost() {
   check_for_repost_ = false;
 }
 
 void NavigationController::SetActive(bool is_active) {
@@ skipping 10 matching lines @@
   // cached state.
   pending_entry_index_ = last_committed_entry_index_;
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::NotifyEntryChanged(const NavigationEntry* entry,
                                               int index) {
   content::EntryChangedDetails det;
   det.changed_entry = entry;
   det.index = index;
-  NotificationService::current()->Notify(NotificationType::NAV_ENTRY_CHANGED,
+  NotificationService::current()->Notify(
+      content::NOTIFICATION_NAV_ENTRY_CHANGED,
       Source<NavigationController>(this),
       Details<content::EntryChangedDetails>(&det));
 }
 
 void NavigationController::FinishRestore(int selected_index,
                                          bool from_last_session) {
   DCHECK(selected_index >= 0 && selected_index < entry_count());
   ConfigureEntriesForRestore(&entries_, from_last_session);
 
   set_max_restored_page_id(static_cast<int32>(entry_count()));
@@ skipping 42 matching lines @@
   size_t insert_index = 0;
   for (int i = 0; i < max_index; i++) {
     // When cloning a tab, copy all entries except interstitial pages
     if (source.entries_[i].get()->page_type() != INTERSTITIAL_PAGE) {
       entries_.insert(entries_.begin() + insert_index++,
                       linked_ptr<NavigationEntry>(
                           new NavigationEntry(*source.entries_[i])));
     }
   }
 }