OLD | NEW |
| (Empty) |
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_ | |
OLD | NEW |