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

chrome/browser/tab_contents/thumbnail_generator.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/tab_contents/thumbnail_generator.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 128 matching lines @@
 }
 
 void ThumbnailGenerator::StartThumbnailing(TabContents* tab_contents) {
   TabContentsObserver::Observe(tab_contents);
 
   if (registrar_.IsEmpty()) {
     // Even though we deal in RenderWidgetHosts, we only care about its
     // subclass, RenderViewHost when it is in a tab. We don't make thumbnails
     // for RenderViewHosts that aren't in tabs, or RenderWidgetHosts that
     // aren't views like select popups.
-    registrar_.Add(this, NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB,
+    registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
                    Source<TabContents>(tab_contents));
-    registrar_.Add(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
+    registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
                    Source<TabContents>(tab_contents));
   }
 }
 
 void ThumbnailGenerator::MonitorRenderer(RenderWidgetHost* renderer,
                                          bool monitor) {
   Source<RenderWidgetHost> renderer_source = Source<RenderWidgetHost>(renderer);
   bool currently_monitored =
       registrar_.IsRegistered(
         this,
-        NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
+        content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
         renderer_source);
   if (monitor != currently_monitored) {
     if (monitor) {
       registrar_.Add(
           this,
-          NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
+          content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
           renderer_source);
       registrar_.Add(
           this,
-          NotificationType::RENDER_WIDGET_VISIBILITY_CHANGED,
+          content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
           renderer_source);
     } else {
       registrar_.Remove(
           this,
-          NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
+          content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
           renderer_source);
       registrar_.Remove(
           this,
-          NotificationType::RENDER_WIDGET_VISIBILITY_CHANGED,
+          content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
           renderer_source);
     }
   }
 }
 
 void ThumbnailGenerator::AskForSnapshot(RenderWidgetHost* renderer,
                                         bool prefer_backing_store,
                                         ThumbnailReadyCallback* callback,
                                         gfx::Size page_size,
                                         gfx::Size desired_size) {
@@ skipping 108 matching lines @@
     // TODO: Figure out a way to avoid this copy?
     non_owned_bitmap.copyTo(&result, SkBitmap::kARGB_8888_Config);
 
     item->second->callback->Run(result);
 
     // We're done with the callback, and with the DIB, so delete both.
     callback_map_.erase(item);
   }
 }
 
-void ThumbnailGenerator::Observe(NotificationType type,
+void ThumbnailGenerator::Observe(int type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB: {
+  switch (type) {
+    case content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB: {
       // Install our observer for all new RVHs.
       RenderViewHost* renderer = Details<RenderViewHost>(details).ptr();
       MonitorRenderer(renderer, true);
       break;
     }
 
-    case NotificationType::RENDER_WIDGET_VISIBILITY_CHANGED:
+    case content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED:
       if (!*Details<bool>(details).ptr())
         WidgetHidden(Source<RenderWidgetHost>(source).ptr());
       break;
 
-    case NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK: {
+    case content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK: {
       RenderWidgetHost::PaintAtSizeAckDetails* size_ack_details =
           Details<RenderWidgetHost::PaintAtSizeAckDetails>(details).ptr();
       WidgetDidReceivePaintAtSizeAck(
           Source<RenderWidgetHost>(source).ptr(),
           size_ack_details->tag,
           size_ack_details->size);
       break;
     }
 
-    case NotificationType::TAB_CONTENTS_DISCONNECTED:
+    case content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED:
       TabContentsDisconnected(Source<TabContents>(source).ptr());
       break;
 
     default:
-      NOTREACHED() << "Unexpected notification type: " << type.value;
+      NOTREACHED() << "Unexpected notification type: " << type;
   }
 }
 
 void ThumbnailGenerator::WidgetHidden(RenderWidgetHost* widget) {
   // tab_contents_ can be NULL, if StartThumbnailing() is not called, but
   // MonitorRenderer() is called. The use case is found in
   // chrome/test/ui_test_utils.cc.
   if (!tab_contents())
     return;
   UpdateThumbnailIfNecessary(tab_contents());
@@ skipping 137 matching lines @@
 
 void ThumbnailGenerator::DidStartLoading() {
   load_interrupted_ = false;
 }
 
 void ThumbnailGenerator::StopNavigation() {
   // This function gets called when the page loading is interrupted by the
   // stop button.
   load_interrupted_ = true;
 }