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>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "content/common/browser_rendering_stats.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/renderer/paint_aggregator.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
+#include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "third_party/WebKit/public/web/WebPopupType.h"
 #include "third_party/WebKit/public/web/WebTextDirection.h"
 #include "third_party/WebKit/public/web/WebTextInputInfo.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 #include "third_party/WebKit/public/web/WebWidgetClient.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/ime/text_input_mode.h"
 #include "ui/base/ime/text_input_type.h"
@@ skipping 12 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;
 }
 
 namespace content {
+class DeviceEmulationEventRewriter;
 class PepperPluginInstanceImpl;
 class RenderWidgetCompositor;
 class RenderWidgetTest;
+struct ContextMenuParams;
 struct GpuRenderingStats;
 struct WebPluginGeometry;
 
 // RenderWidget provides a communication bridge between a WebWidget and
 // a RenderWidgetHost, the latter of which lives in a different process.
 class CONTENT_EXPORT RenderWidget
     : public IPC::Listener,
       public IPC::Sender,
       NON_EXPORTED_BASE(virtual public WebKit::WebWidgetClient),
       NON_EXPORTED_BASE(public WebGraphicsContext3DSwapBuffersClient),
@@ skipping 194 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);
+  // This sets a tranformation on root compositor layer.
+  virtual void SetDeviceEmulationScale(float scale);
+
   // 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 422 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. 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 DeviceEmulationHelper {
+   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);
+
+    // The following methods alter handlers' behavior for messages related to
+    // widget size and position.
+    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);
+    void OnShowContextMenu(RenderWidget* widget, ContextMenuParams* params);
+
+    WebKit::WebInputEvent* ConvertInputEventToEmulated(
+        RenderWidget* widget, const WebKit::WebInputEvent* event);
+
+    // Created popups need to be repositioned.
+    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);
+
+    // Parameters as passed by WebViewClient::EmulateDevice.
+    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_;
+
+    // This handles the rewriting of input events incoming to the widget and
+    // the compositor.
+    scoped_ptr<DeviceEmulationEventRewriter> input_event_rewriter_;
+
+    base::WeakPtrFactory<DeviceEmulationHelper> weak_ptr_factory_;
+  };
+
+  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_