RenderWidgetCompositor should be decoupled from RenderWidget.

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 <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <map>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
 #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/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"
 #include "content/renderer/message_delivery_policy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "third_party/WebKit/public/platform/WebDisplayMode.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebPopupType.h"
@@ skipping 60 matching lines @@
 //
 // RenderWidget is used to implement:
 // - RenderViewImpl (deprecated)
 // - Fullscreen mode (RenderWidgetFullScreen)
 // - Popup "menus" (like the color chooser and date picker)
 // - Widgets for frames (for out-of-process iframe support)
 class CONTENT_EXPORT RenderWidget
     : public IPC::Listener,
       public IPC::Sender,
       NON_EXPORTED_BASE(virtual public blink::WebWidgetClient),
+      public RenderWidgetCompositorDelegate,
       public RenderWidgetInputHandlerDelegate,
       public base::RefCounted<RenderWidget> {
  public:
   // Creates a new RenderWidget.  The opener_id is the routing ID of the
   // RenderView that this widget lives inside.
   static RenderWidget* Create(int32_t opener_id,
                               CompositorDependencies* compositor_deps,
                               blink::WebPopupType popup_type,
                               const blink::WebScreenInfo& screen_info);
 
@@ skipping 14 matching lines @@
 
   CompositorDependencies* compositor_deps() const { return compositor_deps_; }
   blink::WebWidget* webwidget() const { return webwidget_; }
   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_; }
   // Temporary for debugging purposes...
   bool closing() const { return closing_; }
   bool is_swapped_out() { return is_swapped_out_; }
-  bool for_oopif() { return for_oopif_; }
   bool has_host_context_menu_location() {
     return has_host_context_menu_location_;
   }
   gfx::Point host_context_menu_location() {
     return host_context_menu_location_;
   }
 
   // ScreenInfo exposed so it can be passed to subframe RenderWidgets.
   blink::WebScreenInfo screen_info() const { return screen_info_; }
 
@@ skipping 10 matching lines @@
   void RegisterVideoHoleFrame(RenderFrameImpl* frame);
   void UnregisterVideoHoleFrame(RenderFrameImpl* frame);
 #endif  // defined(VIDEO_HOLE)
 
   // IPC::Listener
   bool OnMessageReceived(const IPC::Message& msg) override;
 
   // IPC::Sender
   bool Send(IPC::Message* msg) override;
 
+  // RenderWidgetCompositorDelegate
+  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
+                           const gfx::Vector2dF& outer_delta,
+                           const gfx::Vector2dF& elastic_overscroll_delta,
+                           float page_scale,
+                           float top_controls_delta) override;
+  void BeginMainFrame(double frame_time_sec) override;
+  scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback) override;
+  scoped_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource() override;
+  void DidCommitAndDrawCompositorFrame() override;
+  void DidCommitCompositorFrame() override;
+  void DidCompletePageScaleAnimation() override;
+  void DidCompleteSwapBuffers() override;
+  bool ForOOPIF() const override;
+  void ForwardCompositorProto(const std::vector<uint8_t>& proto) override;
+  void OnSwapBuffersAborted() override;
+  void OnSwapBuffersComplete() override;
+  void OnSwapBuffersPosted() override;
+  void RecordFrameTimingEvents(
+      scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
+      scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events)
+      override;
+  void ScheduleAnimation() override;
+  void WillBeginCompositorFrame() override;
+
   // RenderWidgetInputHandlerDelegate
   void FocusChangeComplete() override;
   bool HasTouchEventHandlersAt(const gfx::Point& point) const override;
   void ObserveWheelEventAndResult(const blink::WebMouseWheelEvent& wheel_event,
                                   const gfx::Vector2dF& wheel_unused_delta,
                                   bool event_processed) override;
   void OnDidHandleKeyEvent() override;
   void OnDidOverscroll(const DidOverscrollParams& params) override;
   void OnInputEventAck(scoped_ptr<InputEventAck> input_event_ack) override;
   void SetInputHandler(RenderWidgetInputHandler* input_handler) override;
@@ skipping 68 matching lines @@
 
   // When paused in debugger, we send ack for mouse event early. This ensures
   // that we continue receiving mouse moves and pass them to debugger. Returns
   // whether we are paused in mouse move event and have sent the ack.
   bool SendAckForMouseMoveFromDebugger();
 
   // When resumed from pause in debugger while handling mouse move,
   // we should not send an extra ack (see SendAckForMouseMoveFromDebugger).
   void IgnoreAckForMouseMoveFromDebugger();
 
-  virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback);
-
   // Callback for use with synthetic gestures (e.g. BeginSmoothScroll).
   typedef base::Callback<void()> SyntheticGestureCompletionCallback;
 
   // Send a synthetic gesture to the browser to be queued to the synthetic
   // gesture controller.
   void QueueSyntheticGesture(
       scoped_ptr<SyntheticGestureParams> gesture_params,
       const SyntheticGestureCompletionCallback& callback);
 
   // Deliveres |message| together with compositor state change updates. The
   // exact behavior depends on |policy|.
   // This mechanism is not a drop-in replacement for IPC: messages sent this way
   // will not be automatically available to BrowserMessageFilter, for example.
   // FIFO ordering is preserved between messages enqueued with the same
   // |policy|, the ordering between messages enqueued for different policies is
   // undefined.
   //
   // |msg| message to send, ownership of |msg| is transferred.
   // |policy| see the comment on MessageDeliveryPolicy.
   void QueueMessage(IPC::Message* msg, MessageDeliveryPolicy policy);
 
   // Handle start and finish of IME event guard.
   void OnImeEventGuardStart(ImeEventGuard* guard);
   void OnImeEventGuardFinish(ImeEventGuard* guard);
 
   // Returns whether we currently should handle an IME event.
   bool ShouldHandleImeEvent();
 
-  // Called by the compositor when page scale animation completed.
-  virtual void DidCompletePageScaleAnimation() {}
-
   // 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);
 
-  // Indicates that the compositor is about to begin a frame. This is primarily
-  // to signal to flow control mechanisms that a frame is beginning, not to
-  // perform actual painting work.
-  void WillBeginCompositorFrame();
-
-  // Notifies about a compositor frame commit operation having finished.
-  virtual void DidCommitCompositorFrame();
-
-  // Notifies that the draw commands for a committed frame have been issued.
-  void DidCommitAndDrawCompositorFrame();
-
-  // Notifies that the compositor has posted a swapbuffers operation to the GPU
-  // process.
-  void DidCompleteSwapBuffers();
 
   void ScheduleComposite();
   void ScheduleCompositeWithForcedRedraw();
 
-  // Called by the compositor in single-threaded mode when a swap is posted,
-  // completes or is aborted.
-  void OnSwapBuffersPosted();
-  void OnSwapBuffersComplete();
-  void OnSwapBuffersAborted();
-
   // Checks if the selection bounds have been changed. If they are changed,
   // the new value will be sent to the browser process.
   void UpdateSelectionBounds();
 
   // Called by the compositor to forward a proto that represents serialized
   // compositor state.
-  void ForwardCompositorProto(const std::vector<uint8_t>& proto);
 
   virtual void GetSelectionBounds(gfx::Rect* start, gfx::Rect* end);
 
   void OnShowHostContextMenu(ContextMenuParams* params);
 
   // Checks if the composition range or composition character bounds have been
   // changed. If they are changed, the new value will be sent to the browser
   // process. This method does nothing when the browser process is not able to
   // handle composition range and composition character bounds.
   void UpdateCompositionInfo(bool should_update_range);
 
   bool host_closing() const { return host_closing_; }

[piman, 2016/01/13 22:09:30]

nit: I think this can now be made private.

[Fady Samuel, 2016/01/13 23:48:13]

Done.

 
  protected:
   // Friend RefCounted so that the dtor can be non-public. Using this class
   // without ref-counting is an error.
   friend class base::RefCounted<RenderWidget>;
 
   // For unit tests.
   friend class RenderWidgetTest;
 
   enum ResizeAck {
@@ skipping 400 matching lines @@
 
   scoped_ptr<scheduler::RenderWidgetSchedulingState>
       render_widget_scheduling_state_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidget);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_WIDGET_H_