Make NotificationService an interface in the content namespace, and switch callers to use it. Mov...

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"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_state.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_manager.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/gpu/gpu_messages.h"
-#include "content/common/notification_service.h"
+#include "content/public/browser/notification_service.h"
 #include "content/common/result_codes.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/plugins/npapi/webplugin.h"
@@ skipping 223 matching lines @@
 
   GpuProcessHost::SendOnIO(
       0,
       content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
       new GpuMsg_VisibilityChanged(routing_id_, process()->id(), false));
 
   // Tell the RenderProcessHost we were hidden.
   process_->WidgetHidden();
 
   bool is_visible = false;
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       content::Source<RenderWidgetHost>(this),
       content::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 @@
   Send(new ViewMsg_WasRestored(routing_id_, needs_repainting));
 
   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(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       content::Source<RenderWidgetHost>(this),
       content::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
@@ skipping 512 matching lines @@
 
 bool RenderWidgetHost::IsMouseLocked() const {
   return view_ ? view_->mouse_locked() : false;
 }
 
 bool RenderWidgetHost::IsFullscreen() const {
   return false;
 }
 
 void RenderWidgetHost::Destroy() {
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
       content::Source<RenderWidgetHost>(this),
-      NotificationService::NoDetails());
+      content::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(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDERER_PROCESS_HANG,
       content::Source<RenderWidgetHost>(this),
-      NotificationService::NoDetails());
+      content::NotificationService::NoDetails());
   is_unresponsive_ = true;
   NotifyRendererUnresponsive();
 }
 
 void RenderWidgetHost::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
     NotifyRendererResponsive();
   }
 }
@@ skipping 49 matching lines @@
   // Note that we ignore the position.
   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(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
       content::Source<RenderWidgetHost>(this),
       content::Details<PaintAtSizeAckDetails>(&details));
 }
 
 void RenderWidgetHost::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::OnMsgUpdateRect");
   TimeTicks paint_start = TimeTicks::Now();
 
@@ skipping 83 matching lines @@
     return;
 
   // Now paint the view. Watch out: it might be destroyed already.
   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(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
       content::Source<RenderWidgetHost>(this),
-      NotificationService::NoDetails());
+      content::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();
   }
 
   // Log the time delta for processing a paint message.
   TimeDelta delta = TimeTicks::Now() - paint_start;
@@ skipping 28 matching lines @@
   } else if (type == WebInputEvent::MouseWheel) {
     ProcessWheelAck(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(
+  content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
       content::Source<RenderWidgetHost>(this),
       content::Details<int>(&type));
 }
 
 void RenderWidgetHost::ProcessWheelAck(bool processed) {
   mouse_wheel_pending_ = false;
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
@@ skipping 319 matching lines @@
     pending_mouse_lock_request_ = false;
     if (!view_ || !view_->HasFocus()|| !view_->LockMouse()) {
       Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
       return false;
     } else {
       Send(new ViewMsg_LockMouse_ACK(routing_id_, true));
       return true;
     }
   }
 }