Implementation of device metrics emulation in render view.

content/renderer/render_widget.h

 // 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.
 
 #ifndef CONTENT_RENDERER_RENDER_WIDGET_H_
 #define CONTENT_RENDERER_RENDER_WIDGET_H_
 
 #include <deque>
 #include <map>
 
@@ skipping 36 matching lines @@
 namespace IPC {
 class SyncMessage;
 }
 
 namespace WebKit {
 class WebGestureEvent;
 class WebInputEvent;
 class WebKeyboardEvent;
 class WebMouseEvent;
 class WebTouchEvent;
+class WebTouchPoint;
 struct WebPoint;
 struct WebRenderingStatsImpl;
 }
 
 namespace cc { class OutputSurface; }
 
 namespace ui {
 class Range;
 }
 
@@ skipping 207 matching lines @@
   virtual void SetBackground(const SkBitmap& bitmap);
 
   // Resizes the render widget.
   void Resize(const gfx::Size& new_size,
               const gfx::Size& physical_backing_size,
               float overdraw_bottom_height,
               const gfx::Rect& resizer_rect,
               bool is_fullscreen,
               ResizeAck resize_ack);
 
+  // Emulates device and widget metrics. Supplied values override everything
+  // coming from host.
+  void EmulateDevice(bool enabled,
+                     const gfx::Size& device_size,
+                     const gfx::Rect& widget_rect,
+                     float device_scale_factor,
+                     bool fit_to_view);
+
   // RenderWidget IPC message handlers
   void OnHandleInputEvent(const WebKit::WebInputEvent* event,
                           const ui::LatencyInfo& latency_info,
                           bool keyboard_shortcut);
   void OnCursorVisibilityChange(bool is_visible);
   void OnMouseCaptureLost();
   virtual void OnSetFocus(bool enable);
   void OnClose();
   void OnCreatingNewAck();
   virtual void OnResize(const ViewMsg_Resize_Params& params);
   void OnChangeResizeRect(const gfx::Rect& resizer_rect);
   virtual void OnWasHidden();
   virtual void OnWasShown(bool needs_repainting);
   virtual void OnWasSwappedOut();
+  void OnEmulateDeviceAck(bool enabled);
   void OnUpdateRectAck();
   void OnCreateVideoAck(int32 video_id);
   void OnUpdateVideoAck(int32 video_id);
   void OnRequestMoveAck();
   void OnSetInputMethodActive(bool is_active);
   virtual void OnImeSetComposition(
       const string16& text,
       const std::vector<WebKit::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end);
@@ skipping 420 matching lines @@
 
   uint32 next_output_surface_id_;
 
 #if defined(OS_ANDROID)
   // A counter for number of outstanding messages from the renderer to the
   // browser regarding IME-type events that have not been acknowledged by the
   // browser. If this value is not 0 IME events will be dropped.
   int outstanding_ime_acks_;
 #endif
 
+  // Helper class which is managing device emulation.
+  // TODO(dgozman): fit to view is not supported yet.
+  class DeviceEmulationHelper {

[jam, 2013/09/11 02:59:47]

nit: since this is a private class, just forward declare it here and
declare/define it in the cc file in an anonymous namespace

[dgozman, 2013/09/13 11:32:36]

Unfortunately, this class is also used by RenderViewImpl.

+   public:
+    DeviceEmulationHelper(const gfx::Size& device_size,
+                          const gfx::Rect& widget_rect,
+                          float device_scale_factor,
+                          bool fit_to_view);
+    virtual ~DeviceEmulationHelper();
+
+    void BeginEmulation(RenderWidget* widget);
+    void ChangeEmulationParams(RenderWidget* widget,
+                               DeviceEmulationHelper* params);
+    void EndEmulation(RenderWidget* widget);
+
+    void OnResizeMessage(RenderWidget* widget,
+                         const ViewMsg_Resize_Params& params);
+    void OnUpdateScreenRectsMessage(RenderWidget* widget,
+                                    const gfx::Rect view_screen_rect,
+                                    const gfx::Rect window_screen_rect);
+    WebKit::WebInputEvent* ConvertInputEventToEmulated(
+        RenderWidget* widget, const WebKit::WebInputEvent* event);
+
+    void PopupCreated(RenderWidget* widget, RenderWidget* popup);
+    WebKit::WebRect ConvertPopupScreenRectFromEmulated(
+        RenderWidget* popup, const WebKit::WebRect& rect);
+
+   private:
+    void Apply(RenderWidget* widget, float overdraw_bottom_height,
+        gfx::Rect resizer_rect, bool is_fullscreen);
+    void ConvertMouseEventToEmulated(WebKit::WebMouseEvent* event);
+    void ConvertTouchPointToEmulated(WebKit::WebTouchPoint* point);
+
+    gfx::Size device_size_;
+    gfx::Rect widget_rect_;
+    float device_scale_factor_;
+    bool fit_to_view_;
+
+    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_;
+
+    base::WeakPtrFactory<DeviceEmulationHelper> weak_ptr_factory_;
+
+    DISALLOW_COPY_AND_ASSIGN(DeviceEmulationHelper);
+  };
+
+  scoped_ptr<DeviceEmulationHelper> device_emulation_helper_;
+
+  // Popup has a weak ptr to the device emulation helper of creator.
+  base::WeakPtr<DeviceEmulationHelper> popup_device_emulation_helper_;
+
+  // While we send ViewMsg_EmulateDevice to the host, these store the requested
+  // emulation parameters.
+  scoped_ptr<DeviceEmulationHelper> pending_device_emulation_helper_;
+  bool pending_device_emulation_enabled_;
+
   base::WeakPtrFactory<RenderWidget> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidget);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_WIDGET_H_