Revert of Decouple ScreenMetricsEmulator From RenderWidget (patchset #9 id:160001 of https://codereview.chromium.org/1675783002/ )

Reason for revert:
speculative revert: http://test-results.appspot.com/dashboards/flakiness_dashboard.html#tests=inspector/elements/styles-4/styles-update-links.html

Original issue's description:
> Decouple ScreenMetricsEmulator From RenderWidget
>
> This is part of the ongoing effort to thin down RenderWidget to be just IPC transport.
> Started in http://crrev.com/1599583002
>
> BUG=577321

TBR=dgozman@chromium.org,fsamuel@chromium.org,jam@chromium.org,mfomitchev@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=577321

Review URL: https://codereview.chromium.org/1692083003

Cr-Commit-Position: refs/heads/master@{#375078}

7 files changed, 386 insertions, 461 deletions

diff --git a/content/content_renderer.gypi b/content/content_renderer.gypi
index 75c3c86..9b7a00f 100644
--- a/content/content_renderer.gypi
+++ b/content/content_renderer.gypi
@@ -170,8 +170,6 @@
       'renderer/devtools/devtools_cpu_throttler.cc',
       'renderer/devtools/devtools_cpu_throttler.h',
       'renderer/devtools/lock_free_circular_queue.h',
-      'renderer/devtools/render_widget_screen_metrics_emulator.cc',
-      'renderer/devtools/render_widget_screen_metrics_emulator.h',
       'renderer/devtools/v8_sampling_profiler.cc',
       'renderer/devtools/v8_sampling_profiler.h',
       'renderer/disambiguation_popup_helper.cc',
diff --git a/content/renderer/devtools/render_widget_screen_metrics_emulator.cc b/content/renderer/devtools/render_widget_screen_metrics_emulator.cc
deleted file mode 100644
index 5843379..0000000
--- a/content/renderer/devtools/render_widget_screen_metrics_emulator.cc
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright 2016 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/devtools/render_widget_screen_metrics_emulator.h"
-
-#include "content/common/resize_params.h"
-#include "content/public/common/context_menu_params.h"
-#include "content/renderer/devtools/render_widget_screen_metrics_emulator_delegate.h"
-
-namespace content {
-
-RenderWidgetScreenMetricsEmulator::RenderWidgetScreenMetricsEmulator(
-    RenderWidgetScreenMetricsEmulatorDelegate* delegate,
-    const blink::WebDeviceEmulationParams& params,
-    const ResizeParams& resize_params,
-    const gfx::Rect& view_screen_rect,
-    const gfx::Rect& window_screen_rect)
-    : delegate_(delegate),
-      emulation_params_(params),
-      scale_(1.f),
-      original_resize_params_(resize_params),
-      original_view_screen_rect_(view_screen_rect),
-      original_window_screen_rect_(window_screen_rect) {
-  Apply();
-}
-
-RenderWidgetScreenMetricsEmulator::~RenderWidgetScreenMetricsEmulator() {
-  delegate_->SetScreenMetricsEmulationParameters(false, emulation_params_);
-  delegate_->SetScreenRects(original_view_screen_rect_,
-                            original_window_screen_rect_);
-  delegate_->Resize(original_resize_params_);
-}
-
-void RenderWidgetScreenMetricsEmulator::ChangeEmulationParams(
-    const blink::WebDeviceEmulationParams& params) {
-  emulation_params_ = params;
-  Apply();
-}
-
-void RenderWidgetScreenMetricsEmulator::Apply() {
-  ResizeParams modified_resize_params = original_resize_params_;
-  applied_widget_rect_.set_size(gfx::Size(emulation_params_.viewSize));
-
-  if (!applied_widget_rect_.width())
-    applied_widget_rect_.set_width(original_size().width());
-
-  if (!applied_widget_rect_.height())
-    applied_widget_rect_.set_height(original_size().height());
-
-  if (emulation_params_.fitToView && !original_size().IsEmpty()) {
-    int original_width = std::max(original_size().width(), 1);
-    int original_height = std::max(original_size().height(), 1);
-    float width_ratio =
-        static_cast<float>(applied_widget_rect_.width()) / original_width;
-    float height_ratio =
-        static_cast<float>(applied_widget_rect_.height()) / original_height;
-    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_ * applied_widget_rect_.width()) / 2);
-    offset_.set_y(
-        (original_size().height() - scale_ * applied_widget_rect_.height()) /
-        2);
-  } else {
-    scale_ = emulation_params_.scale;
-    offset_.SetPoint(emulation_params_.offset.x, emulation_params_.offset.y);
-    if (!emulation_params_.viewSize.width &&
-        !emulation_params_.viewSize.height && scale_) {
-      applied_widget_rect_.set_size(
-          gfx::ScaleToRoundedSize(original_size(), 1.f / scale_));
-    }
-  }
-
-  gfx::Rect window_screen_rect;
-  if (emulation_params_.screenPosition ==
-      blink::WebDeviceEmulationParams::Desktop) {
-    applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
-    modified_resize_params.screen_info.rect = original_screen_info().rect;
-    modified_resize_params.screen_info.availableRect =
-        original_screen_info().availableRect;
-    window_screen_rect = original_window_screen_rect_;
-  } else {
-    applied_widget_rect_.set_origin(emulation_params_.viewPosition);
-    gfx::Rect screen_rect = applied_widget_rect_;
-    if (!emulation_params_.screenSize.isEmpty()) {
-      screen_rect = gfx::Rect(0, 0, emulation_params_.screenSize.width,
-                              emulation_params_.screenSize.height);
-    }
-    modified_resize_params.screen_info.rect = screen_rect;
-    modified_resize_params.screen_info.availableRect = screen_rect;
-    window_screen_rect = applied_widget_rect_;
-  }
-
-  modified_resize_params.screen_info.deviceScaleFactor =
-      emulation_params_.deviceScaleFactor
-          ? emulation_params_.deviceScaleFactor
-          : original_screen_info().deviceScaleFactor;
-
-  // 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.
-  blink::WebDeviceEmulationParams modified_emulation_params = emulation_params_;
-  modified_emulation_params.deviceScaleFactor =
-      original_screen_info().deviceScaleFactor;
-  modified_emulation_params.offset =
-      blink::WebFloatPoint(offset_.x(), offset_.y());
-  modified_emulation_params.scale = scale_;
-  delegate_->SetScreenMetricsEmulationParameters(true,
-                                                 modified_emulation_params);
-
-  delegate_->SetScreenRects(applied_widget_rect_, window_screen_rect);
-
-  modified_resize_params.physical_backing_size =
-      gfx::ScaleToCeiledSize(original_resize_params_.new_size,
-                             original_screen_info().deviceScaleFactor);
-  modified_resize_params.new_size = applied_widget_rect_.size();
-  modified_resize_params.visible_viewport_size = applied_widget_rect_.size();
-  modified_resize_params.needs_resize_ack = false;
-  delegate_->Resize(modified_resize_params);
-}
-
-void RenderWidgetScreenMetricsEmulator::OnResize(const ResizeParams& params) {
-  original_resize_params_ = params;
-  Apply();
-
-  if (params.needs_resize_ack)
-    delegate_->Redraw();
-}
-
-void RenderWidgetScreenMetricsEmulator::OnUpdateScreenRects(
-    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 (emulation_params_.screenPosition ==
-      blink::WebDeviceEmulationParams::Desktop) {
-    Apply();
-  }
-}
-
-void RenderWidgetScreenMetricsEmulator::OnShowContextMenu(
-    ContextMenuParams* params) {
-  params->x *= scale_;
-  params->x += offset_.x();
-  params->y *= scale_;
-  params->y += offset_.y();
-}
-
-gfx::Rect RenderWidgetScreenMetricsEmulator::AdjustValidationMessageAnchor(
-    const gfx::Rect& anchor) {
-  gfx::Rect scaled = gfx::ScaleToEnclosedRect(anchor, scale_);
-  scaled.set_x(scaled.x() + offset_.x());
-  scaled.set_y(scaled.y() + offset_.y());
-  return scaled;
-}
-
-}  // namespace content
diff --git a/content/renderer/devtools/render_widget_screen_metrics_emulator.h b/content/renderer/devtools/render_widget_screen_metrics_emulator.h
deleted file mode 100644
index 8288dfa..0000000
--- a/content/renderer/devtools/render_widget_screen_metrics_emulator.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2016 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.
-
-#ifndef CONTENT_RENDERER_DEVTOOLS_RENDER_WIDGET_SCREEN_METRICS_EMULATOR_H_
-#define CONTENT_RENDERER_DEVTOOLS_RENDER_WIDGET_SCREEN_METRICS_EMULATOR_H_
-
-#include "base/memory/scoped_ptr.h"
-#include "content/common/resize_params.h"
-#include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
-
-namespace gfx {
-class PointF;
-class Rect;
-}
-
-namespace content {
-
-class RenderWidgetScreenMetricsEmulatorDelegate;
-struct ContextMenuParams;
-
-// RenderWidgetScreenMetricsEmulator class manages screen emulation inside a
-// RenderWidget. This includes resizing, placing view on the screen at desired
-// position, changing device scale factor, and scaling down the whole
-// widget if required to fit into the browser window.
-class RenderWidgetScreenMetricsEmulator {
- public:
-  RenderWidgetScreenMetricsEmulator(
-      RenderWidgetScreenMetricsEmulatorDelegate* delegate,
-      const blink::WebDeviceEmulationParams& params,
-      const ResizeParams& resize_params,
-      const gfx::Rect& view_screen_rect,
-      const gfx::Rect& window_screen_rect);
-  virtual ~RenderWidgetScreenMetricsEmulator();
-
-  // Scale and offset used to convert between host coordinates
-  // and webwidget coordinates.
-  const gfx::Size& original_size() const {
-    return original_resize_params_.new_size;
-  }
-
-  float scale() const { return scale_; }
-  const gfx::PointF& offset() const { return offset_; }
-  const gfx::Rect& applied_widget_rect() const { return applied_widget_rect_; }
-  const blink::WebScreenInfo& original_screen_info() const {
-    return original_resize_params_.screen_info;
-  }
-  const gfx::Rect& original_screen_rect() const {
-    return original_view_screen_rect_;
-  }
-
-  void ChangeEmulationParams(const blink::WebDeviceEmulationParams& params);
-
-  // The following methods alter handlers' behavior for messages related to
-  // widget size and position.
-  void OnResize(const ResizeParams& params);
-  void OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
-                           const gfx::Rect& window_screen_rect);
-  void OnShowContextMenu(ContextMenuParams* params);
-  gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
-
- private:
-  // Apply original_resize_params_
-  void Apply();
-
-  RenderWidgetScreenMetricsEmulatorDelegate* const delegate_;
-
-  // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
-  blink::WebDeviceEmulationParams emulation_params_;
-
-  // The computed scale and offset used to fit widget into browser window.
-  float scale_;
-  gfx::PointF offset_;
-
-  // Widget rect as passed to webwidget.
-  gfx::Rect applied_widget_rect_;
-
-  // Original values to restore back after emulation ends.
-  ResizeParams original_resize_params_;
-  gfx::Rect original_view_screen_rect_;
-  gfx::Rect original_window_screen_rect_;
-
-  DISALLOW_COPY_AND_ASSIGN(RenderWidgetScreenMetricsEmulator);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_RENDERER_DEVTOOLS_RENDER_WIDGET_SCREEN_METRICS_EMULATOR_H_
diff --git a/content/renderer/devtools/render_widget_screen_metrics_emulator_delegate.h b/content/renderer/devtools/render_widget_screen_metrics_emulator_delegate.h
deleted file mode 100644
index af79f19..0000000
--- a/content/renderer/devtools/render_widget_screen_metrics_emulator_delegate.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2016 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.
-
-#ifndef CONTENT_RENDERER_DEVTOOLS_RENDER_WIDGET_SCREEN_METRICS_EMULATOR_DELEGATE_H_
-#define CONTENT_RENDERER_DEVTOOLS_RENDER_WIDGET_SCREEN_METRICS_EMULATOR_DELEGATE_H_
-
-#include "content/common/content_export.h"
-
-namespace blink {
-struct WebDeviceEmulationParams;
-}
-
-namespace content {
-
-struct ResizeParams;
-
-// Consumers of RenderWidgetScreenMetricsEmulatorDelegate implement this
-// delegate in order to transport emulation information across processes.
-class CONTENT_EXPORT RenderWidgetScreenMetricsEmulatorDelegate {
- public:
-  // Requests a full redraw of the contents of the renderer.
-  virtual void Redraw() = 0;
-
-  // Resizes the Widget with the provided |resize_params|.
-  virtual void Resize(const ResizeParams& resize_params) = 0;
-
-  // Passes device emulation parameters to the delegate.
-  virtual void SetScreenMetricsEmulationParameters(
-      bool enabled,
-      const blink::WebDeviceEmulationParams& params) = 0;
-
-  // Passes new view bounds and window bounds in screen coordinates to the
-  // delegate.
-  virtual void SetScreenRects(const gfx::Rect& view_screen_rect,
-                              const gfx::Rect& window_screen_rect) = 0;
-
- protected:
-  virtual ~RenderWidgetScreenMetricsEmulatorDelegate() {}
-};
-
-}  // namespace content
-
-#endif  // CONTENT_RENDERER_DEVTOOLS_RENDER_WIDGET_SCREEN_METRICS_EMULATOR_DELEGATE_H_
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index e2e7603..dc17687 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -2533,18 +2533,15 @@ void RenderViewImpl::OnDisableAutoResize(const gfx::Size& new_size) {
   webview()->disableAutoResizeMode();
 
   if (!new_size.IsEmpty()) {
-    ResizeParams resize_params;
-    resize_params.new_size = new_size;
-    resize_params.physical_backing_size = physical_backing_size_;
-    resize_params.top_controls_shrink_blink_size =
-        top_controls_shrink_blink_size_;
-    resize_params.top_controls_height = top_controls_height_;
-    resize_params.visible_viewport_size = visible_viewport_size_;
-    resize_params.resizer_rect = resizer_rect_;
-    resize_params.is_fullscreen_granted = is_fullscreen_granted();
-    resize_params.display_mode = display_mode_;
-    resize_params.needs_resize_ack = false;
-    Resize(resize_params);
+    Resize(new_size,
+           physical_backing_size_,
+           top_controls_shrink_blink_size_,
+           top_controls_height_,
+           visible_viewport_size_,
+           resizer_rect_,
+           is_fullscreen_granted_,
+           display_mode_,
+           NO_RESIZE_ACK);
   }
 }
 
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index d3d5433..592a57c 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -41,7 +41,6 @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/renderer/cursor_utils.h"
-#include "content/renderer/devtools/render_widget_screen_metrics_emulator.h"
 #include "content/renderer/external_popup_menu.h"
 #include "content/renderer/gpu/compositor_output_surface.h"
 #include "content/renderer/gpu/delegated_compositor_output_surface.h"
@@ -203,6 +202,244 @@ content::RenderWidgetInputHandlerDelegate* GetRenderWidgetInputHandlerDelegate(
 
 namespace content {
 
+// RenderWidget::ScreenMetricsEmulator ----------------------------------------
+
+class RenderWidget::ScreenMetricsEmulator {
+ public:
+  ScreenMetricsEmulator(
+      RenderWidget* widget,
+      const WebDeviceEmulationParams& params);
+  virtual ~ScreenMetricsEmulator();
+
+  // Scale and offset used to convert between host coordinates
+  // and webwidget coordinates.
+  float scale() { return scale_; }
+  gfx::PointF offset() { return offset_; }
+  gfx::Rect applied_widget_rect() const { return applied_widget_rect_; }
+  gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
+  const WebScreenInfo& original_screen_info() { return original_screen_info_; }
+
+  void ChangeEmulationParams(
+      const WebDeviceEmulationParams& params);
+
+  // The following methods alter handlers' behavior for messages related to
+  // widget size and position.
+  void OnResizeMessage(const ResizeParams& params);
+  void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
+                                  const gfx::Rect& window_screen_rect);
+  void OnShowContextMenu(ContextMenuParams* params);
+  gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
+
+ private:
+  void Reapply();
+  void Apply(bool top_controls_shrink_blink_size,
+             float top_controls_height,
+             gfx::Rect resizer_rect,
+             bool is_fullscreen_granted,
+             blink::WebDisplayMode display_mode);
+
+  RenderWidget* widget_;
+
+  // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
+  WebDeviceEmulationParams params_;
+
+  // The computed scale and offset used to fit widget into browser window.
+  float scale_;
+  gfx::PointF offset_;
+
+  // Widget rect as passed to webwidget.
+  gfx::Rect applied_widget_rect_;
+
+  // Original values to restore back after emulation ends.
+  gfx::Size original_size_;
+  gfx::Size original_physical_backing_size_;
+  gfx::Size original_visible_viewport_size_;
+  blink::WebScreenInfo original_screen_info_;
+  gfx::Rect original_view_screen_rect_;
+  gfx::Rect original_window_screen_rect_;
+};
+
+RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
+    RenderWidget* widget,
+    const WebDeviceEmulationParams& params)
+    : widget_(widget),
+      params_(params),
+      scale_(1.f) {
+  original_size_ = widget_->size_;
+  original_physical_backing_size_ = widget_->physical_backing_size_;
+  original_visible_viewport_size_ = widget_->visible_viewport_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_->top_controls_shrink_blink_size_,
+        widget_->top_controls_height_,
+        widget_->resizer_rect_,
+        widget_->is_fullscreen_granted_,
+        widget_->display_mode_);
+}
+
+RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
+  widget_->screen_info_ = original_screen_info_;
+
+  widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
+  widget_->SetScreenMetricsEmulationParameters(false, params_);
+  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_->top_controls_shrink_blink_size_,
+                  widget_->top_controls_height_,
+                  original_visible_viewport_size_,
+                  widget_->resizer_rect_,
+                  widget_->is_fullscreen_granted_,
+                  widget_->display_mode_,
+                  NO_RESIZE_ACK);
+}
+
+void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
+    const WebDeviceEmulationParams& params) {
+  params_ = params;
+  Reapply();
+}
+
+void RenderWidget::ScreenMetricsEmulator::Reapply() {
+  Apply(widget_->top_controls_shrink_blink_size_,
+        widget_->top_controls_height_,
+        widget_->resizer_rect_,
+        widget_->is_fullscreen_granted_,
+        widget_->display_mode_);
+}
+
+void RenderWidget::ScreenMetricsEmulator::Apply(
+    bool top_controls_shrink_blink_size,
+    float top_controls_height,
+    gfx::Rect resizer_rect,
+    bool is_fullscreen_granted,
+    blink::WebDisplayMode display_mode) {
+  applied_widget_rect_.set_size(gfx::Size(params_.viewSize));
+  if (!applied_widget_rect_.width())
+    applied_widget_rect_.set_width(original_size_.width());
+  if (!applied_widget_rect_.height())
+    applied_widget_rect_.set_height(original_size_.height());
+
+  if (params_.fitToView && !original_size_.IsEmpty()) {
+    int original_width = std::max(original_size_.width(), 1);
+    int original_height = std::max(original_size_.height(), 1);
+    float width_ratio =
+        static_cast<float>(applied_widget_rect_.width()) / original_width;
+    float height_ratio =
+        static_cast<float>(applied_widget_rect_.height()) / original_height;
+    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_ * applied_widget_rect_.width()) / 2);
+    offset_.set_y(
+        (original_size_.height() - scale_ * applied_widget_rect_.height()) / 2);
+  } else {
+    scale_ = params_.scale;
+    offset_.SetPoint(params_.offset.x, params_.offset.y);
+    if (!params_.viewSize.width && !params_.viewSize.height && scale_) {
+      applied_widget_rect_.set_size(gfx::ScaleToRoundedSize(
+          original_size_, 1.f / scale_));
+    }
+  }
+
+  if (params_.screenPosition == WebDeviceEmulationParams::Desktop) {
+    applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
+    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 {
+    applied_widget_rect_.set_origin(params_.viewPosition);
+    gfx::Rect screen_rect = applied_widget_rect_;
+    if (!params_.screenSize.isEmpty()) {
+      screen_rect =
+          gfx::Rect(0, 0, params_.screenSize.width, params_.screenSize.height);
+    }
+    widget_->screen_info_.rect = screen_rect;
+    widget_->screen_info_.availableRect = screen_rect;
+    widget_->window_screen_rect_ = applied_widget_rect_;
+  }
+
+  float applied_device_scale_factor = params_.deviceScaleFactor ?
+      params_.deviceScaleFactor : 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.
+  blink::WebDeviceEmulationParams modified_params = params_;
+  modified_params.deviceScaleFactor = original_screen_info_.deviceScaleFactor;
+  modified_params.offset = blink::WebFloatPoint(offset_.x(), offset_.y());
+  modified_params.scale = scale_;
+  widget_->SetScreenMetricsEmulationParameters(true, modified_params);
+
+  widget_->SetDeviceScaleFactor(applied_device_scale_factor);
+  widget_->view_screen_rect_ = applied_widget_rect_;
+
+  gfx::Size physical_backing_size = gfx::ScaleToCeiledSize(
+      original_size_, original_screen_info_.deviceScaleFactor);
+  widget_->Resize(applied_widget_rect_.size(),
+                  physical_backing_size,
+                  top_controls_shrink_blink_size,
+                  top_controls_height,
+                  applied_widget_rect_.size(),
+                  resizer_rect,
+                  is_fullscreen_granted,
+                  display_mode,
+                  NO_RESIZE_ACK);
+}
+
+void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
+    const ResizeParams& 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;
+  original_visible_viewport_size_ = params.visible_viewport_size;
+  Apply(params.top_controls_shrink_blink_size,
+        params.top_controls_height,
+        params.resizer_rect,
+        params.is_fullscreen_granted,
+        params.display_mode);
+
+  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 (params_.screenPosition == WebDeviceEmulationParams::Desktop)
+    Reapply();
+}
+
+void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
+    ContextMenuParams* params) {
+  params->x *= scale_;
+  params->x += offset_.x();
+  params->y *= scale_;
+  params->y += offset_.y();
+}
+
+gfx::Rect RenderWidget::ScreenMetricsEmulator::AdjustValidationMessageAnchor(
+    const gfx::Rect& anchor) {
+  gfx::Rect scaled = gfx::ScaleToEnclosedRect(anchor, scale_);
+  scaled.set_x(scaled.x() + offset_.x());
+  scaled.set_y(scaled.y() + offset_.y());
+  return scaled;
+}
+
 // RenderWidget ---------------------------------------------------------------
 
 RenderWidget::RenderWidget(CompositorDependencies* compositor_deps,
@@ -416,7 +653,7 @@ void RenderWidget::WasSwappedOut() {
 }
 
 void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
-    RenderWidgetScreenMetricsEmulator* emulator) {
+    ScreenMetricsEmulator* emulator) {
   popup_origin_scale_for_emulation_ = emulator->scale();
   popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
   popup_screen_origin_for_emulation_ = gfx::Point(
@@ -432,10 +669,16 @@ gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
   return anchor;
 }
 
+void RenderWidget::SetScreenMetricsEmulationParameters(
+    bool enabled,
+    const blink::WebDeviceEmulationParams& params) {
+  // This is only supported in RenderView.
+  NOTREACHED();
+}
+
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
-    ExternalPopupMenu* popup,
-    RenderWidgetScreenMetricsEmulator* emulator) {
+    ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
   popup->SetOriginScaleAndOffsetForEmulation(
       emulator->scale(), emulator->offset());
 }
@@ -502,21 +745,97 @@ bool RenderWidget::Send(IPC::Message* message) {
   return RenderThread::Get()->Send(message);
 }
 
+void RenderWidget::Resize(const gfx::Size& new_size,
+                          const gfx::Size& physical_backing_size,
+                          bool top_controls_shrink_blink_size,
+                          float top_controls_height,
+                          const gfx::Size& visible_viewport_size,
+                          const gfx::Rect& resizer_rect,
+                          bool is_fullscreen_granted,
+                          blink::WebDisplayMode display_mode,
+                          const ResizeAck resize_ack) {
+  if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
+    // A resize ack shouldn't be requested if we have not ACK'd the previous
+    // one.
+    DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
+    DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
+  }
+
+  // Ignore this during shutdown.
+  if (!webwidget_)
+    return;
+
+  if (compositor_)
+    compositor_->setViewportSize(physical_backing_size);
+
+  bool resized = size_ != new_size ||
+      physical_backing_size_ != physical_backing_size;
+
+  size_ = new_size;
+  physical_backing_size_ = physical_backing_size;
+
+  top_controls_shrink_blink_size_ = top_controls_shrink_blink_size;
+  top_controls_height_ = top_controls_height;
+  visible_viewport_size_ = visible_viewport_size;
+  resizer_rect_ = resizer_rect;
+
+  // NOTE: We may have entered fullscreen mode without changing our size.
+  bool fullscreen_change = is_fullscreen_granted_ != is_fullscreen_granted;
+  is_fullscreen_granted_ = is_fullscreen_granted;
+  display_mode_ = display_mode;
+
+  webwidget_->setTopControlsHeight(top_controls_height,
+                                   top_controls_shrink_blink_size_);
+
+  if (resized) {
+    gfx::Size new_widget_size =
+        IsUseZoomForDSFEnabled() ?  physical_backing_size_ : size_;
+    // When resizing, we want to wait to paint before ACK'ing the resize.  This
+    // ensures that we only resize as fast as we can paint.  We only need to
+    // send an ACK if we are resized to a non-empty rect.
+    webwidget_->resize(new_widget_size);
+  }
+  WebSize visual_viewport_size;
+
+  if (IsUseZoomForDSFEnabled()) {
+    visual_viewport_size =
+        gfx::ScaleToCeiledSize(visible_viewport_size, device_scale_factor_);
+  } else {
+    visual_viewport_size = visible_viewport_size_;
+  }
+
+  webwidget()->resizeVisualViewport(visual_viewport_size);
+
+  if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
+    // In this case there is no paint/composite and therefore no
+    // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
+    // ack through a fake ViewHostMsg_UpdateRect or a different message.
+    DCHECK_EQ(resize_ack, NO_RESIZE_ACK);
+  }
+
+  // Send the Resize_ACK flag once we paint again if requested.
+  if (resize_ack == SEND_RESIZE_ACK)
+    set_next_paint_is_resize_ack();
+
+  if (fullscreen_change)
+    DidToggleFullscreen();
+
+  // If a resize ack is requested and it isn't set-up, then no more resizes will
+  // come in and in general things will go wrong.
+  DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
+}
+
 void RenderWidget::SetWindowRectSynchronously(
     const gfx::Rect& new_window_rect) {
-  ResizeParams params;
-  params.new_size = new_window_rect.size();
-  params.physical_backing_size =
-      gfx::ScaleToCeiledSize(new_window_rect.size(), device_scale_factor_);
-  params.top_controls_shrink_blink_size = top_controls_shrink_blink_size_;
-  params.top_controls_height = top_controls_height_;
-  params.visible_viewport_size = new_window_rect.size();
-  params.resizer_rect = gfx::Rect();
-  params.is_fullscreen_granted = is_fullscreen_granted_;
-  params.display_mode = display_mode_;
-  params.needs_resize_ack = false;
-  Resize(params);
-
+  Resize(new_window_rect.size(),
+         gfx::ScaleToCeiledSize(new_window_rect.size(), device_scale_factor_),
+         top_controls_shrink_blink_size_,
+         top_controls_height_,
+         new_window_rect.size(),
+         gfx::Rect(),
+         is_fullscreen_granted_,
+         display_mode_,
+         NO_RESIZE_ACK);
   view_screen_rect_ = new_window_rect;
   window_screen_rect_ = new_window_rect;
   if (!did_show_)
@@ -562,14 +881,24 @@ void RenderWidget::OnResize(const ResizeParams& params) {
     return;
 
   if (screen_metrics_emulator_) {
-    screen_metrics_emulator_->OnResize(params);
+    screen_metrics_emulator_->OnResizeMessage(params);
     return;
   }
 
   bool orientation_changed =
       screen_info_.orientationAngle != params.screen_info.orientationAngle;
 
-  Resize(params);
+  screen_info_ = params.screen_info;
+  SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
+  Resize(params.new_size,
+         params.physical_backing_size,
+         params.top_controls_shrink_blink_size,
+         params.top_controls_height,
+         params.visible_viewport_size,
+         params.resizer_rect,
+         params.is_fullscreen_granted,
+         params.display_mode,
+         params.needs_resize_ack ? SEND_RESIZE_ACK : NO_RESIZE_ACK);
 
   if (orientation_changed)
     OnOrientationChange();
@@ -577,23 +906,10 @@ void RenderWidget::OnResize(const ResizeParams& params) {
 
 void RenderWidget::OnEnableDeviceEmulation(
    const blink::WebDeviceEmulationParams& params) {
-  if (!screen_metrics_emulator_) {
-    ResizeParams resize_params;
-    resize_params.new_size = size_;
-    resize_params.physical_backing_size = physical_backing_size_;
-    resize_params.visible_viewport_size = visible_viewport_size_;
-    resize_params.screen_info = screen_info_;
-    resize_params.top_controls_shrink_blink_size =
-        top_controls_shrink_blink_size_;
-    resize_params.top_controls_height = top_controls_height_;
-    resize_params.resizer_rect = resizer_rect_;
-    resize_params.is_fullscreen_granted = is_fullscreen_granted_;
-    resize_params.display_mode = display_mode_;
-    screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
-        this, params, resize_params, view_screen_rect_, window_screen_rect_));
-  } else {
+  if (!screen_metrics_emulator_)
+    screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
+  else
     screen_metrics_emulator_->ChangeEmulationParams(params);
-  }
 }
 
 void RenderWidget::OnDisableDeviceEmulation() {
@@ -1038,103 +1354,6 @@ bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// RenderWidgetScreenMetricsDelegate
-
-void RenderWidget::Redraw() {
-  set_next_paint_is_resize_ack();
-  if (compositor_)
-    compositor_->SetNeedsRedrawRect(gfx::Rect(size_));
-}
-
-void RenderWidget::Resize(const ResizeParams& params) {
-  screen_info_ = params.screen_info;
-  SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
-
-  if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
-    // A resize ack shouldn't be requested if we have not ACK'd the previous
-    // one.
-    DCHECK(!params.needs_resize_ack || !next_paint_is_resize_ack());
-  }
-
-  // Ignore this during shutdown.
-  if (!webwidget_)
-    return;
-
-  if (compositor_)
-    compositor_->setViewportSize(params.physical_backing_size);
-
-  bool resized = size_ != params.new_size ||
-                 physical_backing_size_ != params.physical_backing_size;
-
-  size_ = params.new_size;
-  physical_backing_size_ = params.physical_backing_size;
-
-  top_controls_shrink_blink_size_ = params.top_controls_shrink_blink_size;
-  top_controls_height_ = params.top_controls_height;
-  visible_viewport_size_ = params.visible_viewport_size;
-  resizer_rect_ = params.resizer_rect;
-
-  // NOTE: We may have entered fullscreen mode without changing our size.
-  bool fullscreen_change =
-      is_fullscreen_granted_ != params.is_fullscreen_granted;
-  is_fullscreen_granted_ = params.is_fullscreen_granted;
-  display_mode_ = params.display_mode;
-
-  webwidget_->setTopControlsHeight(params.top_controls_height,
-                                   top_controls_shrink_blink_size_);
-
-  if (resized) {
-    gfx::Size new_widget_size =
-        IsUseZoomForDSFEnabled() ? physical_backing_size_ : size_;
-    // When resizing, we want to wait to paint before ACK'ing the resize.  This
-    // ensures that we only resize as fast as we can paint.  We only need to
-    // send an ACK if we are resized to a non-empty rect.
-    webwidget_->resize(new_widget_size);
-  }
-  WebSize visual_viewport_size;
-
-  if (IsUseZoomForDSFEnabled()) {
-    visual_viewport_size = gfx::ScaleToCeiledSize(params.visible_viewport_size,
-                                                  device_scale_factor_);
-  } else {
-    visual_viewport_size = visible_viewport_size_;
-  }
-
-  webwidget()->resizeVisualViewport(visual_viewport_size);
-
-  if (params.new_size.IsEmpty() || params.physical_backing_size.IsEmpty()) {
-    // In this case there is no paint/composite and therefore no
-    // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
-    // ack through a fake ViewHostMsg_UpdateRect or a different message.
-    DCHECK(!params.needs_resize_ack);
-  }
-
-  // Send the Resize_ACK flag once we paint again if requested.
-  if (params.needs_resize_ack)
-    set_next_paint_is_resize_ack();
-
-  if (fullscreen_change)
-    DidToggleFullscreen();
-
-  // If a resize ack is requested and it isn't set-up, then no more resizes will
-  // come in and in general things will go wrong.
-  DCHECK(!params.needs_resize_ack || next_paint_is_resize_ack());
-}
-
-void RenderWidget::SetScreenMetricsEmulationParameters(
-    bool enabled,
-    const blink::WebDeviceEmulationParams& params) {
-  // This is only supported in RenderView.
-  NOTREACHED();
-}
-
-void RenderWidget::SetScreenRects(const gfx::Rect& view_screen_rect,
-                                  const gfx::Rect& window_screen_rect) {
-  view_screen_rect_ = view_screen_rect;
-  window_screen_rect_ = window_screen_rect;
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // WebWidgetClient
 
 void RenderWidget::didAutoResize(const WebSize& new_size) {
@@ -1498,10 +1717,11 @@ void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
 void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
                                        const gfx::Rect& window_screen_rect) {
   if (screen_metrics_emulator_) {
-    screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect,
-                                                  window_screen_rect);
+    screen_metrics_emulator_->OnUpdateScreenRectsMessage(
+        view_screen_rect, window_screen_rect);
   } else {
-    SetScreenRects(view_screen_rect, window_screen_rect);
+    view_screen_rect_ = view_screen_rect;
+    window_screen_rect_ = window_screen_rect;
   }
   Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
 }
diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h
index 1185fa2b..3f083e7 100644
--- a/content/renderer/render_widget.h
+++ b/content/renderer/render_widget.h
@@ -23,7 +23,6 @@
 #include "content/common/cursors/webcursor.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/input/synthetic_gesture_params.h"
-#include "content/renderer/devtools/render_widget_screen_metrics_emulator_delegate.h"
 #include "content/renderer/gpu/render_widget_compositor_delegate.h"
 #include "content/renderer/input/render_widget_input_handler.h"
 #include "content/renderer/input/render_widget_input_handler_delegate.h"
@@ -86,7 +85,6 @@ class ImeEventGuard;
 class RenderFrameImpl;
 class RenderFrameProxy;
 class RenderWidgetCompositor;
-class RenderWidgetScreenMetricsEmulator;
 class ResizingModeSelector;
 struct ContextMenuParams;
 struct DidOverscrollParams;
@@ -107,7 +105,6 @@ class CONTENT_EXPORT RenderWidget
       NON_EXPORTED_BASE(virtual public blink::WebWidgetClient),
       public RenderWidgetCompositorDelegate,
       public RenderWidgetInputHandlerDelegate,
-      public RenderWidgetScreenMetricsEmulatorDelegate,
       public base::RefCounted<RenderWidget> {
  public:
   // Creates a new RenderWidget.  The opener_id is the routing ID of the
@@ -134,7 +131,7 @@ class CONTENT_EXPORT RenderWidget
 
   CompositorDependencies* compositor_deps() const { return compositor_deps_; }
   blink::WebWidget* webwidget() const { return webwidget_; }
-  const gfx::Size& size() const { return size_; }
+  gfx::Size size() const { return size_; }
   bool is_fullscreen_granted() const { return is_fullscreen_granted_; }
   blink::WebDisplayMode display_mode() const { return display_mode_; }
   bool is_hidden() const { return is_hidden_; }
@@ -213,15 +210,6 @@ class CONTENT_EXPORT RenderWidget
   bool WillHandleGestureEvent(const blink::WebGestureEvent& event) override;
   bool WillHandleMouseEvent(const blink::WebMouseEvent& event) override;
 
-  // RenderWidgetScreenMetricsDelegate
-  void Redraw() override;
-  void Resize(const ResizeParams& resize_params) override;
-  void SetScreenMetricsEmulationParameters(
-      bool enabled,
-      const blink::WebDeviceEmulationParams& params) override;
-  void SetScreenRects(const gfx::Rect& view_screen_rect,
-                      const gfx::Rect& window_screen_rect) override;
-
   // blink::WebWidgetClient
   void didAutoResize(const blink::WebSize& new_size) override;
   void initializeLayerTreeView() override;
@@ -324,9 +312,13 @@ class CONTENT_EXPORT RenderWidget
   // Returns whether we currently should handle an IME event.
   bool ShouldHandleImeEvent();
 
-  void SetPopupOriginAdjustmentsForEmulation(
-      RenderWidgetScreenMetricsEmulator* emulator);
+  // ScreenMetricsEmulator class manages screen emulation inside a render
+  // widget. This includes resizing, placing view on the screen at desired
+  // position, changing device scale factor, and scaling down the whole
+  // widget if required to fit into the browser window.
+  class ScreenMetricsEmulator;
 
+  void SetPopupOriginAdjustmentsForEmulation(ScreenMetricsEmulator* emulator);
   gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
 
 
@@ -402,12 +394,24 @@ class CONTENT_EXPORT RenderWidget
   // Close the underlying WebWidget.
   virtual void Close();
 
+  // Resizes the render widget.
+  void Resize(const gfx::Size& new_size,
+              const gfx::Size& physical_backing_size,
+              bool top_controls_shrink_blink_size,
+              float top_controls_height,
+              const gfx::Size& visible_viewport_size,
+              const gfx::Rect& resizer_rect,
+              bool is_fullscreen_granted,
+              blink::WebDisplayMode display_mode,
+              ResizeAck resize_ack);
   // Used to force the size of a window when running layout tests.
   void SetWindowRectSynchronously(const gfx::Rect& new_window_rect);
+  virtual void SetScreenMetricsEmulationParameters(
+      bool enabled,
+      const blink::WebDeviceEmulationParams& params);
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   void SetExternalPopupOriginAdjustmentsForEmulation(
-      ExternalPopupMenu* popup,
-      RenderWidgetScreenMetricsEmulator* emulator);
+      ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator);
 #endif
 
   // RenderWidget IPC message handlers
@@ -726,7 +730,7 @@ class CONTENT_EXPORT RenderWidget
   std::deque<blink::WebTextInputInfo> text_input_info_history_;
 #endif
 
-  scoped_ptr<RenderWidgetScreenMetricsEmulator> screen_metrics_emulator_;
+  scoped_ptr<ScreenMetricsEmulator> screen_metrics_emulator_;
 
   // Popups may be displaced when screen metrics emulation is enabled.
   // These values are used to properly adjust popup position.