content/browser/compositor/browser_compositor_ca_layer_tree_mac.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_COMPOSITOR_ACCELERATED_WIDGET_HELPER_MAC_H_
   6 #define CONTENT_BROWSER_COMPOSITOR_ACCELERATED_WIDGET_HELPER_MAC_H_
   7
   8 #include <IOSurface/IOSurfaceAPI.h>
   9 #include <vector>
  10
  11 #include "skia/ext/platform_canvas.h"
  12 #include "ui/events/latency_info.h"
  13 #include "ui/gfx/geometry/size.h"
  14 #include "ui/gfx/native_widget_types.h"
  15
  16 #if defined(__OBJC__)
  17 #include <Cocoa/Cocoa.h>
  18 #include "base/mac/scoped_nsobject.h"
  19 #include "content/browser/compositor/io_surface_layer_mac.h"
  20 #include "content/browser/compositor/software_layer_mac.h"
  21 #include "ui/base/cocoa/remote_layer_api.h"
  22 #endif  // __OBJC__
  23
  24 namespace cc {
  25 class SoftwareFrameData;
  26 }
  27
  28 namespace content {
  29
  30 class AcceleratedWidgetMac;
  31
  32 // A class through which an AcceleratedWidget may be bound to draw the contents
  33 // of an NSView. An AcceleratedWidget may be bound to multiple different views
  34 // throughout its lifetime (one at a time, though).
  35 class AcceleratedWidgetMacNSView {
  36  public:
  37   virtual NSView* AcceleratedWidgetGetNSView() const = 0;
  38   virtual bool AcceleratedWidgetShouldIgnoreBackpressure() const = 0;
  39   virtual void AcceleratedWidgetSwapCompleted(
  40       const std::vector<ui::LatencyInfo>& latency_info) = 0;
  41   virtual void AcceleratedWidgetHitError() = 0;
  42 };
  43
  44 #if defined(__OBJC__)
  45
  46 // AcceleratedWidgetMac owns a tree of CALayers. The widget may be passed
  47 // to a ui::Compositor, which will cause, through its output surface, calls to
  48 // GotAcceleratedFrame and GotSoftwareFrame. The CALayers may be installed
  49 // in an NSView by setting the AcceleratedWidgetMacNSView for the helper.
  50 class AcceleratedWidgetMac : public IOSurfaceLayerClient {
  51  public:
  52   AcceleratedWidgetMac();
  53   virtual ~AcceleratedWidgetMac();
  54
  55   gfx::AcceleratedWidget accelerated_widget() { return native_widget_; }
  56
  57   void SetNSView(AcceleratedWidgetMacNSView* view);
  58   void ResetNSView();
  59
  60   // Return true if the last frame swapped has a size in DIP of |dip_size|.
  61   bool HasFrameOfSize(const gfx::Size& dip_size) const;
  62
  63   // Return the CGL renderer ID for the surface, if one is available.
  64   int GetRendererID() const;
  65
  66   // Return true if the renderer should not be throttled by GPU back-pressure.
  67   bool IsRendererThrottlingDisabled() const;
  68
  69   // Mark a bracket in which new frames are being pumped in a restricted nested
  70   // run loop.
  71   void BeginPumpingFrames();
  72   void EndPumpingFrames();
  73
  74   void GotAcceleratedFrame(
  75       uint64 surface_handle,
  76       const std::vector<ui::LatencyInfo>& latency_info,
  77       gfx::Size pixel_size,
  78       float scale_factor,
  79       const base::Closure& drawn_callback);
  80
  81   void GotSoftwareFrame(
  82       cc::SoftwareFrameData* frame_data, float scale_factor, SkCanvas* canvas);
  83
  84 private:
  85   // IOSurfaceLayerClient implementation:
  86   bool IOSurfaceLayerShouldAckImmediately() const override;
  87   void IOSurfaceLayerDidDrawFrame() override;
  88   void IOSurfaceLayerHitError() override;
  89
  90   void GotAcceleratedCAContextFrame(
  91       CAContextID ca_context_id, gfx::Size pixel_size, float scale_factor);
  92
  93   void GotAcceleratedIOSurfaceFrame(
  94       IOSurfaceID io_surface_id, gfx::Size pixel_size, float scale_factor);
  95
  96   void AcknowledgeAcceleratedFrame();
  97
  98   // Remove a layer from the heirarchy and destroy it. Because the accelerated
  99   // layer types may be replaced by a layer of the same type, the layer to
 100   // destroy is parameterized, and, if it is the current layer, the current
 101   // layer is reset.
 102   void DestroyCAContextLayer(
 103       base::scoped_nsobject<CALayerHost> ca_context_layer);
 104   void DestroyIOSurfaceLayer(
 105       base::scoped_nsobject<IOSurfaceLayer> io_surface_layer);
 106   void DestroySoftwareLayer();
 107
 108   // The AcceleratedWidgetMacNSView that is using this as its internals.
 109   AcceleratedWidgetMacNSView* view_;
 110
 111   // A phony NSView handle used to identify this.
 112   gfx::AcceleratedWidget native_widget_;
 113
 114   // A flipped layer, which acts as the parent of the compositing and software
 115   // layers. This layer is flipped so that the we don't need to recompute the
 116   // origin for sub-layers when their position changes (this is impossible when
 117   // using remote layers, as their size change cannot be synchronized with the
 118   // window). This indirection is needed because flipping hosted layers (like
 119   // |background_layer_| of RenderWidgetHostViewCocoa) leads to unpredictable
 120   // behavior.
 121   base::scoped_nsobject<CALayer> flipped_layer_;
 122
 123   // The accelerated CoreAnimation layer hosted by the GPU process.
 124   base::scoped_nsobject<CALayerHost> ca_context_layer_;
 125
 126   // The locally drawn accelerated CoreAnimation layer.
 127   base::scoped_nsobject<IOSurfaceLayer> io_surface_layer_;
 128
 129   // The locally drawn software layer.
 130   base::scoped_nsobject<SoftwareLayer> software_layer_;
 131
 132   // If an accelerated frame has come in which has not yet been drawn and acked
 133   // then this is the latency info and the callback to make when the frame is
 134   // drawn. If there is no such frame then the callback is null.
 135   std::vector<ui::LatencyInfo> accelerated_latency_info_;
 136   base::Closure accelerated_frame_drawn_callback_;
 137
 138   // The size in DIP of the last swap received from |compositor_|.
 139   gfx::Size last_swap_size_dip_;
 140
 141   DISALLOW_COPY_AND_ASSIGN(AcceleratedWidgetMac);
 142 };
 143
 144 #endif  // __OBJC__
 145
 146 void AcceleratedWidgetMacGotAcceleratedFrame(
 147     gfx::AcceleratedWidget widget, uint64 surface_handle,
 148     const std::vector<ui::LatencyInfo>& latency_info,
 149     gfx::Size pixel_size, float scale_factor,
 150     const base::Closure& drawn_callback,
 151     bool* disable_throttling, int* renderer_id);
 152
 153 void AcceleratedWidgetMacGotSoftwareFrame(
 154     gfx::AcceleratedWidget widget,
 155     cc::SoftwareFrameData* frame_data, float scale_factor, SkCanvas* canvas);
 156
 157 }  // namespace content
 158
 159 #endif  // CONTENT_BROWSER_COMPOSITOR_ACCELERATED_WIDGET_HELPER_MAC_H_