Move DeviceEmulation into WebFrameWidgetBase.

Move the emulation code into the base class. The construction of the
emulator is gated on a ForMainFrame check.

BUG=1097816

Change-Id: Iec921f6639caad1f216a9429e6a2c96b095c5321
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2533907
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#827293}

third_party/blink/renderer/core/frame/screen_metrics_emulator.cc

@@ -6,18 +6,18 @@
 
 #include "base/numerics/safe_conversions.h"
 #include "third_party/blink/public/common/widget/visual_properties.h"
-#include "third_party/blink/renderer/core/frame/web_view_frame_widget.h"
+#include "third_party/blink/renderer/core/frame/web_frame_widget_base.h"
 
 namespace blink {
 
 ScreenMetricsEmulator::ScreenMetricsEmulator(
-    WebViewFrameWidget* delegate,
+    WebFrameWidgetBase* frame_widget,
     const ScreenInfo& screen_info,
     const gfx::Size& widget_size,
     const gfx::Size& visible_viewport_size,
     const gfx::Rect& view_screen_rect,
     const gfx::Rect& window_screen_rect)
-    : delegate_(delegate),
+    : frame_widget_(frame_widget),
       original_screen_info_(screen_info),
       original_widget_size_(widget_size),
       original_visible_viewport_size_(visible_viewport_size),
@@ -25,15 +25,16 @@ ScreenMetricsEmulator::ScreenMetricsEmulator(
       original_window_screen_rect_(window_screen_rect) {}
 
 void ScreenMetricsEmulator::Trace(Visitor* vistor) const {
-  vistor->Trace(delegate_);
+  vistor->Trace(frame_widget_);
 }
 
 void ScreenMetricsEmulator::DisableAndApply() {
-  delegate_->SetScreenMetricsEmulationParameters(false, emulation_params_);
-  delegate_->SetScreenRects(original_view_screen_rect_,
+  frame_widget_->SetScreenMetricsEmulationParameters(false, emulation_params_);
+  frame_widget_->SetScreenRects(original_view_screen_rect_,
                                 original_window_screen_rect_);
-  delegate_->SetWindowSegments(original_root_window_segments_);
-  delegate_->SetScreenInfoAndSize(original_screen_info_, original_widget_size_,
+  frame_widget_->SetWindowSegments(original_root_window_segments_);
+  frame_widget_->SetScreenInfoAndSize(original_screen_info_,
+                                      original_widget_size_,
                                       original_visible_viewport_size_);
 }
 
@@ -126,10 +127,10 @@ void ScreenMetricsEmulator::Apply() {
   DeviceEmulationParams modified_emulation_params = emulation_params_;
   modified_emulation_params.device_scale_factor =
       original_screen_info().device_scale_factor;
-  delegate_->SetScreenMetricsEmulationParameters(
+  frame_widget_->SetScreenMetricsEmulationParameters(
       true, std::move(modified_emulation_params));
 
-  delegate_->SetScreenRects(gfx::Rect(widget_pos, widget_size),
+  frame_widget_->SetScreenRects(gfx::Rect(widget_pos, widget_size),
                                 gfx::Rect(window_pos, window_size));
 
   // If there are no emulated window segments, use the emulated widget size
@@ -137,11 +138,11 @@ void ScreenMetricsEmulator::Apply() {
   // have a single segment that matches the widget size.
   bool has_emulated_segments = emulation_params_.window_segments.size();
   if (has_emulated_segments) {
-    delegate_->SetWindowSegments(emulation_params_.window_segments);
+    frame_widget_->SetWindowSegments(emulation_params_.window_segments);
   } else {
     std::vector<gfx::Rect> emulated_segments{
         {0, 0, widget_size.width(), widget_size.height()}};
-    delegate_->SetWindowSegments(emulated_segments);
+    frame_widget_->SetWindowSegments(emulated_segments);
   }
 
   ScreenInfo screen_info = original_screen_info();
@@ -150,7 +151,7 @@ void ScreenMetricsEmulator::Apply() {
   screen_info.available_rect = screen_rect;
   screen_info.orientation_type = orientation_type;
   screen_info.orientation_angle = orientation_angle;
-  delegate_->SetScreenInfoAndSize(screen_info, /*widget_size=*/widget_size,
+  frame_widget_->SetScreenInfoAndSize(screen_info, /*widget_size=*/widget_size,
                                       /*visible_viewport_size=*/widget_size);
 }
 
@@ -158,7 +159,7 @@ void ScreenMetricsEmulator::UpdateVisualProperties(
     const VisualProperties& visual_properties) {
   // Device emulation isn't supported for widgets that have auto resize mode
   // enabled.
-  DCHECK(!delegate_->AutoResizeMode());
+  DCHECK(!frame_widget_->AutoResizeMode());
 
   original_screen_info_ = visual_properties.screen_info;
   original_widget_size_ = visual_properties.new_size;
@@ -170,7 +171,7 @@ void ScreenMetricsEmulator::UpdateVisualProperties(
   // Appy the compositor viewport rect and surface id allocation. The screen
   // info is kept the same as the current ScreenInfo state. The screen info
   // already was updated in |Apply| via |SetScreenInfoAndSize|.
-  delegate_->UpdateSurfaceAndCompositorRect(
+  frame_widget_->UpdateSurfaceAndCompositorRect(
       visual_properties.local_surface_id.value_or(viz::LocalSurfaceId()),
       visual_properties.compositor_viewport_pixel_rect);
 }

third_party/blink/renderer/core/frame/screen_metrics_emulator.h

@@ -17,15 +17,15 @@
 namespace blink {
 
 struct VisualProperties;
-class WebViewFrameWidget;
+class WebFrameWidgetBase;
 
 // ScreenMetricsEmulator class manages screen emulation inside a
-// WebViewFrameWidget. This includes resizing, placing view on the screen at
+// WebFrameWidgetBase. 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 : public GarbageCollected<ScreenMetricsEmulator> {
  public:
-  ScreenMetricsEmulator(WebViewFrameWidget* delegate,
+  ScreenMetricsEmulator(WebFrameWidgetBase* frame_widget,
                         const ScreenInfo& screen_info,
                         const gfx::Size& widget_size,
                         const gfx::Size& visible_viewport_size,
@@ -55,10 +55,10 @@ class ScreenMetricsEmulator : public GarbageCollected<ScreenMetricsEmulator> {
   gfx::Point ViewRectOrigin();
 
   // Disables emulation and applies non-emulated values to the
-  // WebViewFrameWidget. Call this before destroying the ScreenMetricsEmulator.
+  // WebFrameWidgetBase. Call this before destroying the ScreenMetricsEmulator.
   void DisableAndApply();
 
-  // Sets new parameters and applies them to the WebViewFrameWidget.
+  // Sets new parameters and applies them to the WebFrameWidgetBase.
   void ChangeEmulationParams(const DeviceEmulationParams& params);
 
   void UpdateVisualProperties(const VisualProperties& visual_properties);
@@ -77,9 +77,9 @@ class ScreenMetricsEmulator : public GarbageCollected<ScreenMetricsEmulator> {
   // Applies emulated values to the WidgetBase.
   void Apply();
 
-  Member<WebViewFrameWidget> const delegate_;
+  Member<WebFrameWidgetBase> const frame_widget_;
 
-  // Parameters as passed by WebViewFrameWidget::EnableDeviceEmulation.
+  // Parameters as passed by `WebFrameWidgetBase::EnableDeviceEmulation()`
   DeviceEmulationParams emulation_params_;
 
   // Original values to restore back after emulation ends.

third_party/blink/renderer/core/frame/web_frame_widget_base.cc

@@ -812,6 +812,7 @@ void WebFrameWidgetBase::Trace(Visitor* visitor) const {
   visitor->Trace(receiver_);
   visitor->Trace(input_target_receiver_);
   visitor->Trace(mouse_capture_element_);
+  visitor->Trace(device_emulator_);
 }
 
 void WebFrameWidgetBase::SetNeedsRecalculateRasterScales() {
@@ -1186,6 +1187,28 @@ void WebFrameWidgetBase::ShowContextMenu(
   host_context_menu_location_.reset();
 }
 
+void WebFrameWidgetBase::EnableDeviceEmulation(
+    const DeviceEmulationParams& parameters) {
+  // Device Emaulation is only supported for the main frame.
+  DCHECK(ForMainFrame());
+  if (!device_emulator_) {
+    gfx::Size size_in_dips = widget_base_->BlinkSpaceToFlooredDIPs(Size());
+
+    device_emulator_ = MakeGarbageCollected<ScreenMetricsEmulator>(
+        this, widget_base_->GetScreenInfo(), size_in_dips,
+        widget_base_->VisibleViewportSizeInDIPs(),
+        widget_base_->WidgetScreenRect(), widget_base_->WindowScreenRect());
+  }
+  device_emulator_->ChangeEmulationParams(parameters);
+}
+
+void WebFrameWidgetBase::DisableDeviceEmulation() {
+  if (!device_emulator_)
+    return;
+  device_emulator_->DisableAndApply();
+  device_emulator_ = nullptr;
+}
+
 base::Optional<gfx::Point>
 WebFrameWidgetBase::GetAndResetContextMenuLocation() {
   return std::move(host_context_menu_location_);
@@ -1781,6 +1804,12 @@ WebString WebFrameWidgetBase::GetLastToolTipTextForTesting() const {
   return GetPage()->GetChromeClient().GetLastToolTipTextForTesting();
 }
 
+float WebFrameWidgetBase::GetEmulatorScale() {
+  if (device_emulator_)
+    return device_emulator_->scale();
+  return 1.0f;
+}
+
 void WebFrameWidgetBase::AutoscrollStart(const gfx::PointF& position) {
   GetAssociatedFrameWidgetHost()->AutoscrollStart(std::move(position));
 }
@@ -2725,6 +2754,35 @@ cc::LayerTreeHost* WebFrameWidgetBase::LayerTreeHost() {
   return widget_base_->LayerTreeHost();
 }
 
+ScreenMetricsEmulator* WebFrameWidgetBase::DeviceEmulator() {
+  return device_emulator_;
+}
+
+bool WebFrameWidgetBase::AutoResizeMode() {
+  return View()->AutoResizeMode();
+}
+
+void WebFrameWidgetBase::SetScreenMetricsEmulationParameters(
+    bool enabled,
+    const DeviceEmulationParams& params) {
+  if (enabled)
+    View()->ActivateDevToolsTransform(params);
+  else
+    View()->DeactivateDevToolsTransform();
+}
+
+void WebFrameWidgetBase::SetScreenInfoAndSize(
+    const ScreenInfo& screen_info,
+    const gfx::Size& widget_size_in_dips,
+    const gfx::Size& visible_viewport_size_in_dips) {
+  // Emulation happens on regular main frames which don't use auto-resize mode.
+  DCHECK(!AutoResizeMode());
+
+  UpdateScreenInfo(screen_info);
+  widget_base_->SetVisibleViewportSizeInDIPs(visible_viewport_size_in_dips);
+  Resize(widget_base_->DIPsToCeiledBlinkSpace(widget_size_in_dips));
+}
+
 void WebFrameWidgetBase::NotifyPageScaleFactorChanged(
     float page_scale_factor,
     bool is_pinch_gesture_active) {
@@ -2757,6 +2815,15 @@ void WebFrameWidgetBase::SetPageScaleStateAndLimits(
                                                              minimum, maximum);
 }
 
+bool WebFrameWidgetBase::UpdateScreenRects(
+    const gfx::Rect& widget_screen_rect,
+    const gfx::Rect& window_screen_rect) {
+  if (!device_emulator_)
+    return false;
+  device_emulator_->OnUpdateScreenRects(widget_screen_rect, window_screen_rect);
+  return true;
+}
+
 void WebFrameWidgetBase::OrientationChanged() {
   local_root_->SendOrientationChangeEvent();
 }
@@ -2802,6 +2869,8 @@ void WebFrameWidgetBase::DidUpdateSurfaceAndScreen(
 }
 
 const ScreenInfo& WebFrameWidgetBase::GetOriginalScreenInfo() {
+  if (device_emulator_)
+    return device_emulator_->original_screen_info();
   return widget_base_->GetScreenInfo();
 }
 

third_party/blink/renderer/core/frame/web_frame_widget_base.h

@@ -348,6 +348,7 @@ class CORE_EXPORT WebFrameWidgetBase
   gfx::Size VisibleViewportSizeInDIPs() override;
   bool IsHidden() const override;
   WebString GetLastToolTipTextForTesting() const override;
+  float GetEmulatorScale() override;
 
   // WidgetBaseClient methods.
   void BeginMainFrame(base::TimeTicks last_frame_time) override;
@@ -391,6 +392,8 @@ class CORE_EXPORT WebFrameWidgetBase
   void UpdateVisualProperties(
       const VisualProperties& visual_properties) override;
   void ScheduleAnimationForWebTests() override;
+  bool UpdateScreenRects(const gfx::Rect& widget_screen_rect,
+                         const gfx::Rect& window_screen_rect) override;
   void OrientationChanged() override;
   void DidUpdateSurfaceAndScreen(
       const ScreenInfo& previous_original_screen_info) override;
@@ -442,6 +445,8 @@ class CORE_EXPORT WebFrameWidgetBase
                        const gfx::Point& location) override;
   void SetViewportIntersection(
       mojom::blink::ViewportIntersectionStatePtr intersection_state) override {}
+  void EnableDeviceEmulation(const DeviceEmulationParams& parameters) override;
+  void DisableDeviceEmulation() override;
 
   // Sets the inert bit on an out-of-process iframe, causing it to ignore
   // input.
@@ -589,7 +594,7 @@ class CORE_EXPORT WebFrameWidgetBase
   const viz::LocalSurfaceId& LocalSurfaceIdFromParent();
   cc::LayerTreeHost* LayerTreeHost();
 
-  virtual ScreenMetricsEmulator* DeviceEmulator() { return nullptr; }
+  ScreenMetricsEmulator* DeviceEmulator();
 
   // Called during |UpdateVisualProperties| to apply the new size to the widget.
   virtual void ApplyVisualPropertiesSizing(
@@ -600,6 +605,16 @@ class CORE_EXPORT WebFrameWidgetBase
   virtual void CalculateSelectionBounds(gfx::Rect& anchor_in_root_frame,
                                         gfx::Rect& focus_in_root_frame) = 0;
 
+  // Returns if auto resize mode is enabled.
+  bool AutoResizeMode();
+
+  void SetScreenMetricsEmulationParameters(
+      bool enabled,
+      const blink::DeviceEmulationParams& params);
+  void SetScreenInfoAndSize(const blink::ScreenInfo& screen_info,
+                            const gfx::Size& widget_size,
+                            const gfx::Size& visible_viewport_size);
+
   // Update the surface allocation information, compositor viewport rect and
   // screen info on the widget.
   void UpdateSurfaceAndScreenInfo(
@@ -808,6 +823,11 @@ class CORE_EXPORT WebFrameWidgetBase
   // Metrics for gathering time for commit of compositor frame.
   base::Optional<base::TimeTicks> commit_compositor_frame_start_time_;
 
+  // Present when emulation is enabled, only on a main frame's WebFrameWidget.
+  // Used to override values given from the browser such as ScreenInfo,
+  // WidgetScreenRect, WindowScreenRect, and the widget's size.
+  Member<ScreenMetricsEmulator> device_emulator_;
+
   friend class WebViewImpl;
   friend class ReportTimeSwapPromise;
 };

third_party/blink/renderer/core/frame/web_frame_widget_impl.cc

@@ -420,17 +420,6 @@ void WebFrameWidgetImpl::FocusChanged(bool enable) {
   }
 }
 
-void WebFrameWidgetImpl::EnableDeviceEmulation(
-    const DeviceEmulationParams& parameters) {
-  // This message should only be sent to the top level FrameWidget.
-  NOTREACHED();
-}
-
-void WebFrameWidgetImpl::DisableDeviceEmulation() {
-  // This message should only be sent to the top level FrameWidget.
-  NOTREACHED();
-}
-
 void WebFrameWidgetImpl::CalculateSelectionBounds(gfx::Rect& anchor_root_frame,
                                                   gfx::Rect& focus_root_frame) {
   const LocalFrame* local_frame = FocusedLocalFrameInWidget();

third_party/blink/renderer/core/frame/web_frame_widget_impl.h

@@ -140,10 +140,6 @@ class WebFrameWidgetImpl final : public WebFrameWidgetBase {
   void FocusChanged(bool enable) override;
   gfx::Rect ViewportVisibleRect() override;
 
-  // blink::mojom::FrameWidget
-  void EnableDeviceEmulation(const DeviceEmulationParams& parameters) override;
-  void DisableDeviceEmulation() override;
-
   void UpdateMainFrameLayoutSize();
 
  private:

third_party/blink/renderer/core/frame/web_view_frame_widget.cc

@@ -138,12 +138,6 @@ void WebViewFrameWidget::SetWindowRect(const gfx::Rect& window_rect) {
   View()->SetWindowRect(window_rect);
 }
 
-float WebViewFrameWidget::GetEmulatorScale() {
-  if (device_emulator_)
-    return device_emulator_->scale();
-  return 1.0f;
-}
-
 void WebViewFrameWidget::CalculateSelectionBounds(gfx::Rect& anchor_root_frame,
                                                   gfx::Rect& focus_root_frame) {
   const Frame* frame = View()->FocusedCoreFrame();
@@ -167,26 +161,6 @@ void WebViewFrameWidget::CalculateSelectionBounds(gfx::Rect& anchor_root_frame,
       frame_view->ConvertToRootFrame(focus));
 }
 
-void WebViewFrameWidget::EnableDeviceEmulation(
-    const DeviceEmulationParams& parameters) {
-  if (!device_emulator_) {
-    gfx::Size size_in_dips = widget_base_->BlinkSpaceToFlooredDIPs(size_);
-
-    device_emulator_ = MakeGarbageCollected<ScreenMetricsEmulator>(
-        this, widget_base_->GetScreenInfo(), size_in_dips,
-        widget_base_->VisibleViewportSizeInDIPs(),
-        widget_base_->WidgetScreenRect(), widget_base_->WindowScreenRect());
-  }
-  device_emulator_->ChangeEmulationParams(parameters);
-}
-
-void WebViewFrameWidget::DisableDeviceEmulation() {
-  if (!device_emulator_)
-    return;
-  device_emulator_->DisableAndApply();
-  device_emulator_ = nullptr;
-}
-
 bool WebViewFrameWidget::ScrollFocusedEditableElementIntoView() {
   return web_view_->ScrollFocusedEditableElementIntoView();
 }
@@ -206,11 +180,6 @@ void WebViewFrameWidget::ZoomToFindInPageRect(
   web_view_->ZoomToFindInPageRect(rect_in_root_frame);
 }
 
-void WebViewFrameWidget::Trace(Visitor* visitor) const {
-  WebFrameWidgetBase::Trace(visitor);
-  visitor->Trace(device_emulator_);
-}
-
 WebInputEventResult WebViewFrameWidget::HandleKeyEvent(
     const WebKeyboardEvent& event) {
   DCHECK((event.GetType() == WebInputEvent::Type::kRawKeyDown) ||
@@ -609,55 +578,11 @@ void WebViewFrameWidget::SetDeviceColorSpaceForTesting(
   widget_base_->UpdateScreenInfo(info);
 }
 
-bool WebViewFrameWidget::AutoResizeMode() {
-  return web_view_->AutoResizeMode();
-}
-
-bool WebViewFrameWidget::UpdateScreenRects(
-    const gfx::Rect& widget_screen_rect,
-    const gfx::Rect& window_screen_rect) {
-  if (!device_emulator_)
-    return false;
-  device_emulator_->OnUpdateScreenRects(widget_screen_rect, window_screen_rect);
-  return true;
-}
-
 void WebViewFrameWidget::RunPaintBenchmark(int repeat_count,
                                            cc::PaintBenchmarkResult& result) {
   web_view_->RunPaintBenchmark(repeat_count, result);
 }
 
-const ScreenInfo& WebViewFrameWidget::GetOriginalScreenInfo() {
-  if (device_emulator_)
-    return device_emulator_->original_screen_info();
-  return GetScreenInfo();
-}
-
-ScreenMetricsEmulator* WebViewFrameWidget::DeviceEmulator() {
-  return device_emulator_;
-}
-
-void WebViewFrameWidget::SetScreenMetricsEmulationParameters(
-    bool enabled,
-    const DeviceEmulationParams& params) {
-  if (enabled)
-    View()->ActivateDevToolsTransform(params);
-  else
-    View()->DeactivateDevToolsTransform();
-}
-
-void WebViewFrameWidget::SetScreenInfoAndSize(
-    const ScreenInfo& screen_info,
-    const gfx::Size& widget_size_in_dips,
-    const gfx::Size& visible_viewport_size_in_dips) {
-  // Emulation happens on regular main frames which don't use auto-resize mode.
-  DCHECK(!web_view_->AutoResizeMode());
-
-  UpdateScreenInfo(screen_info);
-  widget_base_->SetVisibleViewportSizeInDIPs(visible_viewport_size_in_dips);
-  Resize(widget_base_->DIPsToCeiledBlinkSpace(widget_size_in_dips));
-}
-
 void WebViewFrameWidget::SetWindowRectSynchronouslyForTesting(
     const gfx::Rect& new_window_rect) {
   SetWindowRectSynchronously(new_window_rect);
@@ -704,8 +629,8 @@ void WebViewFrameWidget::ApplyVisualPropertiesSizing(
     web_view_->CancelPagePopup();
   }
 
-  if (device_emulator_) {
-    device_emulator_->UpdateVisualProperties(visual_properties);
+  if (auto* device_emulator = DeviceEmulator()) {
+    device_emulator->UpdateVisualProperties(visual_properties);
     return;
   }
 

third_party/blink/renderer/core/frame/web_view_frame_widget.h

@@ -69,8 +69,6 @@ class CORE_EXPORT WebViewFrameWidget : public WebFrameWidgetBase {
   void MouseCaptureLost() override;
 
   // blink::mojom::FrameWidget
-  void EnableDeviceEmulation(const DeviceEmulationParams& parameters) override;
-  void DisableDeviceEmulation() override;
 
   // WebFrameWidget overrides:
   bool ScrollFocusedEditableElementIntoView() override;
@@ -91,8 +89,6 @@ class CORE_EXPORT WebViewFrameWidget : public WebFrameWidgetBase {
                                   bool is_pinch_gesture_active,
                                   float minimum,
                                   float maximum) override;
-  ScreenMetricsEmulator* DeviceEmulator() override;
-  const ScreenInfo& GetOriginalScreenInfo() override;
   void ApplyVisualPropertiesSizing(
       const VisualProperties& visual_properties) override;
   void CalculateSelectionBounds(gfx::Rect& anchor, gfx::Rect& focus) override;
@@ -100,7 +96,6 @@ class CORE_EXPORT WebViewFrameWidget : public WebFrameWidgetBase {
   // FrameWidget overrides:
   void SetRootLayer(scoped_refptr<cc::Layer>) override;
   bool ShouldHandleImeEvents() override;
-  float GetEmulatorScale() override;
 
   // WidgetBaseClient overrides:
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override;
@@ -108,24 +103,12 @@ class CORE_EXPORT WebViewFrameWidget : public WebFrameWidgetBase {
   void FocusChanged(bool enabled) override;
   float GetDeviceScaleFactorForTesting() override;
   gfx::Rect ViewportVisibleRect() override;
-  bool UpdateScreenRects(const gfx::Rect& widget_screen_rect,
-                         const gfx::Rect& window_screen_rect) override;
   void RunPaintBenchmark(int repeat_count,
                          cc::PaintBenchmarkResult& result) override;
 
-  void SetScreenMetricsEmulationParameters(
-      bool enabled,
-      const blink::DeviceEmulationParams& params);
-  void SetScreenInfoAndSize(const blink::ScreenInfo& screen_info,
-                            const gfx::Size& widget_size,
-                            const gfx::Size& visible_viewport_size);
-
-  void Trace(Visitor*) const override;
-
   void SetIsNestedMainFrameWidget(bool is_nested);
   void DidAutoResize(const gfx::Size& size);
   void SetDeviceColorSpaceForTesting(const gfx::ColorSpace& color_space);
-  bool AutoResizeMode();
   void SetWindowRect(const gfx::Rect& window_rect);
   void SetWindowRectSynchronouslyForTesting(const gfx::Rect& new_window_rect);
   void UseSynchronousResizeModeForTesting(bool enable);
@@ -160,11 +143,6 @@ class CORE_EXPORT WebViewFrameWidget : public WebFrameWidgetBase {
   // top level widget.
   bool is_for_nested_main_frame_ = false;
 
-  // Present when emulation is enabled, only in a main frame WidgetBase. Used
-  // to override values given from the browser such as ScreenInfo,
-  // WidgetScreenRect, WindowScreenRect, and the widget's size.
-  Member<ScreenMetricsEmulator> device_emulator_;
-
   // In web tests, synchronous resizing mode may be used. Normally each widget's
   // size is controlled by IPC from the browser. In synchronous resize mode the
   // renderer controls the size directly, and IPCs from the browser must be