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 61 matching lines @@
 #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 281 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_SmoothScrollCompleted, OnSmoothScrollCompleted)
     IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
     IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
 #if defined(OS_ANDROID)
@@ skipping 115 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();
+  }
+}
+
 // 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 245 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 (!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 959 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 499 matching lines @@
           weak_ptr_factory_.GetWeakPtr()));
 
   if (!context->InitializeWithDefaultBufferSizes(
           attributes,
           false /* bind generates resources */,
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
     return NULL;
   return context.release();
 }
 
+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_;
+  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 override.
+    widget->compositor_->OverrideDeviceScaleFactor(0.f);
+  }
+  widget->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
+  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) {
+  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);
+  }
+
+  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));
+  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()));
+}
+
+WebKit::WebInputEvent* RenderWidget::DeviceEmulationHelper::ConvertInputEventToEmulated(

[aelias_OOO_until_Jul13, 2013/09/05 08:26:49]

The CC impl thread captures input events as well.  For example, all touch-based
gesture events, and mousewheel when threaded compositing is enabled.  So
translating them here won't work in those cases.  I'd suggest translating on the
browser side instead.

[dgozman, 2013/09/10 19:54:02]

As I understand, CC event handling is not interested in screen positions, which
are the only ones changed here.
Also, if/when I add scaling support via CC impl, it would be logical to scale
events there (since layerTreeHostImpl would know the scale factor).

On the other hand, moving more code to the host size will spread my changes a
lot, while I prefer to keep them more or less in one place (render widget in
this CL). What do you think? 

[aelias_OOO_until_Jul13, 2013/09/10 20:33:34]

OK, I didn't notice you were only changing those side fields. How about just not
making any changes to input event at all then?  This is a lot of complex logic
for no clear benefit.  You could just forward the true screen position of input
events (modulo DIP adjustment).  There's no clear use case for screenPosition
anyway and the intent of it is that it should be true screen position.

[dgozman, 2013/09/10 20:55:36]

Well, wrong screen position of events will conflict with window.screenX/Y, but
this is not a big deal. Let's remove for now.
However, when implementing render-side scale, this input method conversion
should be restored back to apply backward scale.

[aelias_OOO_until_Jul13, 2013/09/10 21:00:02]

should be restored back to apply backward scale.

OK, so it sounds like you don't have this really working locally yet.  So I
think we should delay reviewing this change until you have an end-to-end
solution or we might go the wrong design direction.

+    RenderWidget* widget, 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->globalX = widget_rect_.x() + result->x;
+    result->globalY = widget_rect_.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 RenderWidget::DeviceEmulationHelper::ConvertMouseEventToEmulated(
+    WebKit::WebMouseEvent* event) {
+  event->windowX = widget_rect_.x() + event->x;
+  event->windowY = widget_rect_.y() + event->y;
+  event->globalX = event->windowX;
+  event->globalY = event->windowY;
+}
+
+void RenderWidget::DeviceEmulationHelper::ConvertTouchPointToEmulated(
+    WebKit::WebTouchPoint* point) {
+  point->screenPosition.x = widget_rect_.x() + point->position.x;
+  point->screenPosition.y = widget_rect_.y() + point->position.y;
+}
+
+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();
+  result.y = original_view_screen_rect_.y() +
+      result.y - widget_rect_.y();
+  return result;
+}
+
 }  // namespace content