Rename WebKit namespace to blink (part 3)

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"
 
 #include <cairo/cairo.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
@@ skipping 32 matching lines @@
 #include "third_party/WebKit/public/web/WebScreenInfo.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/gtk_compat.h"
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #include "ui/gfx/gtk_preserve_window.h"
 #include "ui/gfx/text_elider.h"
 #include "webkit/common/cursors/webcursor_gtk_data.h"
 
-using WebKit::WebMouseWheelEvent;
-using WebKit::WebScreenInfo;
+using blink::WebMouseWheelEvent;
+using blink::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.
@@ skipping 22 matching lines @@
     GdkPixmap* mask = gdk_bitmap_create_from_data(
         NULL, reinterpret_cast<const gchar*>(moz_spinning_mask_bits), 32, 32);
     moz_spinning_cursor =
         gdk_cursor_new_from_pixmap(source, mask, &fg, &bg, 2, 2);
     g_object_unref(source);
     g_object_unref(mask);
   }
   return moz_spinning_cursor;
 }
 
-bool MovedToPoint(const WebKit::WebMouseEvent& mouse_event,
+bool MovedToPoint(const blink::WebMouseEvent& mouse_event,
                    const gfx::Point& center) {
   return mouse_event.globalX == center.x() &&
          mouse_event.globalY == center.y();
 }
 
 }  // namespace
 
 // This class is a simple convenience wrapper for Gtk functions. It has only
 // static methods.
 class RenderWidgetHostViewGtkWidget {
@@ skipping 270 matching lines @@
     if (event_widget != widget) {
       int x = 0;
       int y = 0;
       gtk_widget_get_pointer(widget, &x, &y);
       event->x = x;
       event->y = y;
     }
 
     host_view->ModifyEventForEdgeDragging(widget, event);
 
-    WebKit::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event);
+    blink::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event);
 
     if (host_view->mouse_locked_) {
       gfx::Point center = host_view->GetWidgetCenter();
 
       bool moved_to_center = MovedToPoint(mouse_event, center);
       if (moved_to_center)
         host_view->mouse_has_been_warped_to_new_center_ = true;
 
       host_view->ModifyEventMovementAndCoords(&mouse_event);
 
@@ skipping 29 matching lines @@
         GDK_BUTTON3_MASK |
         GDK_BUTTON4_MASK |
         GDK_BUTTON5_MASK;
 
     // Only forward crossing events if the mouse button is not down.
     // (When the mouse button is down, the proper events are already being
     // sent by ButtonPressReleaseEvent and MouseMoveEvent, above, and if we
     // additionally send this crossing event with the state indicating the
     // button is down, it causes problems with drag and drop in WebKit.)
     if (!(event->state & any_button_mask)) {
-      WebKit::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event);
+      blink::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event);
       host_view->ModifyEventMovementAndCoords(&mouse_event);
       // When crossing out and back into a render view the movement values
       // must represent the instantaneous movement of the mouse, not the jump
       // from the exit to re-entry point.
       mouse_event.movementX = 0;
       mouse_event.movementY = 0;
       RenderWidgetHostImpl::From(
           host_view->GetRenderWidgetHost())->ForwardMouseEvent(mouse_event);
     }
 
@@ skipping 537 matching lines @@
 gfx::NativeView RenderWidgetHostViewGtk::BuildInputMethodsGtkMenu() {
   return im_context_->BuildInputMethodsGtkMenu();
 }
 
 void RenderWidgetHostViewGtk::OnDestroy(GtkWidget* widget) {
   DCHECK(is_fullscreen_);
   host_->Shutdown();
 }
 
 bool RenderWidgetHostViewGtk::NeedsInputGrab() {
-  return popup_type_ == WebKit::WebPopupTypeSelect;
+  return popup_type_ == blink::WebPopupTypeSelect;
 }
 
 bool RenderWidgetHostViewGtk::IsPopup() const {
-  return popup_type_ != WebKit::WebPopupTypeNone;
+  return popup_type_ != blink::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewGtk::DoSharedInit() {
   view_.Own(RenderWidgetHostViewGtkWidget::CreateNewWidget(this));
   im_context_.reset(new GtkIMContextWrapper(this));
   plugin_container_manager_.set_host_widget(view_.get());
   key_bindings_handler_.reset(new GtkKeyBindingsHandler(view_.get()));
 }
 
 void RenderWidgetHostViewGtk::DoPopupOrFullscreenInit(GtkWindow* window,
@@ skipping 432 matching lines @@
   gdk_window_get_origin(window, &window_x, &window_y);
   gint window_w = gdk_window_get_width(window);
   gint window_h = gdk_window_get_height(window);
   widget_center_.SetPoint(window_x + window_w / 2,
                           window_y + window_h / 2);
   widget_center_valid_ = true;
   return widget_center_;
 }
 
 void RenderWidgetHostViewGtk::ModifyEventMovementAndCoords(
-    WebKit::WebMouseEvent* event) {
+    blink::WebMouseEvent* event) {
   // Movement is computed by taking the difference of the new cursor position
   // and the previous. Under mouse lock the cursor will be warped back to the
   // center so that we are not limited by clipping boundaries.
   // We do not measure movement as the delta from cursor to center because
   // we may receive more mouse movement events before our warp has taken
   // effect.
   event->movementX = event->globalX - global_mouse_position_.x();
   event->movementY = event->globalY - global_mouse_position_.y();
 
   // While the cursor is being warped back to the unlocked position, suppress
@@ skipping 123 matching lines @@
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.CreatePluginContainer(id);
 }
 
 void RenderWidgetHostViewGtk::OnDestroyPluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.DestroyPluginContainer(id);
 }
 
 }  // namespace content