gpu/blink/webgraphicscontext3d_impl.h - Issue 972713002: gpu/blink: Cleanup - Remove 'using' declarations from webgraphicscontext3d_impl.h.

Side by Side Diff: gpu/blink/webgraphicscontext3d_impl.h

Issue 972713002: gpu/blink: Cleanup - Remove 'using' declarations from webgraphicscontext3d_impl.h. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: review + REBASE Created 5 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.	1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be	2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.	3 // found in the LICENSE file.

4	4

5 #ifndef GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_	5 #ifndef GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_

6 #define GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_	6 #define GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_

7	7

8 #include <string>	8 #include <string>

9 #include <vector>	9 #include <vector>

10	10

11 #include "base/callback.h"	11 #include "base/callback.h"

12 #include "base/memory/scoped_ptr.h"	12 #include "base/memory/scoped_ptr.h"

13 #include "gpu/blink/gpu_blink_export.h"	13 #include "gpu/blink/gpu_blink_export.h"

14 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"	14 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"

15 #include "third_party/WebKit/public/platform/WebString.h"	15 #include "third_party/WebKit/public/platform/WebString.h"

16	16

17 namespace gpu {	17 namespace gpu {

18	18

19 namespace gles2 {	19 namespace gles2 {

20 class GLES2Interface;	20 class GLES2Interface;

21 class GLES2ImplementationErrorMessageCallback;	21 class GLES2ImplementationErrorMessageCallback;

22 struct ContextCreationAttribHelper;	22 struct ContextCreationAttribHelper;

23 }	23 }

24 }	24 }

25	25

26 using blink::WebGLId;

27

28 using blink::WGC3Dbyte;

29 using blink::WGC3Dchar;

30 using blink::WGC3Denum;

31 using blink::WGC3Dboolean;

32 using blink::WGC3Dbitfield;

33 using blink::WGC3Dint;

34 using blink::WGC3Dsizei;

35 using blink::WGC3Duint;

36 using blink::WGC3Dfloat;

37 using blink::WGC3Dclampf;

38 using blink::WGC3Dintptr;

39 using blink::WGC3Dsizeiptr;

40 using blink::WGC3Duint64;

41

42 namespace gpu_blink {	26 namespace gpu_blink {

43	27

44 class WebGraphicsContext3DErrorMessageCallback;	28 class WebGraphicsContext3DErrorMessageCallback;

45	29

46 class GPU_BLINK_EXPORT WebGraphicsContext3DImpl	30 class GPU_BLINK_EXPORT WebGraphicsContext3DImpl

47 : public NON_EXPORTED_BASE(blink::WebGraphicsContext3D) {	31 : public NON_EXPORTED_BASE(blink::WebGraphicsContext3D) {

48 public:	32 public:

49 virtual ~WebGraphicsContext3DImpl();	33 virtual ~WebGraphicsContext3DImpl();

50	34

51 //----------------------------------------------------------------------	35 //----------------------------------------------------------------------

52 // WebGraphicsContext3D methods	36 // WebGraphicsContext3D methods

53	37

54 virtual uint32_t lastFlushID();	38 virtual uint32_t lastFlushID();

55	39

56 virtual unsigned int insertSyncPoint();	40 virtual unsigned int insertSyncPoint();

57 virtual void waitSyncPoint(unsigned int sync_point);	41 virtual void waitSyncPoint(unsigned int sync_point);

58	42

59 virtual void loseContextCHROMIUM(WGC3Denum current, WGC3Denum other);	43 virtual void loseContextCHROMIUM(blink::WGC3Denum current,

	44 blink::WGC3Denum other);

60	45

61 virtual void reshapeWithScaleFactor(	46 virtual void reshapeWithScaleFactor(

62 int width, int height, float scale_factor);	47 int width, int height, float scale_factor);

63	48

64 virtual void prepareTexture();	49 virtual void prepareTexture();

65 virtual void postSubBufferCHROMIUM(int x, int y, int width, int height);	50 virtual void postSubBufferCHROMIUM(int x, int y, int width, int height);

66	51

67 virtual void activeTexture(WGC3Denum texture);	52 virtual void activeTexture(blink::WGC3Denum texture);

68 virtual void attachShader(WebGLId program, WebGLId shader);	53 virtual void attachShader(blink::WebGLId program, blink::WebGLId shader);

69 virtual void bindAttribLocation(WebGLId program, WGC3Duint index,	54 virtual void bindAttribLocation(blink::WebGLId program,

70 const WGC3Dchar* name);	55 blink::WGC3Duint index,

71 virtual void bindBuffer(WGC3Denum target, WebGLId buffer);	56 const blink::WGC3Dchar* name);

72 virtual void bindFramebuffer(WGC3Denum target, WebGLId framebuffer);	57 virtual void bindBuffer(blink::WGC3Denum target, blink::WebGLId buffer);

73 virtual void bindRenderbuffer(WGC3Denum target, WebGLId renderbuffer);	58 virtual void bindFramebuffer(blink::WGC3Denum target,

74 virtual void bindTexture(WGC3Denum target, WebGLId texture);	59 blink::WebGLId framebuffer);

75 virtual void blendColor(WGC3Dclampf red, WGC3Dclampf green,	60 virtual void bindRenderbuffer(blink::WGC3Denum target,

76 WGC3Dclampf blue, WGC3Dclampf alpha);	61 blink::WebGLId renderbuffer);

77 virtual void blendEquation(WGC3Denum mode);	62 virtual void bindTexture(blink::WGC3Denum target, blink::WebGLId texture);

78 virtual void blendEquationSeparate(WGC3Denum modeRGB,	63 virtual void blendColor(blink::WGC3Dclampf red,

79 WGC3Denum modeAlpha);	64 blink::WGC3Dclampf green,

80 virtual void blendFunc(WGC3Denum sfactor, WGC3Denum dfactor);	65 blink::WGC3Dclampf blue,

81 virtual void blendFuncSeparate(WGC3Denum srcRGB,	66 blink::WGC3Dclampf alpha);

82 WGC3Denum dstRGB,	67 virtual void blendEquation(blink::WGC3Denum mode);

83 WGC3Denum srcAlpha,	68 virtual void blendEquationSeparate(blink::WGC3Denum modeRGB,

84 WGC3Denum dstAlpha);	69 blink::WGC3Denum modeAlpha);

85	70 virtual void blendFunc(blink::WGC3Denum sfactor, blink::WGC3Denum dfactor);

86 virtual void bufferData(WGC3Denum target, WGC3Dsizeiptr size,	71 virtual void blendFuncSeparate(blink::WGC3Denum srcRGB,

87 const void* data, WGC3Denum usage);	72 blink::WGC3Denum dstRGB,

88 virtual void bufferSubData(WGC3Denum target, WGC3Dintptr offset,	73 blink::WGC3Denum srcAlpha,

89 WGC3Dsizeiptr size, const void* data);	74 blink::WGC3Denum dstAlpha);

90	75

91 virtual WGC3Denum checkFramebufferStatus(WGC3Denum target);	76 virtual void bufferData(blink::WGC3Denum target,

92 virtual void clear(WGC3Dbitfield mask);	77 blink::WGC3Dsizeiptr size,

93 virtual void clearColor(WGC3Dclampf red, WGC3Dclampf green,	78 const void* data,

94 WGC3Dclampf blue, WGC3Dclampf alpha);	79 blink::WGC3Denum usage);

95 virtual void clearDepth(WGC3Dclampf depth);	80 virtual void bufferSubData(blink::WGC3Denum target,

96 virtual void clearStencil(WGC3Dint s);	81 blink::WGC3Dintptr offset,

97 virtual void colorMask(WGC3Dboolean red, WGC3Dboolean green,	82 blink::WGC3Dsizeiptr size,

98 WGC3Dboolean blue, WGC3Dboolean alpha);	83 const void* data);

99 virtual void compileShader(WebGLId shader);	84

100	85 virtual blink::WGC3Denum checkFramebufferStatus(blink::WGC3Denum target);

101 virtual void compressedTexImage2D(WGC3Denum target,	86 virtual void clear(blink::WGC3Dbitfield mask);

102 WGC3Dint level,	87 virtual void clearColor(blink::WGC3Dclampf red,

103 WGC3Denum internalformat,	88 blink::WGC3Dclampf green,

104 WGC3Dsizei width,	89 blink::WGC3Dclampf blue,

105 WGC3Dsizei height,	90 blink::WGC3Dclampf alpha);

106 WGC3Dint border,	91 virtual void clearDepth(blink::WGC3Dclampf depth);

107 WGC3Dsizei imageSize,	92 virtual void clearStencil(blink::WGC3Dint s);

	93 virtual void colorMask(blink::WGC3Dboolean red,

	94 blink::WGC3Dboolean green,

	95 blink::WGC3Dboolean blue,

	96 blink::WGC3Dboolean alpha);

	97 virtual void compileShader(blink::WebGLId shader);

	98

	99 virtual void compressedTexImage2D(blink::WGC3Denum target,

	100 blink::WGC3Dint level,

	101 blink::WGC3Denum internalformat,

	102 blink::WGC3Dsizei width,

	103 blink::WGC3Dsizei height,

	104 blink::WGC3Dint border,

	105 blink::WGC3Dsizei imageSize,

108 const void* data);	106 const void* data);

109 virtual void compressedTexSubImage2D(WGC3Denum target,	107 virtual void compressedTexSubImage2D(blink::WGC3Denum target,

110 WGC3Dint level,	108 blink::WGC3Dint level,

111 WGC3Dint xoffset,	109 blink::WGC3Dint xoffset,

112 WGC3Dint yoffset,	110 blink::WGC3Dint yoffset,

113 WGC3Dsizei width,	111 blink::WGC3Dsizei width,

114 WGC3Dsizei height,	112 blink::WGC3Dsizei height,

115 WGC3Denum format,	113 blink::WGC3Denum format,

116 WGC3Dsizei imageSize,	114 blink::WGC3Dsizei imageSize,

117 const void* data);	115 const void* data);

118 virtual void copyTexImage2D(WGC3Denum target,	116 virtual void copyTexImage2D(blink::WGC3Denum target,

119 WGC3Dint level,	117 blink::WGC3Dint level,

120 WGC3Denum internalformat,	118 blink::WGC3Denum internalformat,

121 WGC3Dint x,	119 blink::WGC3Dint x,

122 WGC3Dint y,	120 blink::WGC3Dint y,

123 WGC3Dsizei width,	121 blink::WGC3Dsizei width,

124 WGC3Dsizei height,	122 blink::WGC3Dsizei height,

125 WGC3Dint border);	123 blink::WGC3Dint border);

126 virtual void copyTexSubImage2D(WGC3Denum target,	124 virtual void copyTexSubImage2D(blink::WGC3Denum target,

127 WGC3Dint level,	125 blink::WGC3Dint level,

128 WGC3Dint xoffset,	126 blink::WGC3Dint xoffset,

129 WGC3Dint yoffset,	127 blink::WGC3Dint yoffset,

130 WGC3Dint x,	128 blink::WGC3Dint x,

131 WGC3Dint y,	129 blink::WGC3Dint y,

132 WGC3Dsizei width,	130 blink::WGC3Dsizei width,

133 WGC3Dsizei height);	131 blink::WGC3Dsizei height);

134 virtual void cullFace(WGC3Denum mode);	132 virtual void cullFace(blink::WGC3Denum mode);

135 virtual void depthFunc(WGC3Denum func);	133 virtual void depthFunc(blink::WGC3Denum func);

136 virtual void depthMask(WGC3Dboolean flag);	134 virtual void depthMask(blink::WGC3Dboolean flag);

137 virtual void depthRange(WGC3Dclampf zNear, WGC3Dclampf zFar);	135 virtual void depthRange(blink::WGC3Dclampf zNear, blink::WGC3Dclampf zFar);

138 virtual void detachShader(WebGLId program, WebGLId shader);	136 virtual void detachShader(blink::WebGLId program, blink::WebGLId shader);

139 virtual void disable(WGC3Denum cap);	137 virtual void disable(blink::WGC3Denum cap);

140 virtual void disableVertexAttribArray(WGC3Duint index);	138 virtual void disableVertexAttribArray(blink::WGC3Duint index);

141 virtual void drawArrays(WGC3Denum mode, WGC3Dint first, WGC3Dsizei count);	139 virtual void drawArrays(blink::WGC3Denum mode,

142 virtual void drawElements(WGC3Denum mode,	140 blink::WGC3Dint first,

143 WGC3Dsizei count,	141 blink::WGC3Dsizei count);

144 WGC3Denum type,	142 virtual void drawElements(blink::WGC3Denum mode,

145 WGC3Dintptr offset);	143 blink::WGC3Dsizei count,

146	144 blink::WGC3Denum type,

147 virtual void enable(WGC3Denum cap);	145 blink::WGC3Dintptr offset);

148 virtual void enableVertexAttribArray(WGC3Duint index);	146

	147 virtual void enable(blink::WGC3Denum cap);

	148 virtual void enableVertexAttribArray(blink::WGC3Duint index);

149 virtual void finish();	149 virtual void finish();

150 virtual void flush();	150 virtual void flush();

151 virtual void framebufferRenderbuffer(WGC3Denum target,	151 virtual void framebufferRenderbuffer(blink::WGC3Denum target,

152 WGC3Denum attachment,	152 blink::WGC3Denum attachment,

153 WGC3Denum renderbuffertarget,	153 blink::WGC3Denum renderbuffertarget,

154 WebGLId renderbuffer);	154 blink::WebGLId renderbuffer);

155 virtual void framebufferTexture2D(WGC3Denum target,	155 virtual void framebufferTexture2D(blink::WGC3Denum target,

156 WGC3Denum attachment,	156 blink::WGC3Denum attachment,

157 WGC3Denum textarget,	157 blink::WGC3Denum textarget,

158 WebGLId texture,	158 blink::WebGLId texture,

159 WGC3Dint level);	159 blink::WGC3Dint level);

160 virtual void frontFace(WGC3Denum mode);	160 virtual void frontFace(blink::WGC3Denum mode);

161 virtual void generateMipmap(WGC3Denum target);	161 virtual void generateMipmap(blink::WGC3Denum target);

162	162

163 virtual bool getActiveAttrib(WebGLId program,	163 virtual bool getActiveAttrib(blink::WebGLId program,

164 WGC3Duint index,	164 blink::WGC3Duint index,

165 ActiveInfo&);	165 ActiveInfo&);

166 virtual bool getActiveUniform(WebGLId program,	166 virtual bool getActiveUniform(blink::WebGLId program,

167 WGC3Duint index,	167 blink::WGC3Duint index,

168 ActiveInfo&);	168 ActiveInfo&);

169	169

170 virtual void getAttachedShaders(WebGLId program,	170 virtual void getAttachedShaders(blink::WebGLId program,

171 WGC3Dsizei maxCount,	171 blink::WGC3Dsizei maxCount,

172 WGC3Dsizei* count,	172 blink::WGC3Dsizei* count,

173 WebGLId* shaders);	173 blink::WebGLId* shaders);

174	174

175 virtual WGC3Dint getAttribLocation(WebGLId program, const WGC3Dchar* name);	175 virtual blink::WGC3Dint getAttribLocation(blink::WebGLId program,

176	176 const blink::WGC3Dchar* name);

177 virtual void getBooleanv(WGC3Denum pname, WGC3Dboolean* value);	177

178	178 virtual void getBooleanv(blink::WGC3Denum pname, blink::WGC3Dboolean* value);

179 virtual void getBufferParameteriv(WGC3Denum target,	179

180 WGC3Denum pname,	180 virtual void getBufferParameteriv(blink::WGC3Denum target,

181 WGC3Dint* value);	181 blink::WGC3Denum pname,

182	182 blink::WGC3Dint* value);

183 virtual WGC3Denum getError();	183

184	184 virtual blink::WGC3Denum getError();

185 virtual void getFloatv(WGC3Denum pname, WGC3Dfloat* value);	185

186	186 virtual void getFloatv(blink::WGC3Denum pname, blink::WGC3Dfloat* value);

187 virtual void getFramebufferAttachmentParameteriv(WGC3Denum target,	187

188 WGC3Denum attachment,	188 virtual void getFramebufferAttachmentParameteriv(blink::WGC3Denum target,

189 WGC3Denum pname,	189 blink::WGC3Denum attachment,

190 WGC3Dint* value);	190 blink::WGC3Denum pname,

191	191 blink::WGC3Dint* value);

192 virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value);	192

193	193 virtual void getIntegerv(blink::WGC3Denum pname, blink::WGC3Dint* value);

194 virtual void getProgramiv(WebGLId program, WGC3Denum pname, WGC3Dint* value);	194

195	195 virtual void getProgramiv(blink::WebGLId program,

196 virtual blink::WebString getProgramInfoLog(WebGLId program);	196 blink::WGC3Denum pname,

197	197 blink::WGC3Dint* value);

198 virtual void getRenderbufferParameteriv(WGC3Denum target,	198

199 WGC3Denum pname,	199 virtual blink::WebString getProgramInfoLog(blink::WebGLId program);

200 WGC3Dint* value);	200

201	201 virtual void getRenderbufferParameteriv(blink::WGC3Denum target,

202 virtual void getShaderiv(WebGLId shader, WGC3Denum pname, WGC3Dint* value);	202 blink::WGC3Denum pname,

203	203 blink::WGC3Dint* value);

204 virtual blink::WebString getShaderInfoLog(WebGLId shader);	204

205	205 virtual void getShaderiv(blink::WebGLId shader,

206 virtual void getShaderPrecisionFormat(WGC3Denum shadertype,	206 blink::WGC3Denum pname,

207 WGC3Denum precisiontype,	207 blink::WGC3Dint* value);

208 WGC3Dint* range,	208

209 WGC3Dint* precision);	209 virtual blink::WebString getShaderInfoLog(blink::WebGLId shader);

210	210

211 virtual blink::WebString getShaderSource(WebGLId shader);	211 virtual void getShaderPrecisionFormat(blink::WGC3Denum shadertype,

212 virtual blink::WebString getString(WGC3Denum name);	212 blink::WGC3Denum precisiontype,

213	213 blink::WGC3Dint* range,

214 virtual void getTexParameterfv(WGC3Denum target,	214 blink::WGC3Dint* precision);

215 WGC3Denum pname,	215

216 WGC3Dfloat* value);	216 virtual blink::WebString getShaderSource(blink::WebGLId shader);

217 virtual void getTexParameteriv(WGC3Denum target,	217 virtual blink::WebString getString(blink::WGC3Denum name);

218 WGC3Denum pname,	218

219 WGC3Dint* value);	219 virtual void getTexParameterfv(blink::WGC3Denum target,

220	220 blink::WGC3Denum pname,

221 virtual void getUniformfv(WebGLId program,	221 blink::WGC3Dfloat* value);

222 WGC3Dint location,	222 virtual void getTexParameteriv(blink::WGC3Denum target,

223 WGC3Dfloat* value);	223 blink::WGC3Denum pname,

224 virtual void getUniformiv(WebGLId program,	224 blink::WGC3Dint* value);

225 WGC3Dint location,	225

226 WGC3Dint* value);	226 virtual void getUniformfv(blink::WebGLId program,

227	227 blink::WGC3Dint location,

228 virtual WGC3Dint getUniformLocation(WebGLId program, const WGC3Dchar* name);	228 blink::WGC3Dfloat* value);

229	229 virtual void getUniformiv(blink::WebGLId program,

230 virtual void getVertexAttribfv(WGC3Duint index, WGC3Denum pname,	230 blink::WGC3Dint location,

231 WGC3Dfloat* value);	231 blink::WGC3Dint* value);

232 virtual void getVertexAttribiv(WGC3Duint index, WGC3Denum pname,	232

233 WGC3Dint* value);	233 virtual blink::WGC3Dint getUniformLocation(blink::WebGLId program,

234	234 const blink::WGC3Dchar* name);

235 virtual WGC3Dsizeiptr getVertexAttribOffset(WGC3Duint index, WGC3Denum pname);	235

236	236 virtual void getVertexAttribfv(blink::WGC3Duint index,

237 virtual void hint(WGC3Denum target, WGC3Denum mode);	237 blink::WGC3Denum pname,

238 virtual WGC3Dboolean isBuffer(WebGLId buffer);	238 blink::WGC3Dfloat* value);

239 virtual WGC3Dboolean isEnabled(WGC3Denum cap);	239 virtual void getVertexAttribiv(blink::WGC3Duint index,

240 virtual WGC3Dboolean isFramebuffer(WebGLId framebuffer);	240 blink::WGC3Denum pname,

241 virtual WGC3Dboolean isProgram(WebGLId program);	241 blink::WGC3Dint* value);

242 virtual WGC3Dboolean isRenderbuffer(WebGLId renderbuffer);	242

243 virtual WGC3Dboolean isShader(WebGLId shader);	243 virtual blink::WGC3Dsizeiptr getVertexAttribOffset(blink::WGC3Duint index,

244 virtual WGC3Dboolean isTexture(WebGLId texture);	244 blink::WGC3Denum pname);

245 virtual void lineWidth(WGC3Dfloat);	245

246 virtual void linkProgram(WebGLId program);	246 virtual void hint(blink::WGC3Denum target, blink::WGC3Denum mode);

247 virtual void pixelStorei(WGC3Denum pname, WGC3Dint param);	247 virtual blink::WGC3Dboolean isBuffer(blink::WebGLId buffer);

248 virtual void polygonOffset(WGC3Dfloat factor, WGC3Dfloat units);	248 virtual blink::WGC3Dboolean isEnabled(blink::WGC3Denum cap);

249	249 virtual blink::WGC3Dboolean isFramebuffer(blink::WebGLId framebuffer);

250 virtual void readPixels(WGC3Dint x,	250 virtual blink::WGC3Dboolean isProgram(blink::WebGLId program);

251 WGC3Dint y,	251 virtual blink::WGC3Dboolean isRenderbuffer(blink::WebGLId renderbuffer);

252 WGC3Dsizei width,	252 virtual blink::WGC3Dboolean isShader(blink::WebGLId shader);

253 WGC3Dsizei height,	253 virtual blink::WGC3Dboolean isTexture(blink::WebGLId texture);

254 WGC3Denum format,	254 virtual void lineWidth(blink::WGC3Dfloat);

255 WGC3Denum type,	255 virtual void linkProgram(blink::WebGLId program);

	256 virtual void pixelStorei(blink::WGC3Denum pname, blink::WGC3Dint param);

	257 virtual void polygonOffset(blink::WGC3Dfloat factor, blink::WGC3Dfloat units);

	258

	259 virtual void readPixels(blink::WGC3Dint x,

	260 blink::WGC3Dint y,

	261 blink::WGC3Dsizei width,

	262 blink::WGC3Dsizei height,

	263 blink::WGC3Denum format,

	264 blink::WGC3Denum type,

256 void* pixels);	265 void* pixels);

257	266

258 virtual void releaseShaderCompiler();	267 virtual void releaseShaderCompiler();

259 virtual void renderbufferStorage(WGC3Denum target,	268 virtual void renderbufferStorage(blink::WGC3Denum target,

260 WGC3Denum internalformat,	269 blink::WGC3Denum internalformat,

261 WGC3Dsizei width,	270 blink::WGC3Dsizei width,

262 WGC3Dsizei height);	271 blink::WGC3Dsizei height);

263 virtual void sampleCoverage(WGC3Dfloat value, WGC3Dboolean invert);	272 virtual void sampleCoverage(blink::WGC3Dfloat value,

264 virtual void scissor(WGC3Dint x, WGC3Dint y,	273 blink::WGC3Dboolean invert);

265 WGC3Dsizei width, WGC3Dsizei height);	274 virtual void scissor(blink::WGC3Dint x,

266 virtual void shaderSource(WebGLId shader, const WGC3Dchar* string);	275 blink::WGC3Dint y,

267 virtual void stencilFunc(WGC3Denum func, WGC3Dint ref, WGC3Duint mask);	276 blink::WGC3Dsizei width,

268 virtual void stencilFuncSeparate(WGC3Denum face,	277 blink::WGC3Dsizei height);

269 WGC3Denum func,	278 virtual void shaderSource(blink::WebGLId shader,

270 WGC3Dint ref,	279 const blink::WGC3Dchar* string);

271 WGC3Duint mask);	280 virtual void stencilFunc(blink::WGC3Denum func,

272 virtual void stencilMask(WGC3Duint mask);	281 blink::WGC3Dint ref,

273 virtual void stencilMaskSeparate(WGC3Denum face, WGC3Duint mask);	282 blink::WGC3Duint mask);

274 virtual void stencilOp(WGC3Denum fail,	283 virtual void stencilFuncSeparate(blink::WGC3Denum face,

275 WGC3Denum zfail,	284 blink::WGC3Denum func,

276 WGC3Denum zpass);	285 blink::WGC3Dint ref,

277 virtual void stencilOpSeparate(WGC3Denum face,	286 blink::WGC3Duint mask);

278 WGC3Denum fail,	287 virtual void stencilMask(blink::WGC3Duint mask);

279 WGC3Denum zfail,	288 virtual void stencilMaskSeparate(blink::WGC3Denum face,

280 WGC3Denum zpass);	289 blink::WGC3Duint mask);

281	290 virtual void stencilOp(blink::WGC3Denum fail,

282 virtual void texImage2D(WGC3Denum target,	291 blink::WGC3Denum zfail,

283 WGC3Dint level,	292 blink::WGC3Denum zpass);

284 WGC3Denum internalformat,	293 virtual void stencilOpSeparate(blink::WGC3Denum face,

285 WGC3Dsizei width,	294 blink::WGC3Denum fail,

286 WGC3Dsizei height,	295 blink::WGC3Denum zfail,

287 WGC3Dint border,	296 blink::WGC3Denum zpass);

288 WGC3Denum format,	297

289 WGC3Denum type,	298 virtual void texImage2D(blink::WGC3Denum target,

	299 blink::WGC3Dint level,

	300 blink::WGC3Denum internalformat,

	301 blink::WGC3Dsizei width,

	302 blink::WGC3Dsizei height,

	303 blink::WGC3Dint border,

	304 blink::WGC3Denum format,

	305 blink::WGC3Denum type,

290 const void* pixels);	306 const void* pixels);

291	307

292 virtual void texParameterf(WGC3Denum target,	308 virtual void texParameterf(blink::WGC3Denum target,

293 WGC3Denum pname,	309 blink::WGC3Denum pname,

294 WGC3Dfloat param);	310 blink::WGC3Dfloat param);

295 virtual void texParameteri(WGC3Denum target,	311 virtual void texParameteri(blink::WGC3Denum target,

296 WGC3Denum pname,	312 blink::WGC3Denum pname,

297 WGC3Dint param);	313 blink::WGC3Dint param);

298	314

299 virtual void texSubImage2D(WGC3Denum target,	315 virtual void texSubImage2D(blink::WGC3Denum target,

300 WGC3Dint level,	316 blink::WGC3Dint level,

301 WGC3Dint xoffset,	317 blink::WGC3Dint xoffset,

302 WGC3Dint yoffset,	318 blink::WGC3Dint yoffset,

303 WGC3Dsizei width,	319 blink::WGC3Dsizei width,

304 WGC3Dsizei height,	320 blink::WGC3Dsizei height,

305 WGC3Denum format,	321 blink::WGC3Denum format,

306 WGC3Denum type,	322 blink::WGC3Denum type,

307 const void* pixels);	323 const void* pixels);

308	324

309 virtual void uniform1f(WGC3Dint location, WGC3Dfloat x);	325 virtual void uniform1f(blink::WGC3Dint location, blink::WGC3Dfloat x);

310 virtual void uniform1fv(WGC3Dint location,	326 virtual void uniform1fv(blink::WGC3Dint location,

311 WGC3Dsizei count, const WGC3Dfloat* v);	327 blink::WGC3Dsizei count,

312 virtual void uniform1i(WGC3Dint location, WGC3Dint x);	328 const blink::WGC3Dfloat* v);

313 virtual void uniform1iv(WGC3Dint location,	329 virtual void uniform1i(blink::WGC3Dint location, blink::WGC3Dint x);

314 WGC3Dsizei count, const WGC3Dint* v);	330 virtual void uniform1iv(blink::WGC3Dint location,

315 virtual void uniform2f(WGC3Dint location, WGC3Dfloat x, WGC3Dfloat y);	331 blink::WGC3Dsizei count,

316 virtual void uniform2fv(WGC3Dint location,	332 const blink::WGC3Dint* v);

317 WGC3Dsizei count, const WGC3Dfloat* v);	333 virtual void uniform2f(blink::WGC3Dint location,

318 virtual void uniform2i(WGC3Dint location, WGC3Dint x, WGC3Dint y);	334 blink::WGC3Dfloat x,

319 virtual void uniform2iv(WGC3Dint location,	335 blink::WGC3Dfloat y);

320 WGC3Dsizei count, const WGC3Dint* v);	336 virtual void uniform2fv(blink::WGC3Dint location,

321 virtual void uniform3f(WGC3Dint location,	337 blink::WGC3Dsizei count,

322 WGC3Dfloat x, WGC3Dfloat y, WGC3Dfloat z);	338 const blink::WGC3Dfloat* v);

323 virtual void uniform3fv(WGC3Dint location,	339 virtual void uniform2i(blink::WGC3Dint location,

324 WGC3Dsizei count, const WGC3Dfloat* v);	340 blink::WGC3Dint x,

325 virtual void uniform3i(WGC3Dint location,	341 blink::WGC3Dint y);

326 WGC3Dint x, WGC3Dint y, WGC3Dint z);	342 virtual void uniform2iv(blink::WGC3Dint location,

327 virtual void uniform3iv(WGC3Dint location,	343 blink::WGC3Dsizei count,

328 WGC3Dsizei count, const WGC3Dint* v);	344 const blink::WGC3Dint* v);

329 virtual void uniform4f(WGC3Dint location,	345 virtual void uniform3f(blink::WGC3Dint location,

330 WGC3Dfloat x, WGC3Dfloat y,	346 blink::WGC3Dfloat x,

331 WGC3Dfloat z, WGC3Dfloat w);	347 blink::WGC3Dfloat y,

332 virtual void uniform4fv(WGC3Dint location,	348 blink::WGC3Dfloat z);

333 WGC3Dsizei count, const WGC3Dfloat* v);	349 virtual void uniform3fv(blink::WGC3Dint location,

334 virtual void uniform4i(WGC3Dint location,	350 blink::WGC3Dsizei count,

335 WGC3Dint x, WGC3Dint y, WGC3Dint z, WGC3Dint w);	351 const blink::WGC3Dfloat* v);

336 virtual void uniform4iv(WGC3Dint location,	352 virtual void uniform3i(blink::WGC3Dint location,

337 WGC3Dsizei count, const WGC3Dint* v);	353 blink::WGC3Dint x,

338 virtual void uniformMatrix2fv(WGC3Dint location,	354 blink::WGC3Dint y,

339 WGC3Dsizei count,	355 blink::WGC3Dint z);

340 WGC3Dboolean transpose,	356 virtual void uniform3iv(blink::WGC3Dint location,

341 const WGC3Dfloat* value);	357 blink::WGC3Dsizei count,

342 virtual void uniformMatrix3fv(WGC3Dint location,	358 const blink::WGC3Dint* v);

343 WGC3Dsizei count,	359 virtual void uniform4f(blink::WGC3Dint location,

344 WGC3Dboolean transpose,	360 blink::WGC3Dfloat x,

345 const WGC3Dfloat* value);	361 blink::WGC3Dfloat y,

346 virtual void uniformMatrix4fv(WGC3Dint location,	362 blink::WGC3Dfloat z,

347 WGC3Dsizei count,	363 blink::WGC3Dfloat w);

348 WGC3Dboolean transpose,	364 virtual void uniform4fv(blink::WGC3Dint location,

349 const WGC3Dfloat* value);	365 blink::WGC3Dsizei count,

350	366 const blink::WGC3Dfloat* v);

351 virtual void useProgram(WebGLId program);	367 virtual void uniform4i(blink::WGC3Dint location,

352 virtual void validateProgram(WebGLId program);	368 blink::WGC3Dint x,

353	369 blink::WGC3Dint y,

354 virtual void vertexAttrib1f(WGC3Duint index, WGC3Dfloat x);	370 blink::WGC3Dint z,

355 virtual void vertexAttrib1fv(WGC3Duint index, const WGC3Dfloat* values);	371 blink::WGC3Dint w);

356 virtual void vertexAttrib2f(WGC3Duint index, WGC3Dfloat x, WGC3Dfloat y);	372 virtual void uniform4iv(blink::WGC3Dint location,

357 virtual void vertexAttrib2fv(WGC3Duint index, const WGC3Dfloat* values);	373 blink::WGC3Dsizei count,

358 virtual void vertexAttrib3f(WGC3Duint index,	374 const blink::WGC3Dint* v);

359 WGC3Dfloat x, WGC3Dfloat y, WGC3Dfloat z);	375 virtual void uniformMatrix2fv(blink::WGC3Dint location,

360 virtual void vertexAttrib3fv(WGC3Duint index, const WGC3Dfloat* values);	376 blink::WGC3Dsizei count,

361 virtual void vertexAttrib4f(WGC3Duint index,	377 blink::WGC3Dboolean transpose,

362 WGC3Dfloat x, WGC3Dfloat y,	378 const blink::WGC3Dfloat* value);

363 WGC3Dfloat z, WGC3Dfloat w);	379 virtual void uniformMatrix3fv(blink::WGC3Dint location,

364 virtual void vertexAttrib4fv(WGC3Duint index, const WGC3Dfloat* values);	380 blink::WGC3Dsizei count,

365 virtual void vertexAttribPointer(WGC3Duint index,	381 blink::WGC3Dboolean transpose,

366 WGC3Dint size,	382 const blink::WGC3Dfloat* value);

367 WGC3Denum type,	383 virtual void uniformMatrix4fv(blink::WGC3Dint location,

368 WGC3Dboolean normalized,	384 blink::WGC3Dsizei count,

369 WGC3Dsizei stride,	385 blink::WGC3Dboolean transpose,

370 WGC3Dintptr offset);	386 const blink::WGC3Dfloat* value);

371	387

372 virtual void viewport(WGC3Dint x, WGC3Dint y,	388 virtual void useProgram(blink::WebGLId program);

373 WGC3Dsizei width, WGC3Dsizei height);	389 virtual void validateProgram(blink::WebGLId program);

374	390

375 virtual WebGLId createBuffer();	391 virtual void vertexAttrib1f(blink::WGC3Duint index, blink::WGC3Dfloat x);

376 virtual WebGLId createFramebuffer();	392 virtual void vertexAttrib1fv(blink::WGC3Duint index,

377 virtual WebGLId createRenderbuffer();	393 const blink::WGC3Dfloat* values);

378 virtual WebGLId createTexture();	394 virtual void vertexAttrib2f(blink::WGC3Duint index,

379	395 blink::WGC3Dfloat x,

380 virtual void deleteBuffer(WebGLId);	396 blink::WGC3Dfloat y);

381 virtual void deleteFramebuffer(WebGLId);	397 virtual void vertexAttrib2fv(blink::WGC3Duint index,

382 virtual void deleteRenderbuffer(WebGLId);	398 const blink::WGC3Dfloat* values);

383 virtual void deleteTexture(WebGLId);	399 virtual void vertexAttrib3f(blink::WGC3Duint index,

384	400 blink::WGC3Dfloat x,

385 virtual WebGLId createProgram();	401 blink::WGC3Dfloat y,

386 virtual WebGLId createShader(WGC3Denum);	402 blink::WGC3Dfloat z);

387	403 virtual void vertexAttrib3fv(blink::WGC3Duint index,

388 virtual void deleteProgram(WebGLId);	404 const blink::WGC3Dfloat* values);

389 virtual void deleteShader(WebGLId);	405 virtual void vertexAttrib4f(blink::WGC3Duint index,

390	406 blink::WGC3Dfloat x,

391 virtual void synthesizeGLError(WGC3Denum);	407 blink::WGC3Dfloat y,

392	408 blink::WGC3Dfloat z,

393 virtual void* mapBufferSubDataCHROMIUM(	409 blink::WGC3Dfloat w);

394 WGC3Denum target, WGC3Dintptr offset,	410 virtual void vertexAttrib4fv(blink::WGC3Duint index,

395 WGC3Dsizeiptr size, WGC3Denum access);	411 const blink::WGC3Dfloat* values);

	412 virtual void vertexAttribPointer(blink::WGC3Duint index,

	413 blink::WGC3Dint size,

	414 blink::WGC3Denum type,

	415 blink::WGC3Dboolean normalized,

	416 blink::WGC3Dsizei stride,

	417 blink::WGC3Dintptr offset);

	418

	419 virtual void viewport(blink::WGC3Dint x,

	420 blink::WGC3Dint y,

	421 blink::WGC3Dsizei width,

	422 blink::WGC3Dsizei height);

	423

	424 virtual blink::WebGLId createBuffer();

	425 virtual blink::WebGLId createFramebuffer();

	426 virtual blink::WebGLId createRenderbuffer();

	427 virtual blink::WebGLId createTexture();

	428

	429 virtual void deleteBuffer(blink::WebGLId);

	430 virtual void deleteFramebuffer(blink::WebGLId);

	431 virtual void deleteRenderbuffer(blink::WebGLId);

	432 virtual void deleteTexture(blink::WebGLId);

	433

	434 virtual blink::WebGLId createProgram();

	435 virtual blink::WebGLId createShader(blink::WGC3Denum);

	436

	437 virtual void deleteProgram(blink::WebGLId);

	438 virtual void deleteShader(blink::WebGLId);

	439

	440 virtual void synthesizeGLError(blink::WGC3Denum);

	441

	442 virtual void* mapBufferSubDataCHROMIUM(blink::WGC3Denum target,

	443 blink::WGC3Dintptr offset,

	444 blink::WGC3Dsizeiptr size,

	445 blink::WGC3Denum access);

396 virtual void unmapBufferSubDataCHROMIUM(const void*);	446 virtual void unmapBufferSubDataCHROMIUM(const void*);

397 virtual void* mapTexSubImage2DCHROMIUM(	447 virtual void* mapTexSubImage2DCHROMIUM(blink::WGC3Denum target,

398 WGC3Denum target,	448 blink::WGC3Dint level,

399 WGC3Dint level,	449 blink::WGC3Dint xoffset,

400 WGC3Dint xoffset,	450 blink::WGC3Dint yoffset,

401 WGC3Dint yoffset,	451 blink::WGC3Dsizei width,

402 WGC3Dsizei width,	452 blink::WGC3Dsizei height,

403 WGC3Dsizei height,	453 blink::WGC3Denum format,

404 WGC3Denum format,	454 blink::WGC3Denum type,

405 WGC3Denum type,	455 blink::WGC3Denum access);

406 WGC3Denum access);

407 virtual void unmapTexSubImage2DCHROMIUM(const void*);	456 virtual void unmapTexSubImage2DCHROMIUM(const void*);

408	457

409 virtual void setVisibilityCHROMIUM(bool visible);	458 virtual void setVisibilityCHROMIUM(bool visible);

410	459

411 virtual void discardFramebufferEXT(WGC3Denum target,	460 virtual void discardFramebufferEXT(blink::WGC3Denum target,

412 WGC3Dsizei numAttachments,	461 blink::WGC3Dsizei numAttachments,

413 const WGC3Denum* attachments);	462 const blink::WGC3Denum* attachments);

414 virtual void copyTextureToParentTextureCHROMIUM(	463 virtual void copyTextureToParentTextureCHROMIUM(blink::WebGLId texture,

415 WebGLId texture, WebGLId parentTexture);	464 blink::WebGLId parentTexture);

416	465

417 virtual blink::WebString getRequestableExtensionsCHROMIUM();	466 virtual blink::WebString getRequestableExtensionsCHROMIUM();

418 virtual void requestExtensionCHROMIUM(const char*);	467 virtual void requestExtensionCHROMIUM(const char*);

419	468

420 virtual void blitFramebufferCHROMIUM(	469 virtual void blitFramebufferCHROMIUM(blink::WGC3Dint srcX0,

421 WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1,	470 blink::WGC3Dint srcY0,

422 WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1,	471 blink::WGC3Dint srcX1,

423 WGC3Dbitfield mask, WGC3Denum filter);	472 blink::WGC3Dint srcY1,

	473 blink::WGC3Dint dstX0,

	474 blink::WGC3Dint dstY0,

	475 blink::WGC3Dint dstX1,

	476 blink::WGC3Dint dstY1,

	477 blink::WGC3Dbitfield mask,

	478 blink::WGC3Denum filter);

424 virtual void renderbufferStorageMultisampleCHROMIUM(	479 virtual void renderbufferStorageMultisampleCHROMIUM(

425 WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat,	480 blink::WGC3Denum target,

426 WGC3Dsizei width, WGC3Dsizei height);	481 blink::WGC3Dsizei samples,

427	482 blink::WGC3Denum internalformat,

428 virtual blink::WebString getTranslatedShaderSourceANGLE(WebGLId shader);	483 blink::WGC3Dsizei width,

	484 blink::WGC3Dsizei height);

	485

	486 virtual blink::WebString getTranslatedShaderSourceANGLE(

	487 blink::WebGLId shader);

429	488

430 virtual void setContextLostCallback(	489 virtual void setContextLostCallback(

431 WebGraphicsContext3D::WebGraphicsContextLostCallback* callback);	490 WebGraphicsContext3D::WebGraphicsContextLostCallback* callback);

432	491

433 virtual void setErrorMessageCallback(	492 virtual void setErrorMessageCallback(

434 WebGraphicsContext3D::WebGraphicsErrorMessageCallback* callback);	493 WebGraphicsContext3D::WebGraphicsErrorMessageCallback* callback);

435	494

436 virtual void texImageIOSurface2DCHROMIUM(	495 virtual void texImageIOSurface2DCHROMIUM(blink::WGC3Denum target,

437 WGC3Denum target, WGC3Dint width, WGC3Dint height,	496 blink::WGC3Dint width,

438 WGC3Duint ioSurfaceId, WGC3Duint plane);	497 blink::WGC3Dint height,

439	498 blink::WGC3Duint ioSurfaceId,

440 virtual void texStorage2DEXT(	499 blink::WGC3Duint plane);

441 WGC3Denum target, WGC3Dint levels, WGC3Duint internalformat,	500

442 WGC3Dint width, WGC3Dint height);	501 virtual void texStorage2DEXT(blink::WGC3Denum target,

443	502 blink::WGC3Dint levels,

444 virtual WebGLId createQueryEXT();	503 blink::WGC3Duint internalformat,

445 virtual void deleteQueryEXT(WebGLId query);	504 blink::WGC3Dint width,

446 virtual WGC3Dboolean isQueryEXT(WGC3Duint query);	505 blink::WGC3Dint height);

447 virtual void beginQueryEXT(WGC3Denum target, WebGLId query);	506

448 virtual void endQueryEXT(WGC3Denum target);	507 virtual blink::WebGLId createQueryEXT();

449 virtual void getQueryivEXT(	508 virtual void deleteQueryEXT(blink::WebGLId query);

450 WGC3Denum target, WGC3Denum pname, WGC3Dint* params);	509 virtual blink::WGC3Dboolean isQueryEXT(blink::WGC3Duint query);

451 virtual void getQueryObjectuivEXT(	510 virtual void beginQueryEXT(blink::WGC3Denum target, blink::WebGLId query);

452 WebGLId query, WGC3Denum pname, WGC3Duint* params);	511 virtual void endQueryEXT(blink::WGC3Denum target);

	512 virtual void getQueryivEXT(blink::WGC3Denum target,

	513 blink::WGC3Denum pname,

	514 blink::WGC3Dint* params);

	515 virtual void getQueryObjectuivEXT(blink::WebGLId query,

	516 blink::WGC3Denum pname,

	517 blink::WGC3Duint* params);

453	518

454 // TODO(dshwang): Remove \|level\| in Blink and then remove it.	519 // TODO(dshwang): Remove \|level\| in Blink and then remove it.

455 void copyTextureCHROMIUM(WGC3Denum target,	520 void copyTextureCHROMIUM(blink::WGC3Denum target,

456 WebGLId source_id,	521 blink::WebGLId source_id,

457 WebGLId dest_id,	522 blink::WebGLId dest_id,

458 WGC3Dint level,	523 blink::WGC3Dint level,

459 WGC3Denum internal_format,	524 blink::WGC3Denum internal_format,

460 WGC3Denum dest_type) override;	525 blink::WGC3Denum dest_type) override;

461	526

462 void copySubTextureCHROMIUM(WGC3Denum target,	527 void copySubTextureCHROMIUM(blink::WGC3Denum target,

463 WebGLId source_id,	528 blink::WebGLId source_id,

464 WebGLId dest_id,	529 blink::WebGLId dest_id,

465 WGC3Dint level,	530 blink::WGC3Dint level,

466 WGC3Dint xoffset,	531 blink::WGC3Dint xoffset,

467 WGC3Dint yoffset) override;	532 blink::WGC3Dint yoffset) override;

468	533

469 virtual void copyTextureCHROMIUM(WGC3Denum target,	534 virtual void copyTextureCHROMIUM(blink::WGC3Denum target,

470 WebGLId source_id,	535 blink::WebGLId source_id,

471 WebGLId dest_id,	536 blink::WebGLId dest_id,

472 WGC3Denum internal_format,	537 blink::WGC3Denum internal_format,

473 WGC3Denum dest_type);	538 blink::WGC3Denum dest_type);

474	539

475 virtual void copySubTextureCHROMIUM(WGC3Denum target,	540 virtual void copySubTextureCHROMIUM(blink::WGC3Denum target,

476 WebGLId sourceId,	541 blink::WebGLId sourceId,

477 WebGLId destId,	542 blink::WebGLId destId,

478 WGC3Dint xoffset,	543 blink::WGC3Dint xoffset,

479 WGC3Dint yoffset);	544 blink::WGC3Dint yoffset);

480	545

481 virtual void bindUniformLocationCHROMIUM(WebGLId program, WGC3Dint location,	546 virtual void bindUniformLocationCHROMIUM(blink::WebGLId program,

482 const WGC3Dchar* uniform);	547 blink::WGC3Dint location,

	548 const blink::WGC3Dchar* uniform);

483	549

484 virtual void shallowFlushCHROMIUM();	550 virtual void shallowFlushCHROMIUM();

485 virtual void shallowFinishCHROMIUM();	551 virtual void shallowFinishCHROMIUM();

486	552

487 virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox);	553 virtual void genMailboxCHROMIUM(blink::WGC3Dbyte* mailbox);

488 virtual void produceTextureCHROMIUM(WGC3Denum target,	554 virtual void produceTextureCHROMIUM(blink::WGC3Denum target,

489 const WGC3Dbyte* mailbox);	555 const blink::WGC3Dbyte* mailbox);

490 virtual void produceTextureDirectCHROMIUM(WebGLId texture, WGC3Denum target,	556 virtual void produceTextureDirectCHROMIUM(blink::WebGLId texture,

491 const WGC3Dbyte* mailbox);	557 blink::WGC3Denum target,

492 virtual void consumeTextureCHROMIUM(WGC3Denum target,	558 const blink::WGC3Dbyte* mailbox);

493 const WGC3Dbyte* mailbox);	559 virtual void consumeTextureCHROMIUM(blink::WGC3Denum target,

494 virtual WebGLId createAndConsumeTextureCHROMIUM(WGC3Denum target,	560 const blink::WGC3Dbyte* mailbox);

495 const WGC3Dbyte* mailbox);	561 virtual blink::WebGLId createAndConsumeTextureCHROMIUM(

496	562 blink::WGC3Denum target,

497 virtual void genValuebuffersCHROMIUM(WGC3Dsizei count, WebGLId* ids);	563 const blink::WGC3Dbyte* mailbox);

498 virtual WebGLId createValuebufferCHROMIUM();	564

499 virtual void deleteValuebuffersCHROMIUM(WGC3Dsizei count, WebGLId* ids);	565 virtual void genValuebuffersCHROMIUM(blink::WGC3Dsizei count,

500 virtual void deleteValuebufferCHROMIUM(WebGLId);	566 blink::WebGLId* ids);

501 virtual void bindValuebufferCHROMIUM(WGC3Denum target, WebGLId valuebuffer);	567 virtual blink::WebGLId createValuebufferCHROMIUM();

502 virtual WGC3Dboolean isValuebufferCHROMIUM(WebGLId renderbuffer);	568 virtual void deleteValuebuffersCHROMIUM(blink::WGC3Dsizei count,

503 virtual void subscribeValueCHROMIUM(WGC3Denum target, WGC3Denum subscription);	569 blink::WebGLId* ids);

504 virtual void populateSubscribedValuesCHROMIUM(WGC3Denum target);	570 virtual void deleteValuebufferCHROMIUM(blink::WebGLId);

505 virtual void uniformValuebufferCHROMIUM(WGC3Dint location,	571 virtual void bindValuebufferCHROMIUM(blink::WGC3Denum target,

506 WGC3Denum target,	572 blink::WebGLId valuebuffer);

507 WGC3Denum subscription);	573 virtual blink::WGC3Dboolean isValuebufferCHROMIUM(

508 virtual void traceBeginCHROMIUM(const WGC3Dchar* category_name,	574 blink::WebGLId renderbuffer);

509 const WGC3Dchar* trace_name);	575 virtual void subscribeValueCHROMIUM(blink::WGC3Denum target,

	576 blink::WGC3Denum subscription);

	577 virtual void populateSubscribedValuesCHROMIUM(blink::WGC3Denum target);

	578 virtual void uniformValuebufferCHROMIUM(blink::WGC3Dint location,

	579 blink::WGC3Denum target,

	580 blink::WGC3Denum subscription);

	581 virtual void traceBeginCHROMIUM(const blink::WGC3Dchar* category_name,

	582 const blink::WGC3Dchar* trace_name);

510 virtual void traceEndCHROMIUM();	583 virtual void traceEndCHROMIUM();

511	584

512 virtual void insertEventMarkerEXT(const WGC3Dchar* marker);	585 virtual void insertEventMarkerEXT(const blink::WGC3Dchar* marker);

513 virtual void pushGroupMarkerEXT(const WGC3Dchar* marker);	586 virtual void pushGroupMarkerEXT(const blink::WGC3Dchar* marker);

514 virtual void popGroupMarkerEXT();	587 virtual void popGroupMarkerEXT();

515	588

516 // GL_OES_vertex_array_object	589 // GL_OES_vertex_array_object

517 virtual WebGLId createVertexArrayOES();	590 virtual blink::WebGLId createVertexArrayOES();

518 virtual void deleteVertexArrayOES(WebGLId array);	591 virtual void deleteVertexArrayOES(blink::WebGLId array);

519 virtual WGC3Dboolean isVertexArrayOES(WebGLId array);	592 virtual blink::WGC3Dboolean isVertexArrayOES(blink::WebGLId array);

520 virtual void bindVertexArrayOES(WebGLId array);	593 virtual void bindVertexArrayOES(blink::WebGLId array);

521	594

522 virtual void bindTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint image_id);	595 virtual void bindTexImage2DCHROMIUM(blink::WGC3Denum target,

523 virtual void releaseTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint image_id);	596 blink::WGC3Dint image_id);

524	597 virtual void releaseTexImage2DCHROMIUM(blink::WGC3Denum target,

525 virtual void* mapBufferCHROMIUM(WGC3Denum target, WGC3Denum access);	598 blink::WGC3Dint image_id);

526 virtual WGC3Dboolean unmapBufferCHROMIUM(WGC3Denum target);	599

	600 virtual void* mapBufferCHROMIUM(blink::WGC3Denum target,

	601 blink::WGC3Denum access);

	602 virtual blink::WGC3Dboolean unmapBufferCHROMIUM(blink::WGC3Denum target);

527	603

528 // Async pixel transfer functions.	604 // Async pixel transfer functions.

529 virtual void asyncTexImage2DCHROMIUM(	605 virtual void asyncTexImage2DCHROMIUM(blink::WGC3Denum target,

530 WGC3Denum target,	606 blink::WGC3Dint level,

531 WGC3Dint level,	607 blink::WGC3Denum internalformat,

532 WGC3Denum internalformat,	608 blink::WGC3Dsizei width,

533 WGC3Dsizei width,	609 blink::WGC3Dsizei height,

534 WGC3Dsizei height,	610 blink::WGC3Dint border,

535 WGC3Dint border,	611 blink::WGC3Denum format,

536 WGC3Denum format,	612 blink::WGC3Denum type,

537 WGC3Denum type,	613 const void* pixels);

538 const void* pixels);	614 virtual void asyncTexSubImage2DCHROMIUM(blink::WGC3Denum target,

539 virtual void asyncTexSubImage2DCHROMIUM(	615 blink::WGC3Dint level,

540 WGC3Denum target,	616 blink::WGC3Dint xoffset,

541 WGC3Dint level,	617 blink::WGC3Dint yoffset,

542 WGC3Dint xoffset,	618 blink::WGC3Dsizei width,

543 WGC3Dint yoffset,	619 blink::WGC3Dsizei height,

544 WGC3Dsizei width,	620 blink::WGC3Denum format,

545 WGC3Dsizei height,	621 blink::WGC3Denum type,

546 WGC3Denum format,	622 const void* pixels);

547 WGC3Denum type,	623 virtual void waitAsyncTexImage2DCHROMIUM(blink::WGC3Denum target);

548 const void* pixels);

549 virtual void waitAsyncTexImage2DCHROMIUM(WGC3Denum target);

550	624

551 // GL_EXT_draw_buffers	625 // GL_EXT_draw_buffers

552 virtual void drawBuffersEXT(	626 virtual void drawBuffersEXT(blink::WGC3Dsizei n,

553 WGC3Dsizei n,	627 const blink::WGC3Denum* bufs);

554 const WGC3Denum* bufs);

555	628

556 // GL_ANGLE_instanced_arrays	629 // GL_ANGLE_instanced_arrays

557 virtual void drawArraysInstancedANGLE(WGC3Denum mode, WGC3Dint first,	630 virtual void drawArraysInstancedANGLE(blink::WGC3Denum mode,

558 WGC3Dsizei count, WGC3Dsizei primcount);	631 blink::WGC3Dint first,

559 virtual void drawElementsInstancedANGLE(WGC3Denum mode, WGC3Dsizei count,	632 blink::WGC3Dsizei count,

560 WGC3Denum type, WGC3Dintptr offset, WGC3Dsizei primcount);	633 blink::WGC3Dsizei primcount);

561 virtual void vertexAttribDivisorANGLE(WGC3Duint index, WGC3Duint divisor);	634 virtual void drawElementsInstancedANGLE(blink::WGC3Denum mode,

	635 blink::WGC3Dsizei count,

	636 blink::WGC3Denum type,

	637 blink::WGC3Dintptr offset,

	638 blink::WGC3Dsizei primcount);

	639 virtual void vertexAttribDivisorANGLE(blink::WGC3Duint index,

	640 blink::WGC3Duint divisor);

562	641

563 // GL_CHROMIUM_gpu_memory_buffer_image	642 // GL_CHROMIUM_gpu_memory_buffer_image

564 virtual WGC3Duint createGpuMemoryBufferImageCHROMIUM(WGC3Dsizei width,	643 virtual blink::WGC3Duint createGpuMemoryBufferImageCHROMIUM(

565 WGC3Dsizei height,	644 blink::WGC3Dsizei width,

566 WGC3Denum internalformat,	645 blink::WGC3Dsizei height,

567 WGC3Denum usage);	646 blink::WGC3Denum internalformat,

568 virtual void destroyImageCHROMIUM(WGC3Duint image_id);	647 blink::WGC3Denum usage);

	648 virtual void destroyImageCHROMIUM(blink::WGC3Duint image_id);

569	649

570 // GL_EXT_multisampled_render_to_texture	650 // GL_EXT_multisampled_render_to_texture

571 virtual void framebufferTexture2DMultisampleEXT(WGC3Denum target,	651 virtual void framebufferTexture2DMultisampleEXT(blink::WGC3Denum target,

572 WGC3Denum attachment,	652 blink::WGC3Denum attachment,

573 WGC3Denum textarget,	653 blink::WGC3Denum textarget,

574 WebGLId texture,	654 blink::WebGLId texture,

575 WGC3Dint level,	655 blink::WGC3Dint level,

576 WGC3Dsizei samples);	656 blink::WGC3Dsizei samples);

577 virtual void renderbufferStorageMultisampleEXT(	657 virtual void renderbufferStorageMultisampleEXT(

578 WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat,	658 blink::WGC3Denum target,

579 WGC3Dsizei width, WGC3Dsizei height);	659 blink::WGC3Dsizei samples,

	660 blink::WGC3Denum internalformat,

	661 blink::WGC3Dsizei width,

	662 blink::WGC3Dsizei height);

580	663

581 // OpenGL ES 3.0 functions not represented by pre-existing extensions	664 // OpenGL ES 3.0 functions not represented by pre-existing extensions

582 virtual void beginTransformFeedback(WGC3Denum primitiveMode);	665 virtual void beginTransformFeedback(blink::WGC3Denum primitiveMode);

583 virtual void bindBufferBase(WGC3Denum target, WGC3Duint index,	666 virtual void bindBufferBase(blink::WGC3Denum target,

584 WGC3Duint buffer);	667 blink::WGC3Duint index,

585 virtual void bindBufferRange(WGC3Denum target, WGC3Duint index,	668 blink::WGC3Duint buffer);

586 WGC3Duint buffer, WGC3Dintptr offset, WGC3Dsizeiptr size);	669 virtual void bindBufferRange(blink::WGC3Denum target,

587 virtual void bindSampler(WGC3Duint unit, WebGLId sampler);	670 blink::WGC3Duint index,

588 virtual void bindTransformFeedback(WGC3Denum target,	671 blink::WGC3Duint buffer,

589 WebGLId transformfeedback);	672 blink::WGC3Dintptr offset,

590 virtual void clearBufferfi(WGC3Denum buffer, WGC3Dint drawbuffer,	673 blink::WGC3Dsizeiptr size);

591 WGC3Dfloat depth, WGC3Dint stencil);	674 virtual void bindSampler(blink::WGC3Duint unit, blink::WebGLId sampler);

592 virtual void clearBufferfv(WGC3Denum buffer, WGC3Dint drawbuffer,	675 virtual void bindTransformFeedback(blink::WGC3Denum target,

593 const WGC3Dfloat *value);	676 blink::WebGLId transformfeedback);

594 virtual void clearBufferiv(WGC3Denum buffer, WGC3Dint drawbuffer,	677 virtual void clearBufferfi(blink::WGC3Denum buffer,

595 const WGC3Dint *value);	678 blink::WGC3Dint drawbuffer,

596 virtual void clearBufferuiv(WGC3Denum buffer, WGC3Dint drawbuffer,	679 blink::WGC3Dfloat depth,

597 const WGC3Duint *value);	680 blink::WGC3Dint stencil);

598 //virtual WGC3Denum clientWaitSync(WebGLId sync, WGC3Dbitfield flags,	681 virtual void clearBufferfv(blink::WGC3Denum buffer,

599 // WGC3Duint64 timeout);	682 blink::WGC3Dint drawbuffer,

600 //virtual void compressedTexImage3D(WGC3Denum target, WGC3Dint level,	683 const blink::WGC3Dfloat* value);

601 // WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height,	684 virtual void clearBufferiv(blink::WGC3Denum buffer,

602 // WGC3Dsizei depth, WGC3Dint border, WGC3Dsizei imageSize,	685 blink::WGC3Dint drawbuffer,

603 // const void *data);	686 const blink::WGC3Dint* value);

604 //virtual void compressedTexSubImage3D(WGC3Denum target, WGC3Dint level,	687 virtual void clearBufferuiv(blink::WGC3Denum buffer,

605 // WGC3Dint xoffset, WGC3Dint yoffset, WGC3Dint zoffset, WGC3Dsizei width,	688 blink::WGC3Dint drawbuffer,

606 // WGC3Dsizei height, WGC3Dsizei depth, WGC3Denum format,	689 const blink::WGC3Duint* value);

	690 // virtual blink::WGC3Denum clientWaitSync(blink::WebGLId sync,

	691 // blink::WGC3Dbitfield flags,

	692 // blink::WGC3Duint64 timeout);

	693 // virtual void compressedTexImage3D(blink::WGC3Denum target, blink::WGC3Dint

	694 // level,

	695 // blink::WGC3Denum internalformat, blink::WGC3Dsizei width,

	696 // WGC3Dsizei height, WGC3Dsizei depth, blink::WGC3Dint border,

607 // WGC3Dsizei imageSize, const void *data);	697 // WGC3Dsizei imageSize, const void *data);

608 virtual void copyBufferSubData(WGC3Denum readTarget, WGC3Denum writeTarget,	698 // virtual void compressedTexSubImage3D(blink::WGC3Denum target,

609 WGC3Dintptr readOffset, WGC3Dintptr writeOffset, WGC3Dsizeiptr size);	699 // blink::WGC3Dint level, blink::WGC3Dint xoffset, blink::WGC3Dint yoffset,

610 virtual void copyTexSubImage3D(WGC3Denum target, WGC3Dint level,	700 // blink::WGC3Dint zoffset,

611 WGC3Dint xoffset, WGC3Dint yoffset, WGC3Dint zoffset, WGC3Dint x,	701 // blink::WGC3Dsizei width, blink::WGC3Dsizei height,

612 WGC3Dint y, WGC3Dsizei width, WGC3Dsizei height);	702 // blink::WGC3Dsizei depth, blink::WGC3Denum format,

613 virtual WebGLId createSampler();	703 // blink::WGC3Dsizei imageSize, const void *data);

614 virtual WebGLId createTransformFeedback();	704 virtual void copyBufferSubData(blink::WGC3Denum readTarget,

615 virtual void deleteSampler(WebGLId sampler);	705 blink::WGC3Denum writeTarget,

616 //virtual void deleteSync(WebGLId sync);	706 blink::WGC3Dintptr readOffset,

617 virtual void deleteTransformFeedback(WebGLId transformfeedback);	707 blink::WGC3Dintptr writeOffset,

	708 blink::WGC3Dsizeiptr size);

	709 virtual void copyTexSubImage3D(blink::WGC3Denum target,

	710 blink::WGC3Dint level,

	711 blink::WGC3Dint xoffset,

	712 blink::WGC3Dint yoffset,

	713 blink::WGC3Dint zoffset,

	714 blink::WGC3Dint x,

	715 blink::WGC3Dint y,

	716 blink::WGC3Dsizei width,

	717 blink::WGC3Dsizei height);

	718 virtual blink::WebGLId createSampler();

	719 virtual blink::WebGLId createTransformFeedback();

	720 virtual void deleteSampler(blink::WebGLId sampler);

	721 // virtual void deleteSync(blink::WebGLId sync);

	722 virtual void deleteTransformFeedback(blink::WebGLId transformfeedback);

618 virtual void endTransformFeedback(void);	723 virtual void endTransformFeedback(void);

619 //virtual WebGLId fenceSync(WGC3Denum condition, WGC3Dbitfield flags);	724 // virtual blink::WebGLId fenceSync(blink::WGC3Denum condition,

620 virtual void framebufferTextureLayer(WGC3Denum target, WGC3Denum attachment,	725 // blink::WGC3Dbitfield flags);

621 WGC3Duint texture, WGC3Dint level, WGC3Dint layer);	726 virtual void framebufferTextureLayer(blink::WGC3Denum target,

622 virtual void getActiveUniformBlockName(WGC3Duint program,	727 blink::WGC3Denum attachment,

623 WGC3Duint uniformBlockIndex, WGC3Dsizei bufSize, WGC3Dsizei *length,	728 blink::WGC3Duint texture,

624 WGC3Dchar *uniformBlockName);	729 blink::WGC3Dint level,

625 virtual void getActiveUniformBlockiv(WGC3Duint program,	730 blink::WGC3Dint layer);

626 WGC3Duint uniformBlockIndex, WGC3Denum pname, WGC3Dint *params);	731 virtual void getActiveUniformBlockName(blink::WGC3Duint program,

627 //virtual void getActiveUniformsiv(WGC3Duint program, WGC3Dsizei uniformCount,	732 blink::WGC3Duint uniformBlockIndex,

628 // const WGC3Duint uniformIndices, WGC3Denum pname, WGC3Dint params);	733 blink::WGC3Dsizei bufSize,

629 virtual WGC3Dint getFragDataLocation(WGC3Duint program,	734 blink::WGC3Dsizei* length,

630 const WGC3Dchar *name);	735 blink::WGC3Dchar* uniformBlockName);

631 virtual void getInternalformativ(WGC3Denum target, WGC3Denum internalformat,	736 virtual void getActiveUniformBlockiv(blink::WGC3Duint program,

632 WGC3Denum pname, WGC3Dsizei bufSize, WGC3Dint *params);	737 blink::WGC3Duint uniformBlockIndex,

633 virtual void getSamplerParameterfv(WGC3Duint sampler, WGC3Denum pname,	738 blink::WGC3Denum pname,

634 WGC3Dfloat *params);	739 blink::WGC3Dint* params);

635 virtual void getSamplerParameteriv(WGC3Duint sampler, WGC3Denum pname,	740 // virtual void getActiveUniformsiv(blink::WGC3Duint program,

636 WGC3Dint *params);	741 // blink::WGC3Dsizei uniformCount, const blink::WGC3Duint *uniformIndices,

637 //virtual void getTransformFeedbackVarying(WGC3Duint program, WGC3Duint index,	742 // blink::WGC3Denum pname, blink::WGC3Dint *params);

638 // WGC3Dsizei bufSize, WGC3Dsizei length, WGC3Dsizei size,	743 virtual blink::WGC3Dint getFragDataLocation(blink::WGC3Duint program,

639 // WGC3Denum type, WGC3Dchar name);	744 const blink::WGC3Dchar* name);

640 virtual WGC3Duint getUniformBlockIndex(WGC3Duint program,	745 virtual void getInternalformativ(blink::WGC3Denum target,

641 const WGC3Dchar *uniformBlockName);	746 blink::WGC3Denum internalformat,

642 //virtual void getUniformIndices(WGC3Duint program, WGC3Dsizei uniformCount,	747 blink::WGC3Denum pname,

643 // const WGC3Dchar constuniformNames, WGC3Duint *uniformIndices);	748 blink::WGC3Dsizei bufSize,

644 //virtual void getUniformuiv(WGC3Duint program, WGC3Dint location,	749 blink::WGC3Dint* params);

645 // WGC3Duint *params);	750 virtual void getSamplerParameterfv(blink::WGC3Duint sampler,

646 //virtual void getVertexAttribIiv(WGC3Duint index, WGC3Denum pname,	751 blink::WGC3Denum pname,

647 // WGC3Dint *params);	752 blink::WGC3Dfloat* params);

648 //virtual void getVertexAttribIuiv(WGC3Duint index, WGC3Denum pname,	753 virtual void getSamplerParameteriv(blink::WGC3Duint sampler,

649 // WGC3Duint *params);	754 blink::WGC3Denum pname,

650 virtual void invalidateFramebuffer(WGC3Denum target,	755 blink::WGC3Dint* params);

651 WGC3Dsizei numAttachments, const WGC3Denum *attachments);	756 // virtual void getTransformFeedbackVarying(blink::WGC3Duint program,

652 virtual void invalidateSubFramebuffer(WGC3Denum target,	757 // blink::WGC3Duint index,

653 WGC3Dsizei numAttachments, const WGC3Denum *attachments, WGC3Dint x,	758 // blink::WGC3Dsizei bufSize, blink::WGC3Dsizei *length,

654 WGC3Dint y, WGC3Dsizei width, WGC3Dsizei height);	759 // blink::WGC3Dsizei size, blink::WGC3Denum type,

655 virtual WGC3Dboolean isSampler(WebGLId sampler);	760 // blink::WGC3Dchar *name);

656 //virtual WGC3Dboolean isSync(WebGLId sync);	761 virtual blink::WGC3Duint getUniformBlockIndex(

657 virtual WGC3Dboolean isTransformFeedback(WGC3Duint id);	762 blink::WGC3Duint program,

	763 const blink::WGC3Dchar* uniformBlockName);

	764 // virtual void getUniformIndices(blink::WGC3Duint program,

	765 // blink::WGC3Dsizei uniformCount,

	766 // const blink::WGC3Dchar constuniformNames,

	767 // blink::WGC3Duint *uniformIndices);

	768 // virtual void getUniformuiv(blink::WGC3Duint program, blink::WGC3Dint

	769 // location,

	770 // blink::WGC3Duint *params);

	771 // virtual void getVertexAttribIiv(blink::WGC3Duint index, blink::WGC3Denum

	772 // pname,

	773 // blink::WGC3Dint *params);

	774 // virtual void getVertexAttribIuiv(blink::WGC3Duint index, blink::WGC3Denum

	775 // pname,

	776 // blink::WGC3Duint *params);

	777 virtual void invalidateFramebuffer(blink::WGC3Denum target,

	778 blink::WGC3Dsizei numAttachments,

	779 const blink::WGC3Denum* attachments);

	780 virtual void invalidateSubFramebuffer(blink::WGC3Denum target,

	781 blink::WGC3Dsizei numAttachments,

	782 const blink::WGC3Denum* attachments,

	783 blink::WGC3Dint x,

	784 blink::WGC3Dint y,

	785 blink::WGC3Dsizei width,

	786 blink::WGC3Dsizei height);

	787 virtual blink::WGC3Dboolean isSampler(blink::WebGLId sampler);

	788 // virtual blink::WGC3Dboolean isSync(blink::WebGLId sync);

	789 virtual blink::WGC3Dboolean isTransformFeedback(blink::WGC3Duint id);

658 virtual void pauseTransformFeedback(void);	790 virtual void pauseTransformFeedback(void);

659 //virtual void programParameteri(WGC3Duint program, WGC3Denum pname,	791 // virtual void programParameteri(blink::WGC3Duint program, blink::WGC3Denum

660 // WGC3Dint value);	792 // pname,

661 virtual void readBuffer(WGC3Denum src);	793 // blink::WGC3Dint value);

	794 virtual void readBuffer(blink::WGC3Denum src);

662 virtual void resumeTransformFeedback(void);	795 virtual void resumeTransformFeedback(void);

663 virtual void samplerParameterf(WGC3Duint sampler, WGC3Denum pname,	796 virtual void samplerParameterf(blink::WGC3Duint sampler,

664 WGC3Dfloat param);	797 blink::WGC3Denum pname,

665 virtual void samplerParameterfv(WGC3Duint sampler, WGC3Denum pname,	798 blink::WGC3Dfloat param);

666 const WGC3Dfloat *param);	799 virtual void samplerParameterfv(blink::WGC3Duint sampler,

667 virtual void samplerParameteri(WGC3Duint sampler, WGC3Denum pname,	800 blink::WGC3Denum pname,

668 WGC3Dint param);	801 const blink::WGC3Dfloat* param);

669 virtual void samplerParameteriv(WGC3Duint sampler, WGC3Denum pname,	802 virtual void samplerParameteri(blink::WGC3Duint sampler,

670 const WGC3Dint *param);	803 blink::WGC3Denum pname,

671 virtual void texImage3D(WGC3Denum target, WGC3Dint level,	804 blink::WGC3Dint param);

672 WGC3Dint internalformat, WGC3Dsizei width, WGC3Dsizei height,	805 virtual void samplerParameteriv(blink::WGC3Duint sampler,

673 WGC3Dsizei depth, WGC3Dint border, WGC3Denum format, WGC3Denum type,	806 blink::WGC3Denum pname,

674 const void *pixels);	807 const blink::WGC3Dint* param);

675 virtual void texStorage3D(WGC3Denum target, WGC3Dsizei levels,	808 virtual void texImage3D(blink::WGC3Denum target,

676 WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height,	809 blink::WGC3Dint level,

677 WGC3Dsizei depth);	810 blink::WGC3Dint internalformat,

678 virtual void texSubImage3D(WGC3Denum target, WGC3Dint level, WGC3Dint xoffset,	811 blink::WGC3Dsizei width,

679 WGC3Dint yoffset, WGC3Dint zoffset, WGC3Dsizei width, WGC3Dsizei height,	812 blink::WGC3Dsizei height,

680 WGC3Dsizei depth, WGC3Denum format, WGC3Denum type, const void *pixels);	813 blink::WGC3Dsizei depth,

681 virtual void transformFeedbackVaryings(WGC3Duint program, WGC3Dsizei count,	814 blink::WGC3Dint border,

682 const WGC3Dchar constvaryings, WGC3Denum bufferMode);	815 blink::WGC3Denum format,

683 virtual void uniform1ui(WGC3Dint location, WGC3Duint x);	816 blink::WGC3Denum type,

684 virtual void uniform1uiv(WGC3Dint location, WGC3Dsizei count,	817 const void* pixels);

685 const WGC3Duint *value);	818 virtual void texStorage3D(blink::WGC3Denum target,

686 virtual void uniform2ui(WGC3Dint location, WGC3Duint x, WGC3Duint y);	819 blink::WGC3Dsizei levels,

687 virtual void uniform2uiv(WGC3Dint location, WGC3Dsizei count,	820 blink::WGC3Denum internalformat,

688 const WGC3Duint *value);	821 blink::WGC3Dsizei width,

689 virtual void uniform3ui(WGC3Dint location, WGC3Duint x, WGC3Duint y,	822 blink::WGC3Dsizei height,

690 WGC3Duint z);	823 blink::WGC3Dsizei depth);

691 virtual void uniform3uiv(WGC3Dint location, WGC3Dsizei count,	824 virtual void texSubImage3D(blink::WGC3Denum target,

692 const WGC3Duint *value);	825 blink::WGC3Dint level,

693 virtual void uniform4ui(WGC3Dint location, WGC3Duint x, WGC3Duint y,	826 blink::WGC3Dint xoffset,

694 WGC3Duint z, WGC3Duint w);	827 blink::WGC3Dint yoffset,

695 virtual void uniform4uiv(WGC3Dint location, WGC3Dsizei count,	828 blink::WGC3Dint zoffset,

696 const WGC3Duint *value);	829 blink::WGC3Dsizei width,

697 virtual void uniformBlockBinding(WGC3Duint program,	830 blink::WGC3Dsizei height,

698 WGC3Duint uniformBlockIndex, WGC3Duint uniformBlockBinding);	831 blink::WGC3Dsizei depth,

699 virtual void uniformMatrix2x3fv(WGC3Dint location, WGC3Dsizei count,	832 blink::WGC3Denum format,

700 WGC3Dboolean transpose, const WGC3Dfloat* value);	833 blink::WGC3Denum type,

701 virtual void uniformMatrix2x4fv(WGC3Dint location, WGC3Dsizei count,	834 const void* pixels);

702 WGC3Dboolean transpose, const WGC3Dfloat* value);	835 virtual void transformFeedbackVaryings(

703 virtual void uniformMatrix3x2fv(WGC3Dint location, WGC3Dsizei count,	836 blink::WGC3Duint program,

704 WGC3Dboolean transpose, const WGC3Dfloat* value);	837 blink::WGC3Dsizei count,

705 virtual void uniformMatrix3x4fv(WGC3Dint location, WGC3Dsizei count,	838 const blink::WGC3Dchar* const* varyings,

706 WGC3Dboolean transpose, const WGC3Dfloat* value);	839 blink::WGC3Denum bufferMode);

707 virtual void uniformMatrix4x2fv(WGC3Dint location, WGC3Dsizei count,	840 virtual void uniform1ui(blink::WGC3Dint location, blink::WGC3Duint x);

708 WGC3Dboolean transpose, const WGC3Dfloat* value);	841 virtual void uniform1uiv(blink::WGC3Dint location,

709 virtual void uniformMatrix4x3fv(WGC3Dint location, WGC3Dsizei count,	842 blink::WGC3Dsizei count,

710 WGC3Dboolean transpose, const WGC3Dfloat* value);	843 const blink::WGC3Duint* value);

711 virtual void vertexAttribI4i(WGC3Duint index, WGC3Dint x, WGC3Dint y,	844 virtual void uniform2ui(blink::WGC3Dint location,

712 WGC3Dint z, WGC3Dint w);	845 blink::WGC3Duint x,

713 virtual void vertexAttribI4iv(WGC3Duint index, const WGC3Dint *v);	846 blink::WGC3Duint y);

714 virtual void vertexAttribI4ui(WGC3Duint index, WGC3Duint x, WGC3Duint y,	847 virtual void uniform2uiv(blink::WGC3Dint location,

715 WGC3Duint z, WGC3Duint w);	848 blink::WGC3Dsizei count,

716 virtual void vertexAttribI4uiv(WGC3Duint index, const WGC3Duint *v);	849 const blink::WGC3Duint* value);

717 virtual void vertexAttribIPointer(WGC3Duint index, WGC3Dint size,	850 virtual void uniform3ui(blink::WGC3Dint location,

718 WGC3Denum type, WGC3Dsizei stride, WGC3Dintptr pointer);	851 blink::WGC3Duint x,

719 //virtual void waitSync(WebGLId sync, WGC3Dbitfield flags,	852 blink::WGC3Duint y,

720 // WGC3Duint64 timeout);	853 blink::WGC3Duint z);

	854 virtual void uniform3uiv(blink::WGC3Dint location,

	855 blink::WGC3Dsizei count,

	856 const blink::WGC3Duint* value);

	857 virtual void uniform4ui(blink::WGC3Dint location,

	858 blink::WGC3Duint x,

	859 blink::WGC3Duint y,

	860 blink::WGC3Duint z,

	861 blink::WGC3Duint w);

	862 virtual void uniform4uiv(blink::WGC3Dint location,

	863 blink::WGC3Dsizei count,

	864 const blink::WGC3Duint* value);

	865 virtual void uniformBlockBinding(blink::WGC3Duint program,

	866 blink::WGC3Duint uniformBlockIndex,

	867 blink::WGC3Duint uniformBlockBinding);

	868 virtual void uniformMatrix2x3fv(blink::WGC3Dint location,

	869 blink::WGC3Dsizei count,

	870 blink::WGC3Dboolean transpose,

	871 const blink::WGC3Dfloat* value);

	872 virtual void uniformMatrix2x4fv(blink::WGC3Dint location,

	873 blink::WGC3Dsizei count,

	874 blink::WGC3Dboolean transpose,

	875 const blink::WGC3Dfloat* value);

	876 virtual void uniformMatrix3x2fv(blink::WGC3Dint location,

	877 blink::WGC3Dsizei count,

	878 blink::WGC3Dboolean transpose,

	879 const blink::WGC3Dfloat* value);

	880 virtual void uniformMatrix3x4fv(blink::WGC3Dint location,

	881 blink::WGC3Dsizei count,

	882 blink::WGC3Dboolean transpose,

	883 const blink::WGC3Dfloat* value);

	884 virtual void uniformMatrix4x2fv(blink::WGC3Dint location,

	885 blink::WGC3Dsizei count,

	886 blink::WGC3Dboolean transpose,

	887 const blink::WGC3Dfloat* value);

	888 virtual void uniformMatrix4x3fv(blink::WGC3Dint location,

	889 blink::WGC3Dsizei count,

	890 blink::WGC3Dboolean transpose,

	891 const blink::WGC3Dfloat* value);

	892 virtual void vertexAttribI4i(blink::WGC3Duint index,

	893 blink::WGC3Dint x,

	894 blink::WGC3Dint y,

	895 blink::WGC3Dint z,

	896 blink::WGC3Dint w);

	897 virtual void vertexAttribI4iv(blink::WGC3Duint index,

	898 const blink::WGC3Dint* v);

	899 virtual void vertexAttribI4ui(blink::WGC3Duint index,

	900 blink::WGC3Duint x,

	901 blink::WGC3Duint y,

	902 blink::WGC3Duint z,

	903 blink::WGC3Duint w);

	904 virtual void vertexAttribI4uiv(blink::WGC3Duint index,

	905 const blink::WGC3Duint* v);

	906 virtual void vertexAttribIPointer(blink::WGC3Duint index,

	907 blink::WGC3Dint size,

	908 blink::WGC3Denum type,

	909 blink::WGC3Dsizei stride,

	910 blink::WGC3Dintptr pointer);

	911 // virtual void waitSync(blink::WebGLId sync, blink::WGC3Dbitfield flags,

	912 // blink::WGC3Duint64 timeout);

721	913

722 virtual GrGLInterface* createGrGLInterface();	914 virtual GrGLInterface* createGrGLInterface();

723	915

724 ::gpu::gles2::GLES2Interface* GetGLInterface() {	916 ::gpu::gles2::GLES2Interface* GetGLInterface() {

725 return gl_;	917 return gl_;

726 }	918 }

727	919

728 // Convert WebGL context creation attributes into command buffer / EGL size	920 // Convert WebGL context creation attributes into command buffer / EGL size

729 // requests.	921 // requests.

730 static void ConvertAttributes(	922 static void ConvertAttributes(

(...skipping 10 matching lines...) Expand all Loading...
741 virtual void OnErrorMessage(const std::string& message, int id);	933 virtual void OnErrorMessage(const std::string& message, int id);

742	934

743 void setGLInterface(::gpu::gles2::GLES2Interface* gl) {	935 void setGLInterface(::gpu::gles2::GLES2Interface* gl) {

744 gl_ = gl;	936 gl_ = gl;

745 }	937 }

746	938

747 bool initialized_;	939 bool initialized_;

748 bool initialize_failed_;	940 bool initialize_failed_;

749	941

750 WebGraphicsContext3D::WebGraphicsContextLostCallback* context_lost_callback_;	942 WebGraphicsContext3D::WebGraphicsContextLostCallback* context_lost_callback_;

751 WGC3Denum context_lost_reason_;	943 blink::WGC3Denum context_lost_reason_;

752	944

753 WebGraphicsContext3D::WebGraphicsErrorMessageCallback*	945 WebGraphicsContext3D::WebGraphicsErrorMessageCallback*

754 error_message_callback_;	946 error_message_callback_;

755 scoped_ptr<WebGraphicsContext3DErrorMessageCallback>	947 scoped_ptr<WebGraphicsContext3DErrorMessageCallback>

756 client_error_message_callback_;	948 client_error_message_callback_;

757	949

758 // Errors raised by synthesizeGLError().	950 // Errors raised by synthesizeGLError().

759 std::vector<WGC3Denum> synthetic_errors_;	951 std::vector<blink::WGC3Denum> synthetic_errors_;

760	952

761 ::gpu::gles2::GLES2Interface* gl_;	953 ::gpu::gles2::GLES2Interface* gl_;

762 bool lose_context_when_out_of_memory_;	954 bool lose_context_when_out_of_memory_;

763 uint32_t flush_id_;	955 uint32_t flush_id_;

764 };	956 };

765	957

766 } // namespace gpu_blink	958 } // namespace gpu_blink

767	959

768 #endif // GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_	960 #endif // GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_

OLD	NEW

« no previous file with comments | « content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.cc ('k') | gpu/blink/webgraphicscontext3d_impl.cc » ('j') | no next file with comments »