Move more files into the content namespace.

content/browser/renderer_host/render_widget_host_view_gtk.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_gtk.h"
 
 // If this gets included after the gtk headers, then a bunch of compiler
 // errors happen because of a "#define Status int" in Xlib.h, which interacts
 // badly with net::URLRequestStatus::Status.
 #include "content/common/view_messages.h"
@@ skipping 34 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/x11/WebScreenInfoFactory.h"
 #include "ui/base/gtk/gtk_compat.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #include "ui/gfx/gtk_preserve_window.h"
 #include "webkit/glue/webcursor_gtk_data.h"
 #include "webkit/plugins/npapi/webplugin.h"
 
+using WebKit::WebInputEventFactory;
+using WebKit::WebMouseWheelEvent;
+using WebKit::WebScreenInfo;
+
+namespace content {
 namespace {
 
 // Paint rects on Linux are bounded by the maximum size of a shared memory
 // region. By default that's 32MB, but many distros increase it significantly
 // (i.e. to 256MB).
 //
 // We fetch the maximum value from /proc/sys/kernel/shmmax at runtime and, if
 // we exceed that, then we limit the height of the paint rect in the renderer.
 //
 // These constants are here to ensure that, in the event that we exceed it, we
@@ skipping 32 matching lines @@
 }
 
 bool MovedToCenter(const WebKit::WebMouseEvent& mouse_event,
                    const gfx::Point& center) {
   return mouse_event.globalX == center.x() &&
          mouse_event.globalY == center.y();
 }
 
 }  // namespace
 
-using content::NativeWebKeyboardEvent;
-using content::RenderWidgetHostImpl;
-using content::RenderWidgetHostView;
-using content::RenderWidgetHostViewPort;
-using WebKit::WebInputEventFactory;
-using WebKit::WebMouseWheelEvent;
-
 // This class is a simple convenience wrapper for Gtk functions. It has only
 // static methods.
 class RenderWidgetHostViewGtkWidget {
  public:
   static AtkObject* GetAccessible(void* userdata) {
     return (static_cast<RenderWidgetHostViewGtk*>(userdata))->
         GetAccessible();
   }
 
   static GtkWidget* CreateNewWidget(RenderWidgetHostViewGtk* host_view) {
@@ skipping 436 matching lines @@
       web_event.deltaX += GetPendingScrollDelta(false, event->state);
     }
     RenderWidgetHostImpl::From(
         host_view->GetRenderWidgetHost())->ForwardWheelEvent(web_event);
     return FALSE;
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(RenderWidgetHostViewGtkWidget);
 };
 
-RenderWidgetHostViewGtk::RenderWidgetHostViewGtk(
-    content::RenderWidgetHost* widget_host)
+RenderWidgetHostViewGtk::RenderWidgetHostViewGtk(RenderWidgetHost* widget_host)
     : host_(RenderWidgetHostImpl::From(widget_host)),
       about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       parent_(NULL),
       is_popup_first_mouse_release_(true),
       was_imcontext_focused_before_grab_(false),
       do_x_grab_(false),
       is_fullscreen_(false),
       made_active_(false),
@@ skipping 104 matching lines @@
   } else {
     bounds = gfx::Rect(
         0, 0, gdk_screen_get_width(screen), gdk_screen_get_height(screen));
   }
   gtk_window_move(window, bounds.x(), bounds.y());
   gtk_window_resize(window, bounds.width(), bounds.height());
   gtk_window_fullscreen(window);
   DoPopupOrFullscreenInit(window, bounds);
 }
 
-content::RenderWidgetHost*
-RenderWidgetHostViewGtk::GetRenderWidgetHost() const {
+RenderWidgetHost* RenderWidgetHostViewGtk::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewGtk::WasRestored() {
   if (!is_hidden_)
     return;
 
   if (web_contents_switch_paint_time_.is_null())
     web_contents_switch_paint_time_ = base::TimeTicks::Now();
   is_hidden_ = false;
@@ skipping 233 matching lines @@
     gtk_widget_set_has_tooltip(view_.get(), FALSE);
   } else {
     gtk_widget_set_tooltip_text(view_.get(),
                                 UTF16ToUTF8(clamped_tooltip).c_str());
   }
 }
 
 void RenderWidgetHostViewGtk::SelectionChanged(const string16& text,
                                                size_t offset,
                                                const ui::Range& range) {
-  content::RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
+  RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 
   if (text.empty() || range.is_empty())
     return;
   size_t pos = range.GetMin() - offset;
   size_t n = range.length();
 
   DCHECK(pos + n <= text.length()) << "The text can not fully cover range.";
   if (pos >= text.length()) {
     NOTREACHED() << "The text can not cover range.";
     return;
@@ skipping 124 matching lines @@
 
 bool RenderWidgetHostViewGtk::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
   // TODO(jbates) Implement this so this view can use GetBackingStore for both
   // software and GPU frames. Defaulting to false just makes GetBackingStore
   // only useable for software frames.
   return false;
 }
 
 void RenderWidgetHostViewGtk::SetBackground(const SkBitmap& background) {
-  content::RenderWidgetHostViewBase::SetBackground(background);
+  RenderWidgetHostViewBase::SetBackground(background);
   host_->Send(new ViewMsg_SetBackground(host_->GetRoutingID(), background));
 }
 
 void RenderWidgetHostViewGtk::ModifyEventForEdgeDragging(
     GtkWidget* widget, GdkEventMotion* event) {
   // If the widget is aligned with an edge of the monitor its on and the user
   // attempts to drag past that edge we track the number of times it has
   // occurred, so that we can force the widget to scroll when it otherwise
   // would be unable to, by modifying the (x,y) position in the drag
   // event that we forward on to webkit. If we get a move that's no longer a
@@ skipping 149 matching lines @@
 }
 
 
 void RenderWidgetHostViewGtk::OnAcceleratedCompositingStateChange() {
   bool activated = host_->is_accelerated_compositing_active();
   GtkPreserveWindow* widget = reinterpret_cast<GtkPreserveWindow*>(view_.get());
 
   gtk_preserve_window_delegate_resize(widget, activated);
 }
 
-void RenderWidgetHostViewGtk::GetScreenInfo(WebKit::WebScreenInfo* results) {
+void RenderWidgetHostViewGtk::GetScreenInfo(WebScreenInfo* results) {
   GdkWindow* gdk_window = gtk_widget_get_window(view_.get());
   if (!gdk_window) {
     GdkDisplay* display = gdk_display_get_default();
     gdk_window = gdk_display_get_default_group(display);
   }
   if (!gdk_window)
     return;
-  content::GetScreenInfoFromNativeWindow(gdk_window, results);
+  GetScreenInfoFromNativeWindow(gdk_window, results);
 }
 
 gfx::Rect RenderWidgetHostViewGtk::GetRootWindowBounds() {
   GtkWidget* toplevel = gtk_widget_get_toplevel(view_.get());
   if (!toplevel)
     return gfx::Rect();
 
   GdkRectangle frame_extents;
   GdkWindow* gdk_window = gtk_widget_get_window(toplevel);
   if (!gdk_window)
@@ skipping 184 matching lines @@
     unlocked_mouse_position_.SetPoint(event->windowX, event->windowY);
     unlocked_global_mouse_position_.SetPoint(event->globalX, event->globalY);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
-    content::RenderWidgetHost* widget) {
+    RenderWidgetHost* widget) {
   return new RenderWidgetHostViewGtk(widget);
 }
 
 // static
-void content::RenderWidgetHostViewPort::GetDefaultScreenInfo(
-    WebKit::WebScreenInfo* results) {
+void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GdkWindow* gdk_window =
       gdk_display_get_default_group(gdk_display_get_default());
-  content::GetScreenInfoFromNativeWindow(gdk_window, results);
+  GetScreenInfoFromNativeWindow(gdk_window, results);
 }
 
 void RenderWidgetHostViewGtk::SetAccessibilityFocus(int acc_obj_id) {
   if (!host_)
     return;
 
   host_->AccessibilitySetFocus(acc_obj_id);
 }
 
 void RenderWidgetHostViewGtk::AccessibilityDoDefaultAction(int acc_obj_id) {
@@ skipping 27 matching lines @@
   host_->AccessibilitySetTextSelection(acc_obj_id, start_offset, end_offset);
 }
 
 void RenderWidgetHostViewGtk::OnAccessibilityNotifications(
     const std::vector<AccessibilityHostMsg_NotificationParams>& params) {
   if (!browser_accessibility_manager_.get()) {
     GtkWidget* parent = gtk_widget_get_parent(view_.get());
     browser_accessibility_manager_.reset(
         BrowserAccessibilityManager::CreateEmptyDocument(
             parent,
-            static_cast<content::AccessibilityNodeData::State>(0),
+            static_cast<AccessibilityNodeData::State>(0),
             this));
   }
   browser_accessibility_manager_->OnAccessibilityNotifications(params);
 }
 
 AtkObject* RenderWidgetHostViewGtk::GetAccessible() {
   if (!browser_accessibility_manager_.get()) {
     GtkWidget* parent = gtk_widget_get_parent(view_.get());
     browser_accessibility_manager_.reset(
         BrowserAccessibilityManager::CreateEmptyDocument(
             parent,
-            static_cast<content::AccessibilityNodeData::State>(0),
+            static_cast<AccessibilityNodeData::State>(0),
             this));
   }
   BrowserAccessibilityGtk* root =
       browser_accessibility_manager_->GetRoot()->ToBrowserAccessibilityGtk();
 
   atk_object_set_role(root->GetAtkObject(), ATK_ROLE_HTML_CONTAINER);
   return root->GetAtkObject();
 }
+
+}  // namespace content