1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
// Copyright (c) 2011 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.
#if defined(ENABLE_GPU)
#include "content/common/gpu/image_transport_surface.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/win/windows_version.h"
#include "content/common/gpu/gpu_messages.h"
#include "content/public/common/content_switches.h"
#include "ui/gfx/gl/gl_bindings.h"
#include "ui/gfx/gl/gl_context.h"
#include "ui/gfx/gl/gl_implementation.h"
#include "ui/gfx/gl/gl_surface_egl.h"
#include "ui/gfx/native_widget_types.h"
namespace {
// We are backed by an Pbuffer offscreen surface through which ANGLE provides
// a handle to the corresponding render target texture through an extension.
class PbufferImageTransportSurface
: public gfx::GLSurfaceAdapter,
public ImageTransportSurface,
public base::SupportsWeakPtr<PbufferImageTransportSurface> {
public:
PbufferImageTransportSurface(GpuChannelManager* manager,
int32 render_view_id,
int32 renderer_id,
int32 command_buffer_id);
// gfx::GLSurface implementation
virtual bool Initialize() OVERRIDE;
virtual void Destroy() OVERRIDE;
virtual bool IsOffscreen() OVERRIDE;
virtual bool SwapBuffers() OVERRIDE;
virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
virtual std::string GetExtensions() OVERRIDE;
virtual void SetVisible(bool visible) OVERRIDE;
protected:
// ImageTransportSurface implementation
virtual void OnNewSurfaceACK(uint64 surface_id,
TransportDIB::Handle shm_handle) OVERRIDE;
virtual void OnBuffersSwappedACK() OVERRIDE;
virtual void OnPostSubBufferACK() OVERRIDE;
virtual void OnResizeViewACK() OVERRIDE;
virtual void OnResize(gfx::Size size) OVERRIDE;
private:
virtual ~PbufferImageTransportSurface();
void SendBuffersSwapped();
// Whether the surface is currently visible.
bool is_visible_;
// Size to resize to when the surface becomes visible.
gfx::Size visible_size_;
scoped_ptr<ImageTransportHelper> helper_;
DISALLOW_COPY_AND_ASSIGN(PbufferImageTransportSurface);
};
PbufferImageTransportSurface::PbufferImageTransportSurface(
GpuChannelManager* manager,
int32 render_view_id,
int32 renderer_id,
int32 command_buffer_id)
: GLSurfaceAdapter(new gfx::PbufferGLSurfaceEGL(false,
gfx::Size(1, 1))),
is_visible_(true) {
helper_.reset(new ImageTransportHelper(this,
manager,
render_view_id,
renderer_id,
command_buffer_id,
gfx::kNullPluginWindow));
}
PbufferImageTransportSurface::~PbufferImageTransportSurface() {
Destroy();
}
bool PbufferImageTransportSurface::Initialize() {
// Only support this path if the GL implementation is ANGLE.
// IO surfaces will not work with, for example, OSMesa software renderer
// GL contexts.
if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2)
return false;
if (!helper_->Initialize())
return false;
return GLSurfaceAdapter::Initialize();
}
void PbufferImageTransportSurface::Destroy() {
helper_->Destroy();
GLSurfaceAdapter::Destroy();
}
bool PbufferImageTransportSurface::IsOffscreen() {
return false;
}
bool PbufferImageTransportSurface::SwapBuffers() {
HANDLE surface_handle = GetShareHandle();
if (!surface_handle)
return false;
helper_->DeferToFence(base::Bind(
&PbufferImageTransportSurface::SendBuffersSwapped,
AsWeakPtr()));
return true;
}
bool PbufferImageTransportSurface::PostSubBuffer(
int x, int y, int width, int height) {
NOTREACHED();
return false;
}
void PbufferImageTransportSurface::SetVisible(bool visible) {
if (visible == is_visible_)
return;
is_visible_ = visible;
if (visible)
Resize(visible_size_);
else
Resize(gfx::Size(1, 1));
}
std::string PbufferImageTransportSurface::GetExtensions() {
std::string extensions = gfx::GLSurface::GetExtensions();
extensions += extensions.empty() ? "" : " ";
extensions += "GL_CHROMIUM_front_buffer_cached";
return extensions;
}
void PbufferImageTransportSurface::SendBuffersSwapped() {
GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
params.surface_id = reinterpret_cast<int64>(GetShareHandle());
params.size = GetSize();
helper_->SendAcceleratedSurfaceBuffersSwapped(params);
helper_->SetScheduled(false);
}
void PbufferImageTransportSurface::OnBuffersSwappedACK() {
helper_->SetScheduled(true);
}
void PbufferImageTransportSurface::OnPostSubBufferACK() {
NOTREACHED();
}
void PbufferImageTransportSurface::OnNewSurfaceACK(
uint64 surface_id,
TransportDIB::Handle shm_handle) {
NOTREACHED();
}
void PbufferImageTransportSurface::OnResizeViewACK() {
NOTREACHED();
}
void PbufferImageTransportSurface::OnResize(gfx::Size size) {
if (is_visible_)
Resize(size);
visible_size_ = size;
}
} // namespace anonymous
// static
scoped_refptr<gfx::GLSurface> ImageTransportSurface::CreateSurface(
GpuChannelManager* manager,
int32 render_view_id,
int32 renderer_id,
int32 command_buffer_id,
gfx::PluginWindowHandle handle) {
scoped_refptr<gfx::GLSurface> surface;
base::win::OSInfo* os_info = base::win::OSInfo::GetInstance();
if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
gfx::g_EGL_ANGLE_query_surface_pointer &&
gfx::g_EGL_ANGLE_d3d_share_handle_client_buffer &&
!CommandLine::ForCurrentProcess()->HasSwitch(
switches::kDisableImageTransportSurface)) {
surface = new PbufferImageTransportSurface(manager,
render_view_id,
renderer_id,
command_buffer_id);
} else {
surface = gfx::GLSurface::CreateViewGLSurface(false, handle);
if (!surface.get())
return NULL;
surface = new PassThroughImageTransportSurface(manager,
render_view_id,
renderer_id,
command_buffer_id,
surface.get());
}
if (surface->Initialize())
return surface;
else
return NULL;
}
#endif // ENABLE_GPU
|
