Implementation of device metrics emulation in render view.

content/renderer/render_widget.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.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 35 matching lines @@
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebCursorInfo.h"
 #include "third_party/WebKit/public/web/WebHelperPlugin.h"
 #include "third_party/WebKit/public/web/WebPagePopup.h"
 #include "third_party/WebKit/public/web/WebPopupMenu.h"
 #include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
 #include "third_party/WebKit/public/web/WebRange.h"
 #include "third_party/WebKit/public/web/WebScreenInfo.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/base/ui_base_switches.h"
-#include "ui/gfx/point.h"
+#include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/gfx/vector2d_conversions.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/surface/transport_dib.h"
 #include "webkit/renderer/compositor_bindings/web_rendering_stats_impl.h"
 
 #if defined(OS_ANDROID)
 #include "content/renderer/android/synchronous_compositor_factory.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #endif  // defined(OS_POSIX)
 
 #include "third_party/WebKit/public/web/WebWidget.h"
 
 using WebKit::WebCompositionUnderline;
 using WebKit::WebCursorInfo;
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
+using WebKit::WebMouseWheelEvent;
 using WebKit::WebNavigationPolicy;
 using WebKit::WebPagePopup;
 using WebKit::WebPoint;
 using WebKit::WebPopupMenu;
 using WebKit::WebPopupMenuInfo;
 using WebKit::WebPopupType;
 using WebKit::WebRange;
 using WebKit::WebRect;
 using WebKit::WebScreenInfo;
 using WebKit::WebSize;
@@ skipping 287 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
     IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
     IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
     IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
     IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
     IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
     IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
     IPC_MESSAGE_HANDLER(ViewMsg_SwapBuffers_ACK,
                         OnViewContextSwapBuffersComplete)
+    IPC_MESSAGE_HANDLER(ViewMsg_EmulateDevice_ACK, OnEmulateDeviceAck)
     IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
     IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
     IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
     IPC_MESSAGE_HANDLER(ViewMsg_PaintAtSize, OnPaintAtSize)
     IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
     IPC_MESSAGE_HANDLER(ViewMsg_SyntheticGestureCompleted,
                         OnSyntheticGestureCompleted)
     IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
     IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
@@ skipping 116 matching lines @@
   // If there is a Send call on the stack, then it could be dangerous to close
   // now.  Post a task that only gets invoked when there are no nested message
   // loops.
   base::MessageLoop::current()->PostNonNestableTask(
       FROM_HERE, base::Bind(&RenderWidget::Close, this));
 
   // Balances the AddRef taken when we called AddRoute.
   Release();
 }
 
+void RenderWidget::EmulateDevice(
+    bool enabled,
+    const gfx::Size& device_size,
+    const gfx::Rect& widget_rect,
+    float device_scale_factor,
+    bool fit_to_view) {
+  pending_device_emulation_enabled_ = enabled;
+  if (enabled) {
+    pending_device_emulation_helper_.reset(new DeviceEmulationHelper(
+        device_size,
+        widget_rect,
+        device_scale_factor,
+        fit_to_view));
+  } else {
+    pending_device_emulation_helper_.reset();
+  }
+  Send(new ViewHostMsg_EmulateDevice(routing_id_, enabled));
+}
+
+void RenderWidget::OnEmulateDeviceAck(bool enabled) {
+  // We may have got another emulate device request while sending message
+  // to the host. If the host idea of whether device emulation is enabled
+  // differs, wait for another ack with the right |enabled| value.
+  if (enabled != pending_device_emulation_enabled_)
+    return;
+
+  if (pending_device_emulation_enabled_) {
+    if (!device_emulation_helper_) {
+      device_emulation_helper_ = pending_device_emulation_helper_.Pass();
+      device_emulation_helper_->BeginEmulation(this);
+    } else {
+      device_emulation_helper_->ChangeEmulationParams(
+          this, pending_device_emulation_helper_.get());
+      pending_device_emulation_helper_.reset();
+    }
+  } else {
+    if (device_emulation_helper_)
+      device_emulation_helper_->EndEmulation(this);
+    device_emulation_helper_.reset();
+  }
+}
+
+void RenderWidget::SetDeviceEmulationScale(float scale) {
+  // This is only supported in RenderView.
+  NOTREACHED();
+}
+
 // Got a response from the browser after the renderer decided to create a new
 // view.
 void RenderWidget::OnCreatingNewAck() {
   DCHECK(routing_id_ != MSG_ROUTING_NONE);
 
   CompleteInit();
 }
 
 void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
+  if (device_emulation_helper_) {
+    device_emulation_helper_->OnResizeMessage(this, params);
+    return;
+  }
+
   screen_info_ = params.screen_info;
   SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
   Resize(params.new_size, params.physical_backing_size,
          params.overdraw_bottom_height, params.resizer_rect,
          params.is_fullscreen, SEND_RESIZE_ACK);
 }
 
 void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
   if (resizer_rect_ != resizer_rect) {
     gfx::Rect view_rect(size_);
@@ skipping 262 matching lines @@
   }
 
   // Continue painting if necessary...
   DoDeferredUpdateAndSendInputAck();
 }
 
 void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info,
                                       bool is_keyboard_shortcut) {
   handling_input_event_ = true;
+
+  scoped_ptr<const WebKit::WebInputEvent> owner;
+  if (device_emulation_helper_) {
+    input_event = device_emulation_helper_->ConvertInputEventToEmulated(
+        this, input_event);
+    if (input_event)
+      owner.reset(input_event);
+  }
+  if (popup_device_emulation_helper_) {
+//    input_event = popup_device_emulation_helper_->ConvertInputEventToEmulated(
+//        this, input_event);
+//    if (input_event)
+//      owner.reset(input_event);
+  }
+
   if (!input_event) {
     handling_input_event_ = false;
     return;
   }
 
   const char* const event_name = GetEventName(input_event->type);
   TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
                "event", event_name);
 
   if (compositor_)
@@ skipping 592 matching lines @@
     compositor_->Composite(frame_begin_time);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WebWidgetClient
 
 void RenderWidget::didInvalidateRect(const WebRect& rect) {
   // The invalidated rect might be outside the bounds of the view.
   gfx::Rect view_rect(size_);
   gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
+  if (popup_device_emulation_helper_)
+    damaged_rect = view_rect;
   if (damaged_rect.IsEmpty())
     return;
 
   paint_aggregator_.InvalidateRect(damaged_rect);
 
   // We may not need to schedule another call to DoDeferredUpdate.
   if (invalidation_task_posted_)
     return;
   if (!paint_aggregator_.HasPendingUpdate())
     return;
@@ skipping 331 matching lines @@
     return pending_window_rect_;
 
   return view_screen_rect_;
 }
 
 void RenderWidget::setToolTipText(const WebKit::WebString& text,
                                   WebTextDirection hint) {
   Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
 }
 
-void RenderWidget::setWindowRect(const WebRect& pos) {
+void RenderWidget::setWindowRect(const WebRect& rect) {
+  WebRect pos = rect;
+  if (popup_device_emulation_helper_) {
+    pos = popup_device_emulation_helper_->ConvertPopupScreenRectFromEmulated(
+        this, rect);
+  }
+
   if (did_show_) {
     if (!RenderThreadImpl::current()->layout_test_mode()) {
       Send(new ViewHostMsg_RequestMove(routing_id_, pos));
       SetPendingWindowRect(pos);
     } else {
       WebSize new_size(pos.width, pos.height);
       Resize(new_size, new_size, overdraw_bottom_height_,
              WebRect(), is_fullscreen_, NO_RESIZE_ACK);
       view_screen_rect_ = pos;
       window_screen_rect_ = pos;
@@ skipping 220 matching lines @@
 }
 
 void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
   if (!webwidget_)
     return;
   webwidget_->setTextDirection(direction);
 }
 
 void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
                                        const gfx::Rect& window_screen_rect) {
+  if (device_emulation_helper_) {
+    device_emulation_helper_->OnUpdateScreenRectsMessage(
+        this, view_screen_rect, window_screen_rect);
+    return;
+  }
   view_screen_rect_ = view_screen_rect;
   window_screen_rect_ = window_screen_rect;
   Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
 }
 
 #if defined(OS_ANDROID)
 void RenderWidget::OnImeBatchStateChanged(bool is_begin) {
   Send(new ViewHostMsg_ImeBatchStateChanged_ACK(routing_id(), is_begin));
 }
 
@@ skipping 494 matching lines @@
           weak_ptr_factory_.GetWeakPtr()));
 
   if (!context->InitializeWithDefaultBufferSizes(
           attributes,
           false /* bind generates resources */,
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   return context.Pass();
 }
 
+// This class scales input event's coordinates, and then sets screen coordinates
+// to emulate specific view position on the screen.
+class DeviceEmulationEventRewriter : public InputEventRewriter {
+ public:
+  DeviceEmulationEventRewriter() {}
+  virtual ~DeviceEmulationEventRewriter() {}
+
+  void SetParams(float scale, const gfx::Point& origin);
+
+  // InputEventRewriter implementation.
+  virtual WebKit::WebInputEvent* RewriteInputEvent(
+      const WebKit::WebInputEvent* event);
+
+ private:
+  void ConvertMouseEventToEmulated(WebKit::WebMouseEvent* event);
+  void ConvertTouchPointToEmulated(WebKit::WebTouchPoint* point);
+
+  // Event coordinates are scaled by this value.
+  float scale_;
+
+  // Widget screen position, used to set proper event screen coordinates.
+  gfx::Point origin_;
+};
+
+void DeviceEmulationEventRewriter::SetParams(
+    float scale, const gfx::Point& origin) {
+  scale_ = scale;
+  origin_ = origin;
+}
+
+WebKit::WebInputEvent* DeviceEmulationEventRewriter::RewriteInputEvent(
+    const WebKit::WebInputEvent* event) {
+  if (!event)
+    return NULL;
+
+  if (WebInputEvent::isKeyboardEventType(event->type)) {
+    const WebKeyboardEvent& keyboard_event =
+            *static_cast<const WebKeyboardEvent*>(event);
+    WebKeyboardEvent* result = new WebKeyboardEvent(keyboard_event);
+    return result;
+  }
+
+  if (WebInputEvent::isMouseEventType(event->type)) {
+    const WebMouseEvent& mouse_event =
+            *static_cast<const WebMouseEvent*>(event);
+    WebMouseEvent* result = new WebMouseEvent(mouse_event);
+    ConvertMouseEventToEmulated(result);
+    return result;
+  }
+
+  if (WebInputEvent::MouseWheel == event->type) {
+    const WebMouseWheelEvent& mouse_wheel_event =
+            *static_cast<const WebMouseWheelEvent*>(event);
+    WebMouseWheelEvent* result = new WebMouseWheelEvent(mouse_wheel_event);
+    ConvertMouseEventToEmulated(result);
+    return result;
+  }
+
+  if (WebInputEvent::isGestureEventType(event->type)) {
+    const WebGestureEvent& gesture_event =
+            *static_cast<const WebGestureEvent*>(event);
+    WebGestureEvent* result = new WebGestureEvent(gesture_event);
+    result->x = 1.f / scale_ * result->x;
+    result->y = 1.f / scale_ * result->y;
+    result->globalX = origin_.x() + result->x;
+    result->globalY = origin_.y() + result->y;
+    return result;
+  }
+
+  if (WebInputEvent::isTouchEventType(event->type)) {
+    const WebTouchEvent& touch_event =
+            *static_cast<const WebTouchEvent*>(event);
+    WebTouchEvent* result = new WebTouchEvent(touch_event);
+    for (size_t index = 0; index < result->touchesLength; ++index) {
+      ConvertTouchPointToEmulated(&result->touches[index]);
+    }
+    for (size_t index = 0; index < result->changedTouchesLength; ++index) {
+      ConvertTouchPointToEmulated(&result->changedTouches[index]);
+    }
+    for (size_t index = 0; index < result->targetTouchesLength; ++index) {
+      ConvertTouchPointToEmulated(&result->targetTouches[index]);
+    }
+    return result;
+  }
+
+  return NULL;
+}
+
+void DeviceEmulationEventRewriter::ConvertMouseEventToEmulated(
+    WebKit::WebMouseEvent* event) {
+  event->x = 1.f / scale_ * event->x;
+  event->y = 1.f / scale_ * event->y;
+  event->movementX = 1.f / scale_ * event->movementX;
+  event->movementY = 1.f / scale_ * event->movementY;
+  event->windowX = origin_.x() + event->x;
+  event->windowY = origin_.y() + event->y;
+  event->globalX = event->windowX;
+  event->globalY = event->windowY;
+}
+
+void DeviceEmulationEventRewriter::ConvertTouchPointToEmulated(
+    WebKit::WebTouchPoint* point) {
+  point->position.x = 1.f / scale_ * point->position.x;
+  point->position.y = 1.f / scale_ * point->position.y;
+  point->screenPosition.x = origin_.x() + point->position.x;
+  point->screenPosition.y = origin_.y() + point->position.y;
+}
+
+
+RenderWidget::DeviceEmulationHelper::DeviceEmulationHelper(
+    const gfx::Size& device_size,
+    const gfx::Rect& widget_rect,
+    float device_scale_factor,
+    bool fit_to_view)
+    : device_size_(device_size),
+      widget_rect_(widget_rect),
+      device_scale_factor_(device_scale_factor),
+      fit_to_view_(fit_to_view),
+      weak_ptr_factory_(this) {
+}
+
+RenderWidget::DeviceEmulationHelper::~DeviceEmulationHelper() {
+}
+
+void RenderWidget::DeviceEmulationHelper::BeginEmulation(RenderWidget* widget) {
+  original_size_ = widget->size_;
+  original_physical_backing_size_ = widget->physical_backing_size_;
+  original_screen_info_ = widget->screen_info_;
+  original_view_screen_rect_ = widget->view_screen_rect_;
+  original_window_screen_rect_ = widget->window_screen_rect_;
+  input_event_rewriter_.reset(new DeviceEmulationEventRewriter);
+  Apply(widget, widget->overdraw_bottom_height_, widget->resizer_rect_,
+        widget->is_fullscreen_);
+}
+
+void RenderWidget::DeviceEmulationHelper::ChangeEmulationParams(
+    RenderWidget* widget, DeviceEmulationHelper* params) {
+  device_size_ = params->device_size_;
+  widget_rect_ = params->widget_rect_;
+  device_scale_factor_ = params->device_scale_factor_;
+  fit_to_view_ = params->fit_to_view_;
+  Apply(widget, widget->overdraw_bottom_height_, widget->resizer_rect_,
+        widget->is_fullscreen_);
+}
+
+void RenderWidget::DeviceEmulationHelper::EndEmulation(RenderWidget* widget) {
+  widget->screen_info_ = original_screen_info_;
+  if (widget->compositor_) {
+    // Passing zero cancels the override.
+    widget->compositor_->OverrideDeviceScaleFactor(0.f);
+  }
+  widget->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
+  widget->SetDeviceEmulationScale(1.f);
+  widget->view_screen_rect_ = original_view_screen_rect_;
+  widget->window_screen_rect_ = original_window_screen_rect_;
+  widget->Resize(original_size_,
+                 original_physical_backing_size_,
+                 widget->overdraw_bottom_height_, widget->resizer_rect_,
+                 widget->is_fullscreen_, NO_RESIZE_ACK);
+}
+
+void RenderWidget::DeviceEmulationHelper::Apply(RenderWidget* widget,
+    float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
+  if (fit_to_view_) {
+    float width_ratio = !original_size_.width() ? 1.f :
+       static_cast<float>(widget_rect_.width()) / original_size_.width();
+    float height_ratio = !original_size_.height() ? 1.f :
+        static_cast<float>(widget_rect_.height()) / original_size_.height();
+    float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
+    scale_ = 1.f / ratio;
+  } else {
+    scale_ = 1.f;
+  }
+
+  input_event_rewriter_->SetParams(scale_, widget_rect_.origin());
+  InputHandlerManager* input_handler_manager =
+      RenderThreadImpl::current()->input_handler_manager();
+  if (input_handler_manager) {
+     // Make a copy to be owned by InputHandlerManager.
+     scoped_ptr<DeviceEmulationEventRewriter> copy(
+         new DeviceEmulationEventRewriter(*input_event_rewriter_));
+     input_handler_manager->SetInputEventRewriter(
+        widget->routing_id_, copy.PassAs<InputEventRewriter>());
+  }
+
+  widget->screen_info_.rect = gfx::Rect(device_size_);
+  widget->screen_info_.availableRect = gfx::Rect(device_size_);
+  widget->screen_info_.deviceScaleFactor = device_scale_factor_;
+
+  if (widget->compositor_) {
+    // We keep the real device scale factor in compositor to prevent unnecessary
+    // scaling on browser side. This override ensures that compositor
+    // will not change scale factor due to WebLayerTreeView's call.
+    widget->compositor_->OverrideDeviceScaleFactor(
+        original_screen_info_.deviceScaleFactor);
+  }
+
+  // In order to fit into view, WebView applies scaling transform to the
+  // root graphics layer.
+  widget->SetDeviceEmulationScale(scale_);
+
+  widget->SetDeviceScaleFactor(device_scale_factor_);
+  widget->view_screen_rect_ = widget_rect_;
+  widget->window_screen_rect_ = widget->screen_info_.availableRect;
+
+  gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
+      widget_rect_.size(), original_screen_info_.deviceScaleFactor * scale_));
+  widget->Resize(widget_rect_.size(), physical_backing_size,
+                 overdraw_bottom_height, resizer_rect,
+                 is_fullscreen, NO_RESIZE_ACK);
+}
+
+void RenderWidget::DeviceEmulationHelper::OnResizeMessage(
+    RenderWidget* widget, const ViewMsg_Resize_Params& params) {
+  bool need_ack = params.new_size != original_size_;
+  original_size_ = params.new_size;
+  original_physical_backing_size_ = params.physical_backing_size;
+  original_screen_info_ = params.screen_info;
+  Apply(widget, params.overdraw_bottom_height, params.resizer_rect,
+        params.is_fullscreen);
+
+  if (need_ack) {
+    widget->set_next_paint_is_resize_ack();
+    if (widget->is_accelerated_compositing_active_ && widget->compositor_)
+      widget->compositor_->SetNeedsRedrawRect(gfx::Rect(widget->size_));
+    else
+      widget->didInvalidateRect(gfx::Rect(widget->size_));
+  }
+}
+
+void RenderWidget::DeviceEmulationHelper::OnUpdateScreenRectsMessage(
+    RenderWidget* widget,
+    const gfx::Rect view_screen_rect,
+    const gfx::Rect window_screen_rect) {
+  original_view_screen_rect_ = view_screen_rect;
+  original_window_screen_rect_ = window_screen_rect;
+  widget->Send(new ViewHostMsg_UpdateScreenRects_ACK(widget->routing_id()));
+}
+
+void RenderWidget::DeviceEmulationHelper::OnShowContextMenu(
+    RenderWidget* widget, ContextMenuParams* params) {
+  params->x *= scale_;
+  params->y *= scale_;
+}
+
+WebKit::WebInputEvent* RenderWidget::DeviceEmulationHelper::ConvertInputEventToEmulated(
+    RenderWidget* widget, const WebKit::WebInputEvent* event) {
+  return input_event_rewriter_->RewriteInputEvent(event);
+}
+
+void RenderWidget::DeviceEmulationHelper::PopupCreated(
+    RenderWidget* widget, RenderWidget* popup) {
+  popup->popup_device_emulation_helper_ = weak_ptr_factory_.GetWeakPtr();
+}
+
+WebKit::WebRect RenderWidget::DeviceEmulationHelper::ConvertPopupScreenRectFromEmulated(
+    RenderWidget* popup, const WebKit::WebRect& rect) {
+  WebKit::WebRect result = rect;
+  result.x = original_view_screen_rect_.x() +
+      (result.x - widget_rect_.x()) * scale_;
+  result.y = original_view_screen_rect_.y() +
+      (result.y - widget_rect_.y()) * scale_;
+  return result;
+}
+
 }  // namespace content