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

content/browser/tab_contents/interstitial_page.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/interstitial_page.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 186 matching lines @@
     }
   }
 
   // Block the resource requests for the render view host while it is hidden.
   TakeActionOnResourceDispatcher(BLOCK);
   // We need to be notified when the RenderViewHost is destroyed so we can
   // cancel the blocked requests.  We cannot do that on
   // NOTIFY_TAB_CONTENTS_DESTROYED as at that point the RenderViewHost has
   // already been destroyed.
   notification_registrar_.Add(
-      this, NotificationType::RENDER_WIDGET_HOST_DESTROYED,
+      this, content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
       Source<RenderWidgetHost>(tab_->render_view_host()));
 
   // Update the tab_to_interstitial_page_ map.
   iter = tab_to_interstitial_page_->find(tab_);
   DCHECK(iter == tab_to_interstitial_page_->end());
   (*tab_to_interstitial_page_)[tab_] = this;
 
   if (new_navigation_) {
     NavigationEntry* entry = new NavigationEntry;
     entry->set_url(url_);
     entry->set_virtual_url(url_);
     entry->set_page_type(INTERSTITIAL_PAGE);
 
     // Give sub-classes a chance to set some states on the navigation entry.
     UpdateEntry(entry);
 
     tab_->controller().AddTransientEntry(entry);
   }
 
   DCHECK(!render_view_host_);
   render_view_host_ = CreateRenderViewHost();
   CreateTabContentsView();
 
   std::string data_url = "data:text/html;charset=utf-8," +
                          EscapePath(GetHTMLContents());
   render_view_host_->NavigateToURL(GURL(data_url));
 
-  notification_registrar_.Add(this, NotificationType::TAB_CONTENTS_DESTROYED,
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                               Source<TabContents>(tab_));
-  notification_registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+  notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       Source<NavigationController>(&tab_->controller()));
-  notification_registrar_.Add(this, NotificationType::NAV_ENTRY_PENDING,
+  notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
       Source<NavigationController>(&tab_->controller()));
 }
 
 void InterstitialPage::Hide() {
   RenderWidgetHostView* old_view = tab_->render_view_host()->view();
   if (tab_->interstitial_page() == this && old_view && !old_view->IsShowing()) {
     // Show the original RVH since we're going away.  Note it might not exist if
     // the renderer crashed while the interstitial was showing.
     // Note that it is important that we don't call Show() if the view is
     // already showing. That would result in bad things (unparented HWND on
@@ skipping 14 matching lines @@
     tab_->remove_interstitial_page();
   // Let's revert to the original title if necessary.
   NavigationEntry* entry = tab_->controller().GetActiveEntry();
   if (!new_navigation_ && should_revert_tab_title_) {
     entry->set_title(WideToUTF16Hack(original_tab_title_));
     tab_->NotifyNavigationStateChanged(TabContents::INVALIDATE_TITLE);
   }
   delete this;
 }
 
-void InterstitialPage::Observe(NotificationType type,
+void InterstitialPage::Observe(int type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::NAV_ENTRY_PENDING:
+  switch (type) {
+    case content::NOTIFICATION_NAV_ENTRY_PENDING:
       // We are navigating away from the interstitial (the user has typed a URL
       // in the location bar or clicked a bookmark).  Make sure clicking on the
       // interstitial will have no effect.  Also cancel any blocked requests
       // on the ResourceDispatcherHost.  Note that when we get this notification
       // the RenderViewHost has not yet navigated so we'll unblock the
       // RenderViewHost before the resource request for the new page we are
       // navigating arrives in the ResourceDispatcherHost.  This ensures that
       // request won't be blocked if the same RenderViewHost was used for the
       // new navigation.
       Disable();
       TakeActionOnResourceDispatcher(CANCEL);
       break;
-    case NotificationType::RENDER_WIDGET_HOST_DESTROYED:
+    case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED:
       if (action_taken_ == NO_ACTION) {
         // The RenderViewHost is being destroyed (as part of the tab being
         // closed), make sure we clear the blocked requests.
         RenderViewHost* rvh = Source<RenderViewHost>(source).ptr();
         DCHECK(rvh->process()->id() == original_child_id_ &&
                rvh->routing_id() == original_rvh_id_);
         TakeActionOnResourceDispatcher(CANCEL);
       }
       break;
-    case NotificationType::TAB_CONTENTS_DESTROYED:
-    case NotificationType::NAV_ENTRY_COMMITTED:
+    case content::NOTIFICATION_TAB_CONTENTS_DESTROYED:
+    case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
       if (action_taken_ == NO_ACTION) {
         // We are navigating away from the interstitial or closing a tab with an
         // interstitial.  Default to DontProceed(). We don't just call Hide as
         // subclasses will almost certainly override DontProceed to do some work
         // (ex: close pending connections).
         DontProceed();
       } else {
         // User decided to proceed and either the navigation was committed or
         // the tab was closed before that.
         Hide();
@@ skipping 38 matching lines @@
 
   // The RenderViewHost has loaded its contents, we can show it now.
   render_view_host_->view()->Show();
   tab_->set_interstitial_page(this);
 
   // This notification hides the bookmark bar. Note that this has to happen
   // after the interstitial page was registered with |tab_|, since there will be
   // a callback to |tab_| testing if an interstitial page is showing before
   // hiding the bookmark bar.
   NotificationService::current()->Notify(
-      NotificationType::INTERSTITIAL_ATTACHED,
+      content::NOTIFICATION_INTERSTITIAL_ATTACHED,
       Source<TabContents>(tab_),
       NotificationService::NoDetails());
 
   RenderWidgetHostView* rwh_view = tab_->render_view_host()->view();
 
   // The RenderViewHost may already have crashed before we even get here.
   if (rwh_view) {
     // If the page has focus, focus the interstitial.
     if (rwh_view->HasFocus())
       Focus();
@@ skipping 352 matching lines @@
 
 void InterstitialPage::UpdateInspectorSetting(const std::string& key,
                                               const std::string& value) {
   RenderViewHostDelegateHelper::UpdateInspectorSetting(
       tab_->profile(), key, value);
 }
 
 void InterstitialPage::ClearInspectorSettings() {
   RenderViewHostDelegateHelper::ClearInspectorSettings(tab_->profile());
 }