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

chrome/browser/prerender/prerender_contents.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/prerender/prerender_contents.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/process_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history_tab_helper.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_render_view_host_observer.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/download/download_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/icon_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_request_details.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/common/notification_service.h"
 #include "content/common/view_messages.h"
 #include "ui/gfx/rect.h"
@@ skipping 182 matching lines @@
   // Register this with the ResourceDispatcherHost as a prerender
   // RenderViewHost. This must be done before the Navigate message to catch all
   // resource requests, but as it is on the same thread as the Navigate message
   // (IO) there is no race condition.
   prerender_tracker_->OnPrerenderingStarted(
       child_id_,
       route_id_,
       prerender_manager_);
 
   // Close ourselves when the application is shutting down.
-  notification_registrar_.Add(this, NotificationType::APP_TERMINATING,
+  notification_registrar_.Add(this, content::NOTIFICATION_APP_TERMINATING,
                               NotificationService::AllSources());
 
   // Register for our parent profile to shutdown, so we can shut ourselves down
   // as well (should only be called for OTR profiles, as we should receive
   // APP_TERMINATING before non-OTR profiles are destroyed).
   // TODO(tburkard): figure out if this is needed.
-  notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
+  notification_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                               Source<Profile>(profile_));
 
   // Register to inform new RenderViews that we're prerendering.
   notification_registrar_.Add(
-      this, NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB,
+      this, content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
       Source<TabContents>(new_contents));
 
   // Register to be told when the RenderView is ready, so we can hide it.
   // It will automatically be set to visible when we resize it, otherwise.
-  notification_registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_TAB_CONTENTS_CONNECTED,
                               Source<TabContents>(new_contents));
 
   // Register for redirect notifications sourced from |this|.
   notification_registrar_.Add(
-      this, NotificationType::RESOURCE_RECEIVED_REDIRECT,
+      this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
       Source<RenderViewHostDelegate>(GetRenderViewHostDelegate()));
 
   // Register for new windows from any source.
-  notification_registrar_.Add(this,
-                              NotificationType::CREATING_NEW_WINDOW_CANCELLED,
-                              Source<TabContents>(new_contents));
+  notification_registrar_.Add(
+      this, content::NOTIFICATION_CREATING_NEW_WINDOW_CANCELLED,
+      Source<TabContents>(new_contents));
 
   DCHECK(load_start_time_.is_null());
   load_start_time_ = base::TimeTicks::Now();
 
   new_contents->controller().LoadURL(prerender_url_,
                                      referrer_, PageTransition::LINK);
 }
 
 bool PrerenderContents::GetChildId(int* child_id) const {
   CHECK(child_id);
@@ skipping 40 matching lines @@
 
   // If we still have a TabContents, clean up anything we need to and then
   // destroy it.
   if (prerender_contents_.get())
     delete ReleasePrerenderContents();
 
   // The following URLs are no longer rendering.
   prerender_tracker_->RemovePrerenderURLsOnUIThread(alias_urls_);
 }
 
-void PrerenderContents::Observe(NotificationType type,
+void PrerenderContents::Observe(int type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::PROFILE_DESTROYED:
+  switch (type) {
+    case chrome::NOTIFICATION_PROFILE_DESTROYED:
       Destroy(FINAL_STATUS_PROFILE_DESTROYED);
       return;
 
-    case NotificationType::APP_TERMINATING:
+    case content::NOTIFICATION_APP_TERMINATING:
       Destroy(FINAL_STATUS_APP_TERMINATING);
       return;
 
-    case NotificationType::RESOURCE_RECEIVED_REDIRECT: {
+    case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT: {
       // RESOURCE_RECEIVED_REDIRECT can come for any resource on a page.
       // If it's a redirect on the top-level resource, the name needs
       // to be remembered for future matching, and if it redirects to
       // an https resource, it needs to be canceled. If a subresource
       // is redirected, nothing changes.
       DCHECK(Source<RenderViewHostDelegate>(source).ptr() ==
              GetRenderViewHostDelegate());
       ResourceRedirectDetails* resource_redirect_details =
           Details<ResourceRedirectDetails>(details).ptr();
       CHECK(resource_redirect_details);
       if (resource_redirect_details->resource_type() ==
           ResourceType::MAIN_FRAME) {
         if (!AddAliasURL(resource_redirect_details->new_url()))
           return;
       }
       break;
     }
 
-    case NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB: {
+    case content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB: {
       if (prerender_contents_.get()) {
         DCHECK_EQ(Source<TabContents>(source).ptr(),
                   prerender_contents_->tab_contents());
 
         Details<RenderViewHost> new_render_view_host(details);
         OnRenderViewHostCreated(new_render_view_host.ptr());
 
         // When a new RenderView is created for a prerendering TabContents,
         // tell the new RenderView it's being used for prerendering before any
         // navigations occur.  Note that this is always triggered before the
         // first navigation, so there's no need to send the message just after
         // the TabContents is created.
         new_render_view_host->Send(
             new ViewMsg_SetIsPrerendering(new_render_view_host->routing_id(),
                                           true));
       }
       break;
     }
 
-    case NotificationType::TAB_CONTENTS_CONNECTED: {
+    case content::NOTIFICATION_TAB_CONTENTS_CONNECTED: {
       if (prerender_contents_.get()) {
         DCHECK_EQ(Source<TabContents>(source).ptr(),
                   prerender_contents_->tab_contents());
         // Set the new TabContents and its RenderViewHost as hidden, to reduce
         // resource usage.  This can only be done after the size has been sent
         // to the RenderView, which is why it's done here.
         prerender_contents_->tab_contents()->HideContents();
       }
       return;
     }
 
-    case NotificationType::CREATING_NEW_WINDOW_CANCELLED: {
+    case content::NOTIFICATION_CREATING_NEW_WINDOW_CANCELLED: {
       if (prerender_contents_.get()) {
         CHECK(Source<TabContents>(source).ptr() ==
               prerender_contents_->tab_contents());
         // Since we don't want to permit child windows that would have a
         // window.opener property, terminate prerendering.
         Destroy(FINAL_STATUS_CREATE_NEW_WINDOW);
       }
       break;
     }
 
@@ skipping 205 matching lines @@
     return NULL;
   DictionaryValue* dict_value = new DictionaryValue();
   dict_value->SetString("url", prerender_url_.spec());
   base::TimeTicks current_time = base::TimeTicks::Now();
   base::TimeDelta duration = current_time - load_start_time_;
   dict_value->SetInteger("duration", duration.InSeconds());
   return dict_value;
 }
 
 }  // namespace prerender