Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/render_widget_host_view_android.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_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 196 matching lines @@
 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
   // Ignore the given size as only the Java code has the power to
   // resize the view on Android.
   WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   SetSize(rect.size());
 }
 
-WebKit::WebGLId RenderWidgetHostViewAndroid::GetScaledContentTexture(
+blink::WebGLId RenderWidgetHostViewAndroid::GetScaledContentTexture(
     float scale,
     gfx::Size* out_size) {
   gfx::Size size(gfx::ToCeiledSize(
       gfx::ScaleSize(texture_size_in_layer_, scale)));
 
   if (!CompositorImpl::IsInitialized() ||
       texture_id_in_layer_ == 0 ||
       texture_size_in_layer_.IsEmpty() ||
       size.IsEmpty()) {
     if (out_size)
@@ skipping 19 matching lines @@
       texture_size_in_layer_.IsEmpty())
     return false;
 
   gfx::JavaBitmap bitmap(jbitmap);
 
   // TODO(dtrainor): Eventually add support for multiple formats here.
   DCHECK(bitmap.format() == ANDROID_BITMAP_FORMAT_RGBA_8888);
 
   GLHelper* helper = ImageTransportFactoryAndroid::GetInstance()->GetGLHelper();
 
-  WebKit::WebGLId texture = helper->CopyAndScaleTexture(
+  blink::WebGLId texture = helper->CopyAndScaleTexture(
       texture_id_in_layer_,
       texture_size_in_layer_,
       bitmap.size(),
       true,
       GLHelper::SCALER_QUALITY_FAST);
   if (texture == 0)
     return false;
 
   helper->ReadbackTextureSync(texture,
                               gfx::Rect(bitmap.size()),
                               static_cast<unsigned char*> (bitmap.pixels()));
 
-  WebKit::WebGraphicsContext3D* context =
+  blink::WebGraphicsContext3D* context =
       ImageTransportFactoryAndroid::GetInstance()->GetContext3D();
   context->deleteTexture(texture);
 
   return true;
 }
 
 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
   if (!content_view_core_)
     return false;
   if (texture_size_in_layer_.IsEmpty())
@@ skipping 665 matching lines @@
   if (delegated_renderer_layer_.get())
     DestroyDelegatedContent();
 }
 
 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   NOTREACHED();
   return false;
 }
 
-void RenderWidgetHostViewAndroid::GetScreenInfo(WebKit::WebScreenInfo* result) {
+void RenderWidgetHostViewAndroid::GetScreenInfo(blink::WebScreenInfo* result) {
   // ScreenInfo isn't tied to the widget on Android. Always return the default.
   RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
 }
 
 // TODO(jrg): Find out the implications and answer correctly here,
 // as we are returning the WebView and not root window bounds.
 gfx::Rect RenderWidgetHostViewAndroid::GetBoundsInRootWindow() {
   return GetViewBounds();
 }
 
@@ skipping 11 matching lines @@
     bool has_horizontal_scrollbar) {
   // intentionally empty, like RenderWidgetHostViewViews
 }
 
 void RenderWidgetHostViewAndroid::SetScrollOffsetPinning(
     bool is_pinned_to_left, bool is_pinned_to_right) {
   // intentionally empty, like RenderWidgetHostViewViews
 }
 
 void RenderWidgetHostViewAndroid::UnhandledWheelEvent(
-    const WebKit::WebMouseWheelEvent& event) {
+    const blink::WebMouseWheelEvent& event) {
   // intentionally empty, like RenderWidgetHostViewViews
 }
 
 void RenderWidgetHostViewAndroid::GestureEventAck(
     int gesture_event_type,
     InputEventAckState ack_result) {
-  if (gesture_event_type == WebKit::WebInputEvent::GestureScrollUpdate &&
+  if (gesture_event_type == blink::WebInputEvent::GestureScrollUpdate &&
       ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) {
     content_view_core_->OnScrollUpdateGestureConsumed();
   }
-  if (gesture_event_type == WebKit::WebInputEvent::GestureFlingStart &&
+  if (gesture_event_type == blink::WebInputEvent::GestureFlingStart &&
       ack_result == INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS) {
     content_view_core_->UnhandledFlingStartEvent();
   }
 }
 
 InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent(
-    const WebKit::WebInputEvent& input_event) {
+    const blink::WebInputEvent& input_event) {
   if (host_) {
     SynchronousCompositorImpl* compositor =
         SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
                                           host_->GetRoutingID());
     if (compositor)
       return compositor->HandleInputEvent(input_event);
   }
   return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
 }
 
@@ skipping 84 matching lines @@
 
 // Methods called from the host to the render
 
 void RenderWidgetHostViewAndroid::SendKeyEvent(
     const NativeWebKeyboardEvent& event) {
   if (host_)
     host_->ForwardKeyboardEvent(event);
 }
 
 void RenderWidgetHostViewAndroid::SendTouchEvent(
-    const WebKit::WebTouchEvent& event) {
+    const blink::WebTouchEvent& event) {
   if (host_)
     host_->ForwardTouchEventWithLatencyInfo(event, ui::LatencyInfo());
 }
 
 
 void RenderWidgetHostViewAndroid::SendMouseEvent(
-    const WebKit::WebMouseEvent& event) {
+    const blink::WebMouseEvent& event) {
   if (host_)
     host_->ForwardMouseEvent(event);
 }
 
 void RenderWidgetHostViewAndroid::SendMouseWheelEvent(
-    const WebKit::WebMouseWheelEvent& event) {
+    const blink::WebMouseWheelEvent& event) {
   if (host_)
     host_->ForwardWheelEvent(event);
 }
 
 void RenderWidgetHostViewAndroid::SendGestureEvent(
-    const WebKit::WebGestureEvent& event) {
+    const blink::WebGestureEvent& event) {
   // Sending a gesture that may trigger overscroll should resume the effect.
   if (overscroll_effect_)
     overscroll_effect_->SetEnabled(true);
 
   if (host_)
     host_->ForwardGestureEvent(event);
 }
 
 void RenderWidgetHostViewAndroid::SelectRange(const gfx::Point& start,
                                               const gfx::Point& end) {
@@ skipping 197 matching lines @@
 
   DCHECK_EQ(source->width(), dst_size_in_pixel.width());
   DCHECK_EQ(source->height(), dst_size_in_pixel.height());
 
   ignore_result(scoped_callback_runner.Release());
   callback.Run(true, *source);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
-    WebKit::WebScreenInfo* results) {
+    blink::WebScreenInfo* results) {
   const gfx::Display& display =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
   results->rect = display.bounds();
   // TODO(husky): Remove any system controls from availableRect.
   results->availableRect = display.work_area();
   results->deviceScaleFactor = display.device_scale_factor();
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content