Move Render(View|Widget)Host and associated classes to content namespace.

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 29 matching lines @@
 
 #if defined(TOOLKIT_GTK)
 #include "content/browser/renderer_host/backing_store_gtk.h"
 #elif defined(OS_MACOSX)
 #include "content/browser/renderer_host/backing_store_mac.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
-using content::RenderWidgetHostViewPort;
-using content::UserMetricsAction;
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebTextDirection;
 
+namespace {
+
 // How long to (synchronously) wait for the renderer to respond with a
 // PaintRect message, when our backing-store is invalid, before giving up and
 // returning a null or incorrectly sized backing-store from GetBackingStore.
 // This timeout impacts the "choppiness" of our window resize perf.
 static const int kPaintMsgTimeoutMS = 40;
 
 // How long to wait before we consider a renderer hung.
 static const int kHungRendererDelayMs = 20000;
 
-namespace {
-
 // Returns |true| if the two wheel events should be coalesced.
 bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
                                     const WebMouseWheelEvent& new_event) {
   return last_event.modifiers == new_event.modifiers &&
          last_event.scrollByPage == new_event.scrollByPage &&
          last_event.hasPreciseScrollingDeltas
              == new_event.hasPreciseScrollingDeltas &&
          last_event.phase == new_event.phase &&
          last_event.momentumPhase == new_event.momentumPhase;
 }
 
 }  // namespace
 
+namespace content {
+
 // static
 RenderWidgetHost* RenderWidgetHost::FromIPCChannelListener(
     IPC::Channel::Listener* listener) {
   return static_cast<RenderWidgetHost*>(
       static_cast<RenderWidgetHostImpl*>(listener));
 }
 
 // static
 const RenderWidgetHost* RenderWidgetHost::FromIPCChannelListener(
     const IPC::Channel::Listener* listener) {
   return static_cast<const RenderWidgetHost*>(
       static_cast<const RenderWidgetHostImpl*>(listener));
 }
 
 // static
 void RenderWidgetHost::RemoveAllBackingStores() {
   BackingStoreManager::RemoveAllBackingStores();
 }
 
 // static
 size_t RenderWidgetHost::BackingStoreMemorySize() {
   return BackingStoreManager::MemorySize();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostImpl
 
-RenderWidgetHostImpl::RenderWidgetHostImpl(content::RenderProcessHost* process,
+RenderWidgetHostImpl::RenderWidgetHostImpl(RenderProcessHost* process,
                                            int routing_id)
     : view_(NULL),
       renderer_initialized_(false),
       hung_renderer_delay_ms_(kHungRendererDelayMs),
       process_(process),
       routing_id_(routing_id),
       renderer_accessible_(false),
       surface_id_(0),
       is_loading_(false),
       is_hidden_(false),
@@ skipping 61 matching lines @@
   surface_id_ = 0;
 
   process_->Release(routing_id_);
 }
 
 // static
 RenderWidgetHostImpl* RenderWidgetHostImpl::From(RenderWidgetHost* rwh) {
   return rwh->AsRenderWidgetHostImpl();
 }
 
-void RenderWidgetHostImpl::SetView(content::RenderWidgetHostView* view) {
+void RenderWidgetHostImpl::SetView(RenderWidgetHostView* view) {
   view_ = RenderWidgetHostViewPort::FromRWHV(view);
 
   if (!view_) {
     GpuSurfaceTracker::Get()->SetSurfaceHandle(
         surface_id_, gfx::GLSurfaceHandle());
   }
 }
 
-content::RenderProcessHost* RenderWidgetHostImpl::GetProcess() const {
+RenderProcessHost* RenderWidgetHostImpl::GetProcess() const {
   return process_;
 }
 
 int RenderWidgetHostImpl::GetRoutingID() const {
   return routing_id_;
 }
 
-content::RenderWidgetHostView* RenderWidgetHostImpl::GetView() const {
+RenderWidgetHostView* RenderWidgetHostImpl::GetView() const {
   return view_;
 }
 
 RenderWidgetHostImpl* RenderWidgetHostImpl::AsRenderWidgetHostImpl() {
   return this;
 }
 
 bool RenderWidgetHostImpl::OnMessageReceivedForTesting(
     const IPC::Message& msg) {
   return OnMessageReceived(msg);
@@ skipping 96 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_CreatePluginContainer,
                         OnMsgCreatePluginContainer)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DestroyPluginContainer,
                         OnMsgDestroyPluginContainer)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   if (!msg_is_ok) {
     // The message de-serialization failed. Kill the renderer process.
-    content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH"));
+    RecordAction(UserMetricsAction("BadMessageTerminate_RWH"));
     GetProcess()->ReceivedBadMessage();
   }
   return handled;
 }
 
 bool RenderWidgetHostImpl::Send(IPC::Message* msg) {
   return process_->Send(msg);
 }
 
 void RenderWidgetHostImpl::WasHidden() {
   is_hidden_ = true;
 
   // Don't bother reporting hung state when we aren't the active tab.
   StopHangMonitorTimeout();
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   Send(new ViewMsg_WasHidden(routing_id_));
 
   // Tell the RenderProcessHost we were hidden.
   process_->WidgetHidden();
 
   bool is_visible = false;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHost>(this),
-      content::Details<bool>(&is_visible));
+  NotificationService::current()->Notify(
+      NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+      Source<RenderWidgetHost>(this),
+      Details<bool>(&is_visible));
 }
 
 void RenderWidgetHostImpl::WasRestored() {
   // When we create the widget, it is created as *not* hidden.
   if (!is_hidden_)
     return;
   is_hidden_ = false;
 
   BackingStore* backing_store = BackingStoreManager::Lookup(this);
   // If we already have a backing store for this widget, then we don't need to
   // repaint on restore _unless_ we know that our backing store is invalid.
   // When accelerated compositing is on, we must always repaint, even when
   // the backing store exists.
   bool needs_repainting;
   if (needs_repainting_on_restore_ || !backing_store ||
       is_accelerated_compositing_active()) {
     needs_repainting = true;
     needs_repainting_on_restore_ = false;
   } else {
     needs_repainting = false;
   }
   Send(new ViewMsg_WasRestored(routing_id_, needs_repainting));
 
   process_->WidgetRestored();
 
   bool is_visible = true;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHost>(this),
-      content::Details<bool>(&is_visible));
+  NotificationService::current()->Notify(
+      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
   //    is.
   // By invoking WasResized the renderer is updated as necessary. WasResized
@@ skipping 556 matching lines @@
 
 bool RenderWidgetHostImpl::IsFullscreen() const {
   return false;
 }
 
 void RenderWidgetHostImpl::SetShouldAutoResize(bool enable) {
   should_auto_resize_ = enable;
 }
 
 void RenderWidgetHostImpl::Destroy() {
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
-      content::Source<RenderWidgetHost>(this),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      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 RenderWidgetHostImpl::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!
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_RENDERER_PROCESS_HANG,
-      content::Source<RenderWidgetHost>(this),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      NOTIFICATION_RENDERER_PROCESS_HANG,
+      Source<RenderWidgetHost>(this),
+      NotificationService::NoDetails());
   is_unresponsive_ = true;
   NotifyRendererUnresponsive();
 }
 
 void RenderWidgetHostImpl::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 RenderWidgetHostImpl::OnMsgPaintAtSizeAck(int tag, const gfx::Size& size) {
   PaintAtSizeAckDetails details = {tag, size};
   gfx::Size size_details = size;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
-      content::Source<RenderWidgetHost>(this),
-      content::Details<PaintAtSizeAckDetails>(&details));
+  NotificationService::current()->Notify(
+      NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
+      Source<RenderWidgetHost>(this),
+      Details<PaintAtSizeAckDetails>(&details));
 }
 
 void RenderWidgetHostImpl::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnMsgUpdateRect");
   TimeTicks paint_start = TimeTicks::Now();
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
   // Update our knowledge of the RenderWidget's scroll offset.
@@ skipping 25 matching lines @@
     DCHECK(!params.bitmap_rect.IsEmpty());
     const size_t size = params.bitmap_rect.height() *
         params.bitmap_rect.width() * 4;
     TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
 
     // If gpu process does painting, scroll_rect and copy_rects are always empty
     // and backing store is never used.
     if (dib) {
       if (dib->size() < size) {
         DLOG(WARNING) << "Transport DIB too small for given rectangle";
-        content::RecordAction(
-            UserMetricsAction("BadMessageTerminate_RWH1"));
+        RecordAction(UserMetricsAction("BadMessageTerminate_RWH1"));
         GetProcess()->ReceivedBadMessage();
       } else {
         UNSHIPPED_TRACE_EVENT_INSTANT2("test_latency", "UpdateRect",
             "x+y", params.bitmap_rect.x() + params.bitmap_rect.y(),
             "color", 0xffffff & *static_cast<uint32*>(dib->memory()));
         UNSHIPPED_TRACE_EVENT_INSTANT1("test_latency", "UpdateRectWidth",
             "width", params.bitmap_rect.width());
 
         // Scroll the backing store.
         if (!params.scroll_rect.IsEmpty()) {
@@ skipping 64 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;
   }
 
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
-      content::Source<RenderWidgetHost>(this),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      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?
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
   if (is_resize_ack && view_) {
     gfx::Rect view_bounds = view_->GetViewBounds();
     if (current_size_ != view_bounds.size())
       WasResized();
   }
 
@@ skipping 20 matching lines @@
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_InputEventDelta", delta);
 
   // Cancel pending hung renderer checks since the renderer is responsive.
   if (--in_flight_event_count_ == 0)
     StopHangMonitorTimeout();
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
-    content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
+    RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
     process_->ReceivedBadMessage();
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_.get()) {
       DCHECK(next_mouse_move_->type == WebInputEvent::MouseMove);
       ForwardMouseEvent(*next_mouse_move_);
     }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     ProcessKeyboardEventAck(type, processed);
   } else if (type == WebInputEvent::MouseWheel) {
     ProcessWheelAck(processed);
   } else if (WebInputEvent::isTouchEventType(type)) {
     ProcessTouchAck(event_type, processed);
   }
 
   // This is used only for testing, and the other end does not use the
   // source object.  On linux, specifying
-  // content::Source<RenderWidgetHost> results in a very strange
+  // Source<RenderWidgetHost> results in a very strange
   // runtime error in the epilogue of the enclosing
   // (OnMsgInputEventAck) method, but not on other platforms; using
-  // 'void' instead is just as safe (since content::NotificationSource
+  // 'void' instead is just as safe (since NotificationSource
   // is not actually typesafe) and avoids this error.
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
-      content::Source<void>(this),
-      content::Details<int>(&type));
+  NotificationService::current()->Notify(
+      NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
+      Source<void>(this),
+      Details<int>(&type));
 }
 
 void RenderWidgetHostImpl::ProcessWheelAck(bool processed) {
   mouse_wheel_pending_ = false;
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
     WebMouseWheelEvent next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     ForwardWheelEvent(next_wheel_event);
   }
 
   if (!processed && !is_hidden_ && view_)
     view_->UnhandledWheelEvent(current_wheel_event_);
 }
 
 void RenderWidgetHostImpl::ProcessTouchAck(
     WebInputEvent::Type type, bool processed) {
   if (view_)
     view_->ProcessTouchAck(type, processed);
 }
 
 void RenderWidgetHostImpl::OnMsgFocus() {
   // Only RenderViewHost can deal with that message.
-  content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH4"));
+  RecordAction(UserMetricsAction("BadMessageTerminate_RWH4"));
   GetProcess()->ReceivedBadMessage();
 }
 
 void RenderWidgetHostImpl::OnMsgBlur() {
   // Only RenderViewHost can deal with that message.
-  content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH5"));
+  RecordAction(UserMetricsAction("BadMessageTerminate_RWH5"));
   GetProcess()->ReceivedBadMessage();
 }
 
 void RenderWidgetHostImpl::OnMsgDidChangeNumTouchEvents(int count) {
   has_touch_handler_ = count > 0;
 }
 
 void RenderWidgetHostImpl::OnMsgSetCursor(const WebCursor& cursor) {
   if (!view_) {
     return;
@@ skipping 245 matching lines @@
   Send(new ViewMsg_ScrollFocusedEditableNodeIntoRect(GetRoutingID(), rect));
 }
 
 void RenderWidgetHostImpl::SelectRange(const gfx::Point& start,
                                        const gfx::Point& end) {
   Send(new ViewMsg_SelectRange(GetRoutingID(), start, end));
 }
 
 void RenderWidgetHostImpl::Undo() {
   Send(new ViewMsg_Undo(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("Undo"));
+  RecordAction(UserMetricsAction("Undo"));
 }
 
 void RenderWidgetHostImpl::Redo() {
   Send(new ViewMsg_Redo(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("Redo"));
+  RecordAction(UserMetricsAction("Redo"));
 }
 
 void RenderWidgetHostImpl::Cut() {
   Send(new ViewMsg_Cut(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("Cut"));
+  RecordAction(UserMetricsAction("Cut"));
 }
 
 void RenderWidgetHostImpl::Copy() {
   Send(new ViewMsg_Copy(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("Copy"));
+  RecordAction(UserMetricsAction("Copy"));
 }
 
 void RenderWidgetHostImpl::CopyToFindPboard() {
 #if defined(OS_MACOSX)
   // Windows/Linux don't have the concept of a find pasteboard.
   Send(new ViewMsg_CopyToFindPboard(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("CopyToFindPboard"));
+  RecordAction(UserMetricsAction("CopyToFindPboard"));
 #endif
 }
 
 void RenderWidgetHostImpl::Paste() {
   Send(new ViewMsg_Paste(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("Paste"));
+  RecordAction(UserMetricsAction("Paste"));
 }
 
 void RenderWidgetHostImpl::PasteAndMatchStyle() {
   Send(new ViewMsg_PasteAndMatchStyle(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("PasteAndMatchStyle"));
+  RecordAction(UserMetricsAction("PasteAndMatchStyle"));
 }
 
 void RenderWidgetHostImpl::Delete() {
   Send(new ViewMsg_Delete(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("DeleteSelection"));
+  RecordAction(UserMetricsAction("DeleteSelection"));
 }
 
 void RenderWidgetHostImpl::SelectAll() {
   Send(new ViewMsg_SelectAll(GetRoutingID()));
-  content::RecordAction(UserMetricsAction("SelectAll"));
+  RecordAction(UserMetricsAction("SelectAll"));
 }
 bool RenderWidgetHostImpl::GotResponseToLockMouseRequest(bool allowed) {
   if (!allowed) {
     RejectMouseLockOrUnlockIfNecessary();
     return false;
   } else {
     if (!pending_mouse_lock_request_) {
       // This is possible, e.g., the plugin sends us an unlock request before
       // the user allows to lock to mouse.
       return false;
@@ skipping 18 matching lines @@
     ui_shim->Send(new AcceleratedSurfaceMsg_BuffersSwappedACK(route_id));
 }
 
 // static
 void RenderWidgetHostImpl::AcknowledgePostSubBuffer(int32 route_id,
                                                     int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_PostSubBufferACK(route_id));
 }
+
+}  // namespace content