Rename WebKit namespace to blink (part 3)

content/renderer/render_widget_fullscreen_pepper.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/renderer/render_widget_fullscreen_pepper.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/pepper/pepper_platform_context_3d.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebCanvas.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/platform/WebLayer.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/web/WebCursorInfo.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gl/gpu_preference.h"
 
-using WebKit::WebCanvas;
-using WebKit::WebCompositionUnderline;
-using WebKit::WebCursorInfo;
-using WebKit::WebGestureEvent;
-using WebKit::WebInputEvent;
-using WebKit::WebMouseEvent;
-using WebKit::WebMouseWheelEvent;
-using WebKit::WebPoint;
-using WebKit::WebRect;
-using WebKit::WebSize;
-using WebKit::WebString;
-using WebKit::WebTextDirection;
-using WebKit::WebTextInputType;
-using WebKit::WebVector;
-using WebKit::WebWidget;
-using WebKit::WGC3Dintptr;
+using blink::WebCanvas;
+using blink::WebCompositionUnderline;
+using blink::WebCursorInfo;
+using blink::WebGestureEvent;
+using blink::WebInputEvent;
+using blink::WebMouseEvent;
+using blink::WebMouseWheelEvent;
+using blink::WebPoint;
+using blink::WebRect;
+using blink::WebSize;
+using blink::WebString;
+using blink::WebTextDirection;
+using blink::WebTextInputType;
+using blink::WebVector;
+using blink::WebWidget;
+using blink::WGC3Dintptr;
 
 namespace content {
 
 namespace {
 
 class FullscreenMouseLockDispatcher : public MouseLockDispatcher {
  public:
   explicit FullscreenMouseLockDispatcher(RenderWidgetFullscreenPepper* widget);
   virtual ~FullscreenMouseLockDispatcher();
 
@@ skipping 246 matching lines @@
 
   virtual bool compositionRange(size_t* location, size_t* length) {
     return false;
   }
 
   virtual bool confirmComposition(const WebString& text) {
     return false;
   }
 
   virtual WebTextInputType textInputType() {
-    return WebKit::WebTextInputTypeNone;
+    return blink::WebTextInputTypeNone;
   }
 
   virtual WebRect caretOrSelectionBounds() {
     return WebRect();
   }
 
   virtual bool selectionRange(WebPoint& start, WebPoint& end) const {
     return false;
   }
 
@@ skipping 15 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PepperWidget);
 };
 
 }  // anonymous namespace
 
 // static
 RenderWidgetFullscreenPepper* RenderWidgetFullscreenPepper::Create(
     int32 opener_id,
     PepperPluginInstanceImpl* plugin,
     const GURL& active_url,
-    const WebKit::WebScreenInfo& screen_info) {
+    const blink::WebScreenInfo& screen_info) {
   DCHECK_NE(MSG_ROUTING_NONE, opener_id);
   scoped_refptr<RenderWidgetFullscreenPepper> widget(
       new RenderWidgetFullscreenPepper(plugin, active_url, screen_info));
   widget->Init(opener_id);
   widget->AddRef();
   return widget.get();
 }
 
 RenderWidgetFullscreenPepper::RenderWidgetFullscreenPepper(
     PepperPluginInstanceImpl* plugin,
     const GURL& active_url,
-    const WebKit::WebScreenInfo& screen_info)
+    const blink::WebScreenInfo& screen_info)
     : RenderWidgetFullscreen(screen_info),
       active_url_(active_url),
       plugin_(plugin),
       layer_(NULL),
       mouse_lock_dispatcher_(new FullscreenMouseLockDispatcher(
           this)) {
 }
 
 RenderWidgetFullscreenPepper::~RenderWidgetFullscreenPepper() {
 }
 
 void RenderWidgetFullscreenPepper::Invalidate() {
   InvalidateRect(gfx::Rect(size_.width(), size_.height()));
 }
 
-void RenderWidgetFullscreenPepper::InvalidateRect(const WebKit::WebRect& rect) {
+void RenderWidgetFullscreenPepper::InvalidateRect(const blink::WebRect& rect) {
   didInvalidateRect(rect);
 }
 
 void RenderWidgetFullscreenPepper::ScrollRect(
-    int dx, int dy, const WebKit::WebRect& rect) {
+    int dx, int dy, const blink::WebRect& rect) {
   didScrollRect(dx, dy, rect);
 }
 
 void RenderWidgetFullscreenPepper::Destroy() {
   // This function is called by the plugin instance as it's going away, so reset
   // plugin_ to NULL to avoid calling into a dangling pointer e.g. on Close().
   plugin_ = NULL;
 
   // After calling Destroy(), the plugin instance assumes that the layer is not
   // used by us anymore, so it may destroy the layer before this object goes
   // away.
   SetLayer(NULL);
 
   Send(new ViewHostMsg_Close(routing_id_));
   Release();
 }
 
 void RenderWidgetFullscreenPepper::DidChangeCursor(
-    const WebKit::WebCursorInfo& cursor) {
+    const blink::WebCursorInfo& cursor) {
   didChangeCursor(cursor);
 }
 
-void RenderWidgetFullscreenPepper::SetLayer(WebKit::WebLayer* layer) {
+void RenderWidgetFullscreenPepper::SetLayer(blink::WebLayer* layer) {
   layer_ = layer;
   bool compositing = !!layer_;
   if (compositing != is_accelerated_compositing_active_) {
     if (compositing) {
       if (!layerTreeView())
         initializeLayerTreeView();
       if (!layerTreeView())
         return;
-      layer_->setBounds(WebKit::WebSize(size()));
+      layer_->setBounds(blink::WebSize(size()));
       layer_->setDrawsContent(true);
       compositor_->setDeviceScaleFactor(device_scale_factor_);
       compositor_->setRootLayer(*layer_);
       didActivateCompositor(-1);
     } else {
       didDeactivateCompositor();
     }
   }
 }
 
@@ skipping 44 matching lines @@
   if (plugin_ && plugin_->GetBitmapForOptimizedPluginPaint(
           paint_bounds, dib, location, clip, scale_factor)) {
     return plugin_;
   }
   return NULL;
 }
 
 void RenderWidgetFullscreenPepper::OnResize(
     const ViewMsg_Resize_Params& params) {
   if (layer_)
-    layer_->setBounds(WebKit::WebSize(params.new_size));
+    layer_->setBounds(blink::WebSize(params.new_size));
   RenderWidget::OnResize(params);
 }
 
 WebWidget* RenderWidgetFullscreenPepper::CreateWebWidget() {
   return new PepperWidget(this);
 }
 
 GURL RenderWidgetFullscreenPepper::GetURLForGraphicsContext3D() {
   return active_url_;
 }
 
 void RenderWidgetFullscreenPepper::SetDeviceScaleFactor(
     float device_scale_factor) {
   RenderWidget::SetDeviceScaleFactor(device_scale_factor);
   if (compositor_)
     compositor_->setDeviceScaleFactor(device_scale_factor);
 }
 
 }  // namespace content