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

content/browser/renderer_host/render_widget_host.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/renderer_host/render_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
@@ skipping 231 matching lines @@
   // TODO(darin): what about constrained windows?  it doesn't look like they
   // see a message when their parent is hidden.  maybe there is something more
   // generic we can do at the TabContents API level instead of relying on
   // Windows messages.
 
   // Tell the RenderProcessHost we were hidden.
   process_->WidgetHidden();
 
   bool is_visible = false;
   NotificationService::current()->Notify(
-      NotificationType::RENDER_WIDGET_VISIBILITY_CHANGED,
+      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       Source<RenderWidgetHost>(this),
       Details<bool>(&is_visible));
 }
 
 void RenderWidgetHost::WasRestored() {
   // When we create the widget, it is created as *not* hidden.
   if (!is_hidden_)
     return;
   is_hidden_ = false;
 
@@ skipping 14 matching lines @@
 
   GpuProcessHost::SendOnIO(
       0,
       content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
       new GpuMsg_VisibilityChanged(routing_id_, process()->id(), true));
 
   process_->WidgetRestored();
 
   bool is_visible = true;
   NotificationService::current()->Notify(
-      NotificationType::RENDER_WIDGET_VISIBILITY_CHANGED,
+      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       Source<RenderWidgetHost>(this),
       Details<bool>(&is_visible));
 
   // It's possible for our size to be out of sync with the renderer. The
   // following is one case that leads to this:
   // 1. WasResized -> Send ViewMsg_Resize to render
   // 2. WasResized -> do nothing as resize_ack_pending_ is true
   // 3. WasHidden
   // 4. OnMsgUpdateRect from (1) processed. Does NOT invoke WasResized as view
   //    is hidden. Now renderer/browser out of sync with what they think size
@@ skipping 452 matching lines @@
   Send(new ViewMsg_ImeConfirmComposition(routing_id(), string16()));
 }
 
 void RenderWidgetHost::ImeCancelComposition() {
   Send(new ViewMsg_ImeSetComposition(routing_id(), string16(),
             std::vector<WebKit::WebCompositionUnderline>(), 0, 0));
 }
 
 void RenderWidgetHost::Destroy() {
   NotificationService::current()->Notify(
-      NotificationType::RENDER_WIDGET_HOST_DESTROYED,
+      content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
 
   // Tell the view to die.
   // Note that in the process of the view shutting down, it can call a ton
   // of other messages on us.  So if you do any other deinitialization here,
   // do it after this call to view_->Destroy().
   if (view_)
     view_->Destroy();
 
   delete this;
 }
 
 void RenderWidgetHost::CheckRendererIsUnresponsive() {
   // If we received a call to StopHangMonitorTimeout.
   if (time_when_considered_hung_.is_null())
     return;
 
   // If we have not waited long enough, then wait some more.
   Time now = Time::Now();
   if (now < time_when_considered_hung_) {
     StartHangMonitorTimeout(time_when_considered_hung_ - now);
     return;
   }
 
   // OK, looks like we have a hung renderer!
   NotificationService::current()->Notify(
-      NotificationType::RENDERER_PROCESS_HANG,
+      content::NOTIFICATION_RENDERER_PROCESS_HANG,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
   is_unresponsive_ = true;
   NotifyRendererUnresponsive();
 }
 
 void RenderWidgetHost::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
     NotifyRendererResponsive();
@@ skipping 52 matching lines @@
   if (view_) {
     view_->SetBounds(pos);
     Send(new ViewMsg_Move_ACK(routing_id_));
   }
 }
 
 void RenderWidgetHost::OnMsgPaintAtSizeAck(int tag, const gfx::Size& size) {
   PaintAtSizeAckDetails details = {tag, size};
   gfx::Size size_details = size;
   NotificationService::current()->Notify(
-      NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
+      content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
       Source<RenderWidgetHost>(this),
       Details<PaintAtSizeAckDetails>(&details));
 }
 
 void RenderWidgetHost::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::OnMsgUpdateRect");
   TimeTicks paint_start = TimeTicks::Now();
 
   NotificationService::current()->Notify(
-      NotificationType::RENDER_WIDGET_HOST_WILL_PAINT,
+      content::NOTIFICATION_RENDER_WIDGET_HOST_WILL_PAINT,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
   // Update our knowledge of the RenderWidget's scroll offset.
   last_scroll_offset_ = params.scroll_offset;
 
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
@@ skipping 76 matching lines @@
     // destroyed.
     if (view_ && !is_accelerated_compositing_active_) {
       view_being_painted_ = true;
       view_->DidUpdateBackingStore(params.scroll_rect, params.dx, params.dy,
                                    params.copy_rects);
       view_being_painted_ = false;
     }
   }
 
   NotificationService::current()->Notify(
-      NotificationType::RENDER_WIDGET_HOST_DID_PAINT,
+      content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
 
   // If we got a resize ack, then perhaps we have another resize to send?
   if (is_resize_ack && view_) {
     // WasResized checks the current size and sends the resize update only
     // when something was actually changed.
     WasResized();
   }
 
@@ skipping 37 matching lines @@
     ProcessKeyboardEventAck(type, processed);
   } else if (type == WebInputEvent::TouchMove) {
     touch_move_pending_ = false;
     if (touch_event_is_queued_) {
       touch_event_is_queued_ = false;
       ForwardTouchEvent(queued_touch_event_);
     }
   }
   // This is used only for testing.
   NotificationService::current()->Notify(
-      NotificationType::RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
+      content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
       Source<RenderWidgetHost>(this),
       Details<int>(&type));
 }
 
 void RenderWidgetHost::ProcessWheelAck() {
   mouse_wheel_pending_ = false;
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
     WebMouseWheelEvent next_wheel_event =
@@ skipping 169 matching lines @@
     view_->CreatePluginContainer(deferred_plugin_handles_[i]);
 #endif
   }
 
   deferred_plugin_handles_.clear();
 }
 
 void RenderWidgetHost::StartUserGesture() {
   OnUserGesture();
 }