Revert of Remove code used by --disable-delegated-renderer on Mac

content/browser/renderer_host/render_widget_host_view_mac.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_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_MAC_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_MAC_H_
 
 #import <Cocoa/Cocoa.h>
 #include <IOSurface/IOSurfaceAPI.h>
 #include <list>
@@ skipping 19 matching lines @@
 #include "ipc/ipc_sender.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "ui/base/cocoa/base_view.h"
 #include "ui/base/cocoa/remote_layer_api.h"
 #include "ui/gfx/display_observer.h"
 
 struct ViewHostMsg_TextInputState_Params;
 
 namespace content {
 class BrowserCompositorviewMac;
+class CompositingIOSurfaceMac;
+class CompositingIOSurfaceContext;
 class RenderWidgetHostViewMac;
 class RenderWidgetHostViewMacEditCommandHelper;
 class WebContents;
 }
 
 namespace ui {
 class Compositor;
 class Layer;
 }
 
+@class CompositingIOSurfaceLayer;
 @class FullscreenWindowManager;
 @protocol RenderWidgetHostViewMacDelegate;
+@class SoftwareLayer;
 @class ToolTip;
 
 @protocol RenderWidgetHostViewMacOwner
 - (content::RenderWidgetHostViewMac*)renderWidgetHostViewMac;
 @end
 
 // This is the view that lives in the Cocoa view hierarchy. In Windows-land,
 // RenderWidgetHostViewWin is both the view and the delegate. We split the roles
 // but that means that the view needs to own the delegate and will dispose of it
 // when it's removed from the view system.
@@ skipping 82 matching lines @@
 
   // Whether or not plugin IME is currently enabled active.
   BOOL pluginImeActive_;
 
   // Whether the previous mouse event was ignored due to hitTest check.
   BOOL mouseEventWasIgnored_;
 
   // Event monitor for scroll wheel end event.
   id endWheelMonitor_;
 
+  // OpenGL Support:
+
+  // recursive globalFrameDidChange protection:
+  BOOL handlingGlobalFrameDidChange_;
+
+  // The scale factor of the display this view is in.
+  float deviceScaleFactor_;
+
   // If true then escape key down events are suppressed until the first escape
   // key up event. (The up event is suppressed as well). This is used by the
   // flash fullscreen code to avoid sending a key up event without a matching
   // key down event.
   BOOL suppressNextEscapeKeyUp_;
 }
 
 @property(nonatomic, readonly) NSRange selectedRange;
 @property(nonatomic, readonly) BOOL suppressNextEscapeKeyUp;
 
@@ skipping 36 matching lines @@
 //    "The lifetime of the RenderWidgetHost* is tied to the render process.
 //     If the render process dies, the RenderWidgetHost* goes away and all
 //     references to it must become NULL."
 //
 // RenderWidgetHostView class hierarchy described in render_widget_host_view.h.
 class CONTENT_EXPORT RenderWidgetHostViewMac
     : public RenderWidgetHostViewBase,
       public DelegatedFrameHostClient,
       public BrowserCompositorViewMacClient,
       public IPC::Sender,
+      public SoftwareFrameManagerClient,
       public CompositingIOSurfaceLayerClient,
       public gfx::DisplayObserver {
  public:
   // The view will associate itself with the given widget. The native view must
   // be hooked up immediately to the view hierarchy, or else when it is
   // deleted it will delete this out from under the caller.
   explicit RenderWidgetHostViewMac(RenderWidgetHost* widget);
   virtual ~RenderWidgetHostViewMac();
 
   RenderWidgetHostViewCocoa* cocoa_view() const { return cocoa_view_; }
@@ skipping 101 matching lines @@
   virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE;
 
   virtual bool LockMouse() OVERRIDE;
   virtual void UnlockMouse() OVERRIDE;
   virtual void WheelEventAck(const blink::WebMouseWheelEvent& event,
                              InputEventAckState ack_result) OVERRIDE;
 
   // IPC::Sender implementation.
   virtual bool Send(IPC::Message* message) OVERRIDE;
 
+  // SoftwareFrameManagerClient implementation:
+  virtual void SoftwareFrameWasFreed(
+      uint32 output_surface_id, unsigned frame_id) OVERRIDE;
+  virtual void ReleaseReferencesToSoftwareFrame() OVERRIDE;
+
   virtual SkColorType PreferredReadbackFormat() OVERRIDE;
 
   // CompositingIOSurfaceLayerClient implementation.
   virtual bool AcceleratedLayerShouldAckImmediately() const OVERRIDE;
   virtual void AcceleratedLayerDidDrawFrame() OVERRIDE;
   virtual void AcceleratedLayerHitError() OVERRIDE;
 
   // gfx::DisplayObserver implementation.
   virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE;
   virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE;
   virtual void OnDisplayMetricsChanged(const gfx::Display& display,
                                        uint32_t metrics) OVERRIDE;
 
   // Forwards the mouse event to the renderer.
   void ForwardMouseEvent(const blink::WebMouseEvent& event);
 
   void KillSelf();
 
   void SetTextInputActive(bool active);
 
   // Sends completed plugin IME notification and text back to the renderer.
   void PluginImeCompositionCompleted(const base::string16& text, int plugin_id);
 
   const std::string& selected_text() const { return selected_text_; }
 
+  // Update the IOSurface to be drawn and call setNeedsDisplay on
+  // |cocoa_view_|.
+  void CompositorSwapBuffers(IOSurfaceID surface_handle,
+                             const gfx::Rect& damage_rect,
+                             const gfx::Size& surface_size,
+                             float scale_factor,
+                             const std::vector<ui::LatencyInfo>& latency_info);
+
+  // Called when a GPU error is detected. Posts a task to destroy all
+  // compositing state.
+  void GotAcceleratedCompositingError();
+
   // Returns true and stores first rectangle for character range if the
   // requested |range| is already cached, otherwise returns false.
   // Exposed for testing.
   CONTENT_EXPORT bool GetCachedFirstRectForCharacterRange(
       NSRange range, NSRect* rect, NSRange* actual_range);
 
   // Returns true if there is line break in |range| and stores line breaking
   // point to |line_breaking_point|. The |line_break_point| is valid only if
   // this function returns true.
   bool GetLineBreakIndex(const std::vector<gfx::Rect>& bounds,
@@ skipping 20 matching lines @@
   // someone (other than superview) has retained |cocoa_view_|.
   RenderWidgetHostImpl* render_widget_host_;
 
   // Current text input type.
   ui::TextInputType text_input_type_;
   bool can_compose_inline_;
 
   // The background CoreAnimation layer which is hosted by |cocoa_view_|.
   base::scoped_nsobject<CALayer> background_layer_;
 
+  // A flipped layer, which acts as the parent of the compositing and software
+  // layers. This layer is flipped so that the we don't need to recompute the
+  // origin for sub-layers when their position changes (this is impossible when
+  // using remote layers, as their size change cannot be synchronized with the
+  // window). This indirection is needed because flipping hosted layers (like
+  // |background_layer_|) leads to unpredictable behavior.
+  base::scoped_nsobject<CALayer> flipped_layer_;
+
+  // The CoreAnimation layer hosted by the GPU process.
+  base::scoped_nsobject<CALayerHost> remote_layer_host_;
+
+  // The CoreAnimation layer for software compositing. This should be NULL
+  // when software compositing is not in use.
+  base::scoped_nsobject<SoftwareLayer> software_layer_;
+
+  // Accelerated compositing structures. These may be dynamically created and
+  // destroyed together in Create/DestroyCompositedIOSurfaceAndLayer.
+  base::scoped_nsobject<CompositingIOSurfaceLayer> compositing_iosurface_layer_;
+  scoped_refptr<CompositingIOSurfaceMac> compositing_iosurface_;
+  scoped_refptr<CompositingIOSurfaceContext> compositing_iosurface_context_;
+
   // Delegated frame management and compositior.
   scoped_ptr<DelegatedFrameHost> delegated_frame_host_;
   scoped_ptr<ui::Layer> root_layer_;
 
   // Container for the NSView drawn by the browser compositor.
   scoped_ptr<BrowserCompositorViewMac> browser_compositor_view_;
 
   // Placeholder that is allocated while browser_compositor_view_ is NULL,
   // indicating that a BrowserCompositorViewMac may be allocated. This is to
   // help in recycling the internals of BrowserCompositorViewMac.
   scoped_ptr<BrowserCompositorViewPlaceholderMac>
       browser_compositor_view_placeholder_;
 
+  // This holds the current software compositing framebuffer, if any.
+  scoped_ptr<SoftwareFrameManager> software_frame_manager_;
+
+  // Latency info to send back when the next frame appears on the
+  // screen.
+  std::vector<ui::LatencyInfo> pending_latency_info_;
+
   NSWindow* pepper_fullscreen_window() const {
     return pepper_fullscreen_window_;
   }
 
   CONTENT_EXPORT void release_pepper_fullscreen_window_for_testing();
 
   RenderWidgetHostViewMac* fullscreen_parent_host_view() const {
     return fullscreen_parent_host_view_;
   }
 
+  RenderWidgetHostViewFrameSubscriber* frame_subscriber() const {
+    return frame_subscriber_.get();
+  }
+
   int window_number() const;
 
   // The scale factor for the screen that the view is currently on.
   float ViewScaleFactor() const;
 
   // Update the scale factor for the backing store and for any CALayers.
   void UpdateBackingStoreScaleFactor();
 
   // Ensure that the display link is associated with the correct display.
   void UpdateDisplayLink();
 
+  // The scale factor of the backing store. Note that this is updated based on
+  // ViewScaleFactor with some delay.
+  float backing_store_scale_factor_;
+
+  void AddPendingLatencyInfo(
+      const std::vector<ui::LatencyInfo>& latency_info);
+  void SendPendingLatencyInfoToHost();
+
+  void SendPendingSwapAck();
+
   void PauseForPendingResizeOrRepaintsAndDraw();
 
+  // The geometric arrangement of the layers depends on cocoa_view's size, the
+  // compositing IOSurface's rounded size, and the software frame size. Update
+  // all of them using this function when any of those parameters changes. Also
+  // update the scale factor of the layers.
+  void LayoutLayers();
+
   // DelegatedFrameHostClient implementation.
   virtual ui::Compositor* GetCompositor() const OVERRIDE;
   virtual ui::Layer* GetLayer() OVERRIDE;
   virtual RenderWidgetHostImpl* GetHost() OVERRIDE;
   virtual void SchedulePaintInRect(
       const gfx::Rect& damage_rect_in_dip) OVERRIDE;
   virtual bool IsVisible() OVERRIDE;
   virtual scoped_ptr<ResizeLock> CreateResizeLock(
       bool defer_compositor_lock) OVERRIDE;
   virtual gfx::Size DesiredFrameSize() OVERRIDE;
   virtual float CurrentDeviceScaleFactor() OVERRIDE;
   virtual gfx::Size ConvertViewSizeToPixel(const gfx::Size& size) OVERRIDE;
   virtual DelegatedFrameHost* GetDelegatedFrameHost() const OVERRIDE;
 
   // BrowserCompositorViewMacClient implementation.
   virtual bool BrowserCompositorViewShouldAckImmediately() const OVERRIDE;
   virtual void BrowserCompositorViewFrameSwapped(
       const std::vector<ui::LatencyInfo>& latency_info) OVERRIDE;
   virtual NSView* BrowserCompositorSuperview() OVERRIDE;
   virtual ui::Layer* BrowserCompositorRootLayer() OVERRIDE;
 
  private:
   friend class RenderWidgetHostViewMacTest;
 
+  struct PendingSwapAck {
+    PendingSwapAck(int32 route_id, int gpu_host_id, int32 renderer_id)
+        : route_id(route_id),
+          gpu_host_id(gpu_host_id),
+          renderer_id(renderer_id) {}
+    int32 route_id;
+    int gpu_host_id;
+    int32 renderer_id;
+  };
+  scoped_ptr<PendingSwapAck> pending_swap_ack_;
+  void AddPendingSwapAck(int32 route_id, int gpu_host_id, int32 renderer_id);
+
   // Returns whether this render view is a popup (autocomplete window).
   bool IsPopup() const;
 
   // Shuts down the render_widget_host_.  This is a separate function so we can
   // invoke it from the message loop.
   void ShutdownHost();
 
   // Tear down all components of the browser compositor in an order that will
   // ensure no dangling references.
   void ShutdownBrowserCompositor();
 
   void EnsureBrowserCompositorView();
   void DestroyBrowserCompositorView();
 
+  void EnsureSoftwareLayer();
+  void DestroySoftwareLayer();
+
+  bool EnsureCompositedIOSurface() WARN_UNUSED_RESULT;
+  void EnsureCompositedIOSurfaceLayer();
+  enum DestroyCompositedIOSurfaceLayerBehavior {
+    kLeaveLayerInHierarchy,
+    kRemoveLayerFromHierarchy,
+  };
+  void DestroyCompositedIOSurfaceLayer(
+      DestroyCompositedIOSurfaceLayerBehavior destroy_layer_behavior);
+  void DestroyCompositedIOSurfaceAndLayer();
+
+  void DestroyCompositingStateOnError();
+
+  // Called when a GPU SwapBuffers is received.
+  void GotAcceleratedFrame();
+
+  // Called when a software DIB is received.
+  void GotSoftwareFrame();
+
   // IPC message handlers.
   void OnPluginFocusChanged(bool focused, int plugin_id);
   void OnStartPluginIme();
   void OnGetRenderedTextCompleted(const std::string& text);
 
+  // Convert |rect| from the views coordinate (upper-left origin) into
+  // the OpenGL coordinate (lower-left origin) and scale for HiDPI displays.
+  gfx::Rect GetScaledOpenGLPixelRect(const gfx::Rect& rect);
+
   // Send updated vsync parameters to the renderer.
   void SendVSyncParametersToRenderer();
 
   // Dispatches a TTS session.
   void SpeakText(const std::string& text);
 
   // The associated view. This is weak and is inserted into the view hierarchy
   // to own this RenderWidgetHostViewMac object. Set to nil at the start of the
   // destructor.
   RenderWidgetHostViewCocoa* cocoa_view_;
@@ skipping 30 matching lines @@
   base::TimeTicks vsync_timebase_;
   base::TimeDelta vsync_interval_;
 
   // The current composition character range and its bounds.
   gfx::Range composition_range_;
   std::vector<gfx::Rect> composition_bounds_;
 
   // The current caret bounds.
   gfx::Rect caret_rect_;
 
+  // Subscriber that listens to frame presentation events.
+  scoped_ptr<RenderWidgetHostViewFrameSubscriber> frame_subscriber_;
+
+  base::WeakPtrFactory<RenderWidgetHostViewMac>
+      software_frame_weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewMac);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_MAC_H_