[DevTools] Allow partial device metrics emulation.

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/debug/trace_event_synthetic_delay.h"
@@ skipping 167 matching lines @@
       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,
                                   const gfx::Rect& window_screen_rect);
   void OnShowContextMenu(ContextMenuParams* params);
 
  private:
+  void CalculateScaleAndOffset();
   void Apply(float overdraw_bottom_height,
       gfx::Rect resizer_rect, bool is_fullscreen);
 
   RenderWidget* widget_;
 
   // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
   gfx::Rect device_rect_;
   gfx::Rect widget_rect_;
   float device_scale_factor_;
   bool fit_to_view_;
@@ skipping 49 matching lines @@
     float device_scale_factor,
     bool fit_to_view) {
   device_rect_ = device_rect;
   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) {
+void RenderWidget::ScreenMetricsEmulator::CalculateScaleAndOffset() {
   if (fit_to_view_) {
     DCHECK(!original_size_.IsEmpty());
 
     int width_with_gutter =
         std::max(original_size_.width() - 2 * device_rect_.x(), 1);
     int height_with_gutter =
         std::max(original_size_.height() - 2 * device_rect_.y(), 1);
     float width_ratio =
         static_cast<float>(widget_rect_.width()) / width_with_gutter;
     float height_ratio =
         static_cast<float>(widget_rect_.height()) / height_with_gutter;
     float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
     scale_ = 1.f / ratio;
+
+    // Center emulated view inside available view space.
+    offset_.set_x((original_size_.width() - scale_ * widget_rect_.width()) / 2);
+    offset_.set_y(
+        (original_size_.height() - scale_ * widget_rect_.height()) / 2);
   } else {
     scale_ = 1.f;
+    offset_.SetPoint(0, 0);
+  }
+}
+
+void RenderWidget::ScreenMetricsEmulator::Apply(
+    float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
+  gfx::Rect applied_widget_rect = widget_rect_;
+  if (widget_rect_.size().IsEmpty()) {
+    scale_ = 1.f;
+    offset_.SetPoint(0, 0);
+    applied_widget_rect =
+        gfx::Rect(original_view_screen_rect_.origin(), original_size_);
+  } else {
+    CalculateScaleAndOffset();
   }
 
-  // Center emulated view inside available view space.
-  offset_.set_x((original_size_.width() - scale_ * widget_rect_.width()) / 2);
-  offset_.set_y((original_size_.height() - scale_ * widget_rect_.height()) / 2);
+  if (device_rect_.size().IsEmpty()) {
+    widget_->screen_info_.rect = original_screen_info_.rect;
+    widget_->screen_info_.availableRect = original_screen_info_.availableRect;
+    widget_->window_screen_rect_ = original_window_screen_rect_;
+  } else {
+    widget_->screen_info_.rect = gfx::Rect(device_rect_.size());
+    widget_->screen_info_.availableRect = gfx::Rect(device_rect_.size());
+    widget_->window_screen_rect_ = widget_->screen_info_.availableRect;
+  }
 
-  widget_->screen_info_.rect = gfx::Rect(device_rect_.size());
-  widget_->screen_info_.availableRect = gfx::Rect(device_rect_.size());
-  widget_->screen_info_.deviceScaleFactor = device_scale_factor_;
+  float applied_device_scale_factor = device_scale_factor_ ?
+      device_scale_factor_ : original_screen_info_.deviceScaleFactor;
+  widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
 
   // Pass three 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 offset and scale to the
   //   root layer.
   widget_->SetScreenMetricsEmulationParameters(
       original_screen_info_.deviceScaleFactor, offset_, scale_);
 
-  widget_->SetDeviceScaleFactor(device_scale_factor_);
-  widget_->view_screen_rect_ = widget_rect_;
-  widget_->window_screen_rect_ = widget_->screen_info_.availableRect;
+  widget_->SetDeviceScaleFactor(applied_device_scale_factor);
+  widget_->view_screen_rect_ = applied_widget_rect;
 
   gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
       original_size_, original_screen_info_.deviceScaleFactor));
-  widget_->Resize(widget_rect_.size(), physical_backing_size,
+  widget_->Resize(applied_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_ &&
       !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
   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;
+  if (device_rect_.size().IsEmpty())
+    widget_->window_screen_rect_ = window_screen_rect;
+  if (widget_rect_.size().IsEmpty())
+    widget_->view_screen_rect_ = view_screen_rect;
 }
 
 void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
     ContextMenuParams* params) {
   params->x *= scale_;
   params->x += offset_.x();
   params->y *= scale_;
   params->y += offset_.y();
 }
 
@@ skipping 2499 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content