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"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "cc/output/output_surface.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/child/npapi/webplugin.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/input_messages.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/cursor_utils.h"
+#include "content/renderer/external_popup_menu.h"
 #include "content/renderer/gpu/compositor_output_surface.h"
 #include "content/renderer/gpu/compositor_software_output_device.h"
 #include "content/renderer/gpu/delegated_compositor_output_surface.h"
 #include "content/renderer/gpu/input_handler_manager.h"
 #include "content/renderer/gpu/mailbox_output_surface.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/ime_event_guard.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
 #include "ipc/ipc_sync_message.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #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/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 "base/android/sys_utils.h"
 #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 87 matching lines @@
   TextInputModeMap::iterator it = singleton->Map().find(input_mode.utf8());
   if (it == singleton->Map().end())
     return ui::TEXT_INPUT_MODE_DEFAULT;
   return it->second;
 }
 
 }  // namespace
 
 namespace content {
 
+// RenderWidget::ScreenMetricsEmulator ----------------------------------------
+
+class RenderWidget::ScreenMetricsEmulator {
+ public:
+  ScreenMetricsEmulator(
+      RenderWidget* widget,
+      const gfx::Size& device_size,
+      const gfx::Rect& widget_rect,
+      float device_scale_factor,
+      bool fit_to_view);
+  virtual ~ScreenMetricsEmulator();
+
+  float scale() { return scale_; }
+  gfx::Rect widget_rect() const { return widget_rect_; }
+  gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
+
+  void ChangeEmulationParams(
+      const gfx::Size& device_size,
+      const gfx::Rect& widget_rect,
+      float device_scale_factor,
+      bool fit_to_view);
+
+  // The following methods alter handlers' behavior for messages related to
+  // widget size and position.
+  void OnResizeMessage(const ViewMsg_Resize_Params& params);
+  void OnUpdateScreenRectsMessage(const gfx::Rect view_screen_rect,

[aelias_OOO_until_Jul13, 2013/09/27 22:51:14]

Either add & or remove the "const".

[dgozman, 2013/10/01 06:22:16]

Done.

+                                  const gfx::Rect window_screen_rect);
+  void OnShowContextMenu(ContextMenuParams* params);
+
+ private:
+  void Apply(float overdraw_bottom_height,
+      gfx::Rect resizer_rect, bool is_fullscreen);
+
+  RenderWidget* widget_;
+
+  // Parameters as passed by RenderWidget::EmulateScreenMetrics.
+  gfx::Size device_size_;
+  gfx::Rect widget_rect_;
+  float device_scale_factor_;
+  bool fit_to_view_;
+
+  // The computed scaled used to fit widget into browser window.
+  float scale_;
+
+  // Original values to restore back after emulation ends.
+  gfx::Size original_size_;
+  gfx::Size original_physical_backing_size_;
+  WebKit::WebScreenInfo original_screen_info_;
+  gfx::Rect original_view_screen_rect_;
+  gfx::Rect original_window_screen_rect_;
+};
+
+RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
+    RenderWidget* widget,
+    const gfx::Size& device_size,
+    const gfx::Rect& widget_rect,
+    float device_scale_factor,
+    bool fit_to_view)
+    : widget_(widget),
+      device_size_(device_size),
+      widget_rect_(widget_rect),
+      device_scale_factor_(device_scale_factor),
+      fit_to_view_(fit_to_view),
+      scale_(1.f) {
+  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_->overdraw_bottom_height_,
+        widget_->resizer_rect_, widget_->is_fullscreen_);
+}
+
+RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
+  widget_->screen_info_ = original_screen_info_;
+
+  widget_->Send(new ViewHostMsg_SetExpectedSize(widget_->routing_id(),
+      gfx::Size()));
+
+  widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
+  widget_->SetScreenMetricsEmulationParameters(false /* enabled */, 1.f, 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::ScreenMetricsEmulator::ChangeEmulationParams(
+    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;
+  Apply(widget_->overdraw_bottom_height_,
+        widget_->resizer_rect_, widget_->is_fullscreen_);
+}
+
+void RenderWidget::ScreenMetricsEmulator::Apply(
+    float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
+  if (fit_to_view_) {
+    float width_ratio = !original_size_.width() ? 1.f :

[aelias_OOO_until_Jul13, 2013/09/27 22:51:14]

Setting a default value when a divide-by-zero would occur is not very principled
and I've seen this kind of thing cause subtle bugs.  In reality, when would
original_size_.width() be zero?  If never, can you DCHECK it's non-empty
instead?  If sometimes, are you sure you don't need to suppress emulation
entirely until it resolves to a sane value?

[dgozman, 2013/10/01 06:22:16]

Added DCHECK.

+       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;

[aelias_OOO_until_Jul13, 2013/09/27 22:51:14]

widget_rect_ being zero would also cause a divide-by-zero here so you should
DCHECK that one too.

[dgozman, 2013/10/01 06:22:16]

Ratio is at least 1.f (see line above).

+  } else {
+    scale_ = 1.f;
+  }
+
+  widget_->screen_info_.rect = gfx::Rect(device_size_);
+  widget_->screen_info_.availableRect = gfx::Rect(device_size_);
+  widget_->screen_info_.deviceScaleFactor = device_scale_factor_;
+
+  // Pass two emulation parameters to the blink side:
+  // - we keep the real device scale factor in compositor to produce sharp image
+  //   even when emulating different scale factor;
+  // - in order to fit into view, WebView applies scaling transform to the
+  //   root layer.
+  widget_->SetScreenMetricsEmulationParameters(true /* enabled */,
+      original_screen_info_.deviceScaleFactor, scale_);
+
+  widget_->SetDeviceScaleFactor(device_scale_factor_);
+  widget_->view_screen_rect_ = widget_rect_;
+  widget_->window_screen_rect_ = widget_->screen_info_.availableRect;
+
+  // Make host accept an image of different size.
+  widget_->Send(new ViewHostMsg_SetExpectedSize(widget_->routing_id(),
+      gfx::ToCeiledSize(gfx::ScaleSize(widget_rect_.size(), scale_))));
+
+  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::ScreenMetricsEmulator::OnResizeMessage(
+    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(params.overdraw_bottom_height, params.resizer_rect,
+        params.is_fullscreen);
+
+  if (need_ack) {
+    widget_->set_next_paint_is_resize_ack();
+    if (widget_->compositor_)
+      widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
+  }
+}
+
+void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
+    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::ScreenMetricsEmulator::OnShowContextMenu(
+    ContextMenuParams* params) {
+  params->x *= scale_;
+  params->y *= scale_;
+}
+
+// RenderWidget ---------------------------------------------------------------
+
 RenderWidget::RenderWidget(WebKit::WebPopupType popup_type,
                            const WebKit::WebScreenInfo& screen_info,
                            bool swapped_out,
                            bool hidden)
     : routing_id_(MSG_ROUTING_NONE),
       surface_id_(0),
       webwidget_(NULL),
       opener_id_(MSG_ROUTING_NONE),
       init_complete_(false),
       current_paint_buf_(NULL),
@@ skipping 25 matching lines @@
       was_accelerated_compositing_ever_active_(false),
       animation_update_pending_(false),
       invalidation_task_posted_(false),
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
       is_threaded_compositing_enabled_(false),
       next_output_surface_id_(0),
 #if defined(OS_ANDROID)
       outstanding_ime_acks_(0),
 #endif
+      popup_origin_scale_for_emulation_(0.f),
       weak_ptr_factory_(this) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableGpuVsync);
   is_threaded_compositing_enabled_ =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableThreadedCompositing);
 
@@ skipping 118 matching lines @@
 }
 
 bool RenderWidget::UsingSynchronousRendererCompositor() const {
 #if defined(OS_ANDROID)
   return SynchronousCompositorFactory::GetInstance() != NULL;
 #else
   return false;
 #endif
 }
 
+void RenderWidget::EmulateScreenMetrics(
+    bool enabled,
+    const gfx::Size& device_size,
+    const gfx::Rect& widget_rect,
+    float device_scale_factor,
+    bool fit_to_view) {
+  if (enabled) {
+    if (!screen_metrics_emulator_) {
+      screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this,
+          device_size, widget_rect, device_scale_factor, fit_to_view));
+    } else {
+      screen_metrics_emulator_->ChangeEmulationParams(device_size,
+          widget_rect, device_scale_factor, fit_to_view);
+    }
+  } else {
+    screen_metrics_emulator_.reset();
+  }
+}
+
+void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
+    ScreenMetricsEmulator* emulator) {
+  popup_origin_scale_for_emulation_ = emulator->scale();
+  popup_view_origin_for_emulation_ = emulator->widget_rect().origin();
+  popup_screen_origin_for_emulation_ =
+      emulator->original_screen_rect().origin();
+}
+
+void RenderWidget::SetScreenMetricsEmulationParameters(
+    bool enabled, float device_scale_factor, float root_layer_scale) {
+  // This is only supported in RenderView.
+  NOTREACHED();
+}
+
+void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
+    ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
+  popup->SetOriginScaleForEmulation(emulator->scale());
+}
+
+void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
+  if (screen_metrics_emulator_)
+    screen_metrics_emulator_->OnShowContextMenu(params);
+}
+
 bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
     IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
     IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
                         OnCursorVisibilityChange)
     IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
     IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
     IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
@@ skipping 143 matching lines @@
 
 // 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 (screen_metrics_emulator_) {
+    screen_metrics_emulator_->OnResizeMessage(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 270 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;
+
   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 949 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_origin_scale_for_emulation_) {
+    float scale = popup_origin_scale_for_emulation_;
+    pos.x = popup_screen_origin_for_emulation_.x() +
+        (pos.x - popup_view_origin_for_emulation_.x()) * scale;
+    pos.y = popup_screen_origin_for_emulation_.y() +
+        (pos.y - popup_view_origin_for_emulation_.y()) * scale;
+  }
+
   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 (screen_metrics_emulator_) {
+    screen_metrics_emulator_->OnUpdateScreenRectsMessage(
+        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 551 matching lines @@
           kDefaultCommandBufferSize,
           kDefaultStartTransferBufferSize,
           kDefaultMinTransferBufferSize,
           kDefaultMaxTransferBufferSize,
           mapped_memory_reclaim_limit))
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   return context.Pass();
 }
 
 }  // namespace content