Move more files into the content namespace.

content/browser/renderer_host/render_widget_host_view_aura.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_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 30 matching lines @@
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
 
-using content::BrowserThread;
-using content::NativeWebKeyboardEvent;
-using content::RenderViewHost;
-using content::RenderViewHostDelegate;
-using content::RenderWidgetHost;
-using content::RenderWidgetHostImpl;
-using content::RenderWidgetHostView;
+using WebKit::WebScreenInfo;
 using WebKit::WebTouchEvent;
 
+namespace content {
 namespace {
 
 // In mouse lock mode, we need to prevent the (invisible) cursor from hitting
 // the border of the view, in order to get valid movement information. However,
 // forcing the cursor back to the center of the view after each mouse move
 // doesn't work well. It reduces the frequency of useful mouse move messages
 // significantly. Therefore, we move the cursor to the center of the view only
 // if it approaches the border. |kMouseLockBorderPercentage| specifies the width
 // of the border area, in percentage of the corresponding dimension.
 const int kMouseLockBorderPercentage = 15;
@@ skipping 39 matching lines @@
     case WM_NCXBUTTONUP:
     case WM_NCXBUTTONDBLCLK:
       return false;
     default:
       break;
   }
 #endif
   return true;
 }
 
-void GetScreenInfoForWindow(WebKit::WebScreenInfo* results,
-                            aura::Window* window) {
+void GetScreenInfoForWindow(WebScreenInfo* results, aura::Window* window) {
   const gfx::Display display = window ?
       gfx::Screen::GetDisplayNearestWindow(window) :
       gfx::Screen::GetPrimaryDisplay();
   const gfx::Size size = display.size();
   results->rect = WebKit::WebRect(0, 0, size.width(), size.height());
   results->availableRect = results->rect;
   // TODO(derat|oshima): Don't hardcode this. Get this from display object.
   results->depth = 24;
   results->depthPerComponent = 8;
   int default_dpi = display.device_scale_factor() * 160;
@@ skipping 324 matching lines @@
     return;
 
   std::map<uint64, scoped_refptr<ui::Texture> >::iterator it =
       image_transport_clients_.find(current_surface_);
   if (it == image_transport_clients_.end())
     return;
 
   ui::Texture* container = it->second;
   DCHECK(container);
 
-  gfx::Size size_in_pixel = content::ConvertSizeToPixel(this, size);
+  gfx::Size size_in_pixel = ConvertSizeToPixel(this, size);
   if (!output->initialize(
       size_in_pixel.width(), size_in_pixel.height(), true))
     return;
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-  content::GLHelper* gl_helper = factory->GetGLHelper(compositor);
+  GLHelper* gl_helper = factory->GetGLHelper(compositor);
   if (!gl_helper)
     return;
 
   unsigned char* addr = static_cast<unsigned char*>(
       output->getTopDevice()->accessBitmap(true).getPixels());
   scoped_callback_runner.Release();
   gl_helper->CopyTextureTo(container->texture_id(),
                            container->size(),
                            size_in_pixel,
                            addr,
@@ skipping 32 matching lines @@
     window_->SetExternalTexture(container);
 
     released_front_lock_ = NULL;
 
     if (!container) {
       resize_locks_.clear();
     } else {
       typedef std::vector<linked_ptr<ResizeLock> > ResizeLockList;
       ResizeLockList::iterator it = resize_locks_.begin();
       while (it != resize_locks_.end()) {
-        gfx::Size container_size = content::ConvertSizeToDIP(this,
+        gfx::Size container_size = ConvertSizeToDIP(this,
             container->size());
         if ((*it)->expected_size() == container_size)
           break;
         ++it;
       }
       if (it != resize_locks_.end()) {
         ++it;
         ui::Compositor* compositor = GetCompositor();
         if (compositor) {
           // Delay the release of the lock until we've kicked a frame with the
@@ skipping 26 matching lines @@
   UpdateExternalTexture();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface.
     // Must still send the ACK.
     InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, NULL);
   } else {
     gfx::Size surface_size_in_pixel =
         image_transport_clients_[params_in_pixel.surface_handle]->size();
-    gfx::Size surface_size = content::ConvertSizeToDIP(this,
+    gfx::Size surface_size = ConvertSizeToDIP(this,
                                                        surface_size_in_pixel);
     window_->SchedulePaintInRect(gfx::Rect(surface_size));
 
     if (!resize_locks_.empty()) {
       // If we are waiting for the resize, fast-track the ACK.
       if (compositor->IsThreaded()) {
         // We need the compositor thread to pick up the active buffer before
         // ACKing.
         on_compositing_did_commit_callbacks_.push_back(
             base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
@@ skipping 29 matching lines @@
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface
     // Must still send the ACK
     InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, NULL);
   } else {
     gfx::Size surface_size_in_pixel =
         image_transport_clients_[params_in_pixel.surface_handle]->size();
 
     // Co-ordinates come in OpenGL co-ordinate space.
     // We need to convert to layer space.
-    gfx::Rect rect_to_paint = content::ConvertRectToDIP(this, gfx::Rect(
+    gfx::Rect rect_to_paint = ConvertRectToDIP(this, gfx::Rect(
         params_in_pixel.x,
         surface_size_in_pixel.height() - params_in_pixel.y -
             params_in_pixel.height,
         params_in_pixel.width,
         params_in_pixel.height));
     window_->SchedulePaintInRect(rect_to_paint);
 
     if (!resize_locks_.empty()) {
       // If we are waiting for the resize, fast-track the ACK.
       if (compositor->IsThreaded()) {
@@ skipping 55 matching lines @@
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease(
     uint64 surface_handle) {
   if (current_surface_ == surface_handle) {
     current_surface_ = 0;
     UpdateExternalTexture();
   }
   image_transport_clients_.erase(surface_handle);
 }
 
 void RenderWidgetHostViewAura::SetBackground(const SkBitmap& background) {
-  content::RenderWidgetHostViewBase::SetBackground(background);
+  RenderWidgetHostViewBase::SetBackground(background);
   host_->SetBackground(background);
   window_->layer()->SetFillsBoundsOpaquely(background.isOpaque());
 }
 
-void RenderWidgetHostViewAura::GetScreenInfo(WebKit::WebScreenInfo* results) {
+void RenderWidgetHostViewAura::GetScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, window_);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetRootWindowBounds() {
   return window_->GetToplevelWindow()->bounds();
 }
 
 void RenderWidgetHostViewAura::ProcessTouchAck(
     WebKit::WebInputEvent::Type type, bool processed) {
   // The ACKs for the touch-events arrive in the same sequence as they were
@@ skipping 327 matching lines @@
 
 bool RenderWidgetHostViewAura::ShouldDescendIntoChildForEventHandling(
     aura::Window* child,
     const gfx::Point& location) {
   return true;
 }
 
 bool RenderWidgetHostViewAura::OnMouseEvent(aura::MouseEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnMouseEvent");
   if (mouse_locked_) {
-    WebKit::WebMouseEvent mouse_event = content::MakeWebMouseEvent(event);
+    WebKit::WebMouseEvent mouse_event = MakeWebMouseEvent(event);
     gfx::Point center(gfx::Rect(window_->bounds().size()).CenterPoint());
 
     bool is_move_to_center_event = (event->type() == ui::ET_MOUSE_MOVED ||
         event->type() == ui::ET_MOUSE_DRAGGED) &&
         mouse_event.x == center.x() && mouse_event.y == center.y();
 
     ModifyEventMovementAndCoords(&mouse_event);
 
     bool should_not_forward = is_move_to_center_event && synthetic_move_sent_;
     if (should_not_forward) {
       synthetic_move_sent_ = false;
     } else {
       // Check if the mouse has reached the border and needs to be centered.
       if (ShouldMoveToCenter()) {
         synthetic_move_sent_ = true;
         window_->MoveCursorTo(center);
       }
 
       // Forward event to renderer.
       if (CanRendererHandleEvent(event))
         host_->ForwardMouseEvent(mouse_event);
     }
 
     return false;
   }
 
   if (event->type() == ui::ET_MOUSEWHEEL) {
     WebKit::WebMouseWheelEvent mouse_wheel_event =
-        content::MakeWebMouseWheelEvent(event);
+        MakeWebMouseWheelEvent(event);
     if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0)
       host_->ForwardWheelEvent(mouse_wheel_event);
   } else if (event->type() == ui::ET_SCROLL) {
     WebKit::WebGestureEvent gesture_event =
-        content::MakeWebGestureEventFlingCancel();
+        MakeWebGestureEventFlingCancel();
     host_->ForwardGestureEvent(gesture_event);
     WebKit::WebMouseWheelEvent mouse_wheel_event =
-        content::MakeWebMouseWheelEvent(static_cast<aura::ScrollEvent*>(event));
+        MakeWebMouseWheelEvent(static_cast<aura::ScrollEvent*>(event));
     host_->ForwardWheelEvent(mouse_wheel_event);
-    content::RecordAction(content::UserMetricsAction("TrackpadScroll"));
+    RecordAction(UserMetricsAction("TrackpadScroll"));
   } else if (event->type() == ui::ET_SCROLL_FLING_START ||
       event->type() == ui::ET_SCROLL_FLING_CANCEL) {
     WebKit::WebGestureEvent gesture_event =
-        content::MakeWebGestureEvent(static_cast<aura::ScrollEvent*>(event));
+        MakeWebGestureEvent(static_cast<aura::ScrollEvent*>(event));
     host_->ForwardGestureEvent(gesture_event);
     if (event->type() == ui::ET_SCROLL_FLING_START)
-      content::RecordAction(content::UserMetricsAction("TrackpadScrollFling"));
+      RecordAction(UserMetricsAction("TrackpadScrollFling"));
   } else if (CanRendererHandleEvent(event)) {
-    WebKit::WebMouseEvent mouse_event = content::MakeWebMouseEvent(event);
+    WebKit::WebMouseEvent mouse_event = MakeWebMouseEvent(event);
     ModifyEventMovementAndCoords(&mouse_event);
     host_->ForwardMouseEvent(mouse_event);
   }
 
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
       window_->SetCapture();
       // Confirm existing composition text on mouse click events, to make sure
       // the input caret won't be moved with an ongoing composition text.
       FinishImeCompositionSession();
@@ skipping 11 matching lines @@
     window_->parent()->delegate()->OnMouseEvent(event);
 
   // Return true so that we receive released/drag events.
   return true;
 }
 
 ui::TouchStatus RenderWidgetHostViewAura::OnTouchEvent(
     aura::TouchEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnTouchEvent");
   // Update the touch event first.
-  WebKit::WebTouchPoint* point = content::UpdateWebTouchEvent(event,
+  WebKit::WebTouchPoint* point = UpdateWebTouchEvent(event,
       &touch_event_);
 
   // Forward the touch event only if a touch point was updated, and there's a
   // touch-event handler in the page.
   if (point && host_->has_touch_handler()) {
     host_->ForwardTouchEvent(touch_event_);
     UpdateWebTouchEventAfterDispatch(&touch_event_, point);
     return DecideTouchStatus(touch_event_, point);
   }
 
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
 ui::GestureStatus RenderWidgetHostViewAura::OnGestureEvent(
     aura::GestureEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnGestureEvent");
   // Pinch gestures are currently disabled by default. See crbug.com/128477.
   if ((event->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       event->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       event->type() == ui::ET_GESTURE_PINCH_END) && !ShouldSendPinchGesture()) {
     return ui::GESTURE_STATUS_CONSUMED;
   }
 
   RenderViewHostDelegate* delegate = RenderViewHost::From(host_)->GetDelegate();
   if (event->type() == ui::ET_GESTURE_BEGIN &&
       event->details().touch_points() == 1) {
     delegate->HandleGestureBegin();
   }
 
-  WebKit::WebGestureEvent gesture = content::MakeWebGestureEvent(event);
+  WebKit::WebGestureEvent gesture = MakeWebGestureEvent(event);
   if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
     // Webkit does not stop a fling-scroll on tap-down. So explicitly send an
     // event to stop any in-progress flings.
     WebKit::WebGestureEvent fling_cancel = gesture;
     fling_cancel.type = WebKit::WebInputEvent::GestureFlingCancel;
     host_->ForwardGestureEvent(fling_cancel);
   }
 
   if (gesture.type != WebKit::WebInputEvent::Undefined) {
     host_->ForwardGestureEvent(gesture);
 
     if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
         event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
         event->type() == ui::ET_GESTURE_SCROLL_END) {
-      content::RecordAction(content::UserMetricsAction("TouchscreenScroll"));
+      RecordAction(UserMetricsAction("TouchscreenScroll"));
     } else if (event->type() == ui::ET_SCROLL_FLING_START) {
-      content::RecordAction(
-          content::UserMetricsAction("TouchscreenScrollFling"));
+      RecordAction(UserMetricsAction("TouchscreenScrollFling"));
     }
   }
 
   if (event->type() == ui::ET_GESTURE_END &&
       event->details().touch_points() == 1) {
     delegate->HandleGestureEnd();
   }
 
   // If a gesture is not processed by the webpage, then WebKit processes it
   // (e.g. generates synthetic mouse events). So CONSUMED should be returned
@@ skipping 303 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
-void content::RenderWidgetHostViewPort::GetDefaultScreenInfo(
-    WebKit::WebScreenInfo* results) {
+void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
+
+}  // namespace content