Update from https://crrev.com/312398
Involves adding many //testing/test.gni imports, fixing one
SkSurface::NewRenderTarget invocation inside sky, and fixing up
base::Process usage in the shell.
Review URL: https://codereview.chromium.org/862133002
diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index 922a496..38cbb49 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -598,6 +598,44 @@
'GL_RENDERBUFFER',
],
},
+ 'Bufferiv': {
+ 'type': 'GLenum',
+ 'valid': [
+ 'GL_COLOR',
+ 'GL_STENCIL',
+ ],
+ 'invalid': [
+ 'GL_RENDERBUFFER',
+ ],
+ },
+ 'Bufferuiv': {
+ 'type': 'GLenum',
+ 'valid': [
+ 'GL_COLOR',
+ ],
+ 'invalid': [
+ 'GL_RENDERBUFFER',
+ ],
+ },
+ 'Bufferfv': {
+ 'type': 'GLenum',
+ 'valid': [
+ 'GL_COLOR',
+ 'GL_DEPTH',
+ ],
+ 'invalid': [
+ 'GL_RENDERBUFFER',
+ ],
+ },
+ 'Bufferfi': {
+ 'type': 'GLenum',
+ 'valid': [
+ 'GL_DEPTH_STENCIL',
+ ],
+ 'invalid': [
+ 'GL_RENDERBUFFER',
+ ],
+ },
'BufferUsage': {
'type': 'GLenum',
'valid': [
@@ -1377,6 +1415,8 @@
# for this command.
# needs_size: If True a data_size field is added to the command.
# count: The number of units per element. For PUTn or PUT types.
+# use_count_func: If True the actual data count needs to be computed; the count
+# argument specifies the maximum count.
# unit_test: If False no service side unit test will be generated.
# client_test: If False no client side unit test will be generated.
# expectation: If False the unit test will have no expected calls.
@@ -1504,6 +1544,26 @@
'defer_draws': True,
'trace_level': 1,
},
+ 'ClearBufferiv': {
+ 'type': 'PUT',
+ 'use_count_func': True,
+ 'count': 4,
+ 'unsafe': True,
+ },
+ 'ClearBufferuiv': {
+ 'type': 'PUT',
+ 'count': 4,
+ 'unsafe': True,
+ },
+ 'ClearBufferfv': {
+ 'type': 'PUT',
+ 'use_count_func': True,
+ 'count': 4,
+ 'unsafe': True,
+ },
+ 'ClearBufferfi': {
+ 'unsafe': True,
+ },
'ClearColor': {
'type': 'StateSet',
'state': 'ClearColor',
@@ -5624,6 +5684,10 @@
file.Write(" return error::kOutOfBounds;\n")
file.Write(" }\n")
+ def __NeedsToCalcDataCount(self, func):
+ use_count_func = func.GetInfo('use_count_func')
+ return use_count_func != None and use_count_func != False
+
def WriteGLES2Implementation(self, func, file):
"""Overrriden from TypeHandler."""
impl_func = func.GetInfo('impl_func')
@@ -5635,11 +5699,16 @@
file.Write(" GPU_CLIENT_SINGLE_THREAD_CHECK();\n")
func.WriteDestinationInitalizationValidation(file)
self.WriteClientGLCallLog(func, file)
- last_arg_name = func.GetLastOriginalArg().name
- values_str = ' << ", " << '.join(
- ["%s[%d]" % (last_arg_name, ndx) \
- for ndx in range(0, self.GetArrayCount(func))])
- file.Write(' GPU_CLIENT_LOG("values: " << %s);\n' % values_str)
+
+ if self.__NeedsToCalcDataCount(func):
+ file.Write(" size_t count = GLES2Util::Calc%sDataCount(%s);\n" %
+ (func.name, func.GetOriginalArgs()[0].name))
+ file.Write(" DCHECK_LE(count, %du);\n" % self.GetArrayCount(func))
+ else:
+ file.Write(" size_t count = %d;" % self.GetArrayCount(func))
+ file.Write(" for (size_t ii = 0; ii < count; ++ii)\n")
+ file.Write(' GPU_CLIENT_LOG("value[" << ii << "]: " << %s[ii]);\n' %
+ func.GetLastOriginalArg().name)
for arg in func.GetOriginalArgs():
arg.WriteClientSideValidationCode(file, func)
file.Write(" helper_->%sImmediate(%s);\n" %
@@ -5689,14 +5758,24 @@
"""Overrriden from TypeHandler."""
file.Write(" static uint32_t ComputeDataSize() {\n")
file.Write(" return static_cast<uint32_t>(\n")
- file.Write(" sizeof(%s) * %d); // NOLINT\n" %
+ file.Write(" sizeof(%s) * %d);\n" %
(self.GetArrayType(func), self.GetArrayCount(func)))
file.Write(" }\n")
file.Write("\n")
+ if self.__NeedsToCalcDataCount(func):
+ file.Write(" static uint32_t ComputeEffectiveDataSize(%s %s) {\n" %
+ (func.GetOriginalArgs()[0].type,
+ func.GetOriginalArgs()[0].name))
+ file.Write(" return static_cast<uint32_t>(\n")
+ file.Write(" sizeof(%s) * GLES2Util::Calc%sDataCount(%s));\n" %
+ (self.GetArrayType(func), func.original_name,
+ func.GetOriginalArgs()[0].name))
+ file.Write(" }\n")
+ file.Write("\n")
file.Write(" static uint32_t ComputeSize() {\n")
file.Write(" return static_cast<uint32_t>(\n")
file.Write(
- " sizeof(ValueType) + ComputeDataSize()); // NOLINT\n")
+ " sizeof(ValueType) + ComputeDataSize());\n")
file.Write(" }\n")
file.Write("\n")
@@ -5719,7 +5798,17 @@
for arg in args:
file.Write(" %s = _%s;\n" % (arg.name, arg.name))
file.Write(" memcpy(ImmediateDataAddress(this),\n")
- file.Write(" _%s, ComputeDataSize());\n" % last_arg.name)
+ if self.__NeedsToCalcDataCount(func):
+ file.Write(" _%s, ComputeEffectiveDataSize(%s));" %
+ (last_arg.name, func.GetOriginalArgs()[0].name))
+ file.Write("""
+ DCHECK_GE(ComputeDataSize(), ComputeEffectiveDataSize(%(arg)s));
+ char* pointer = reinterpret_cast<char*>(ImmediateDataAddress(this)) +
+ ComputeEffectiveDataSize(%(arg)s);
+ memset(pointer, 0, ComputeDataSize() - ComputeEffectiveDataSize(%(arg)s));
+""" % { 'arg': func.GetOriginalArgs()[0].name, })
+ else:
+ file.Write(" _%s, ComputeDataSize());\n" % last_arg.name)
file.Write(" }\n")
file.Write("\n")
@@ -9307,7 +9396,8 @@
gen.WriteCommonUtilsImpl(
"gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h")
gen.WriteGLES2Header("gpu/GLES2/gl2chromium_autogen.h")
- mojo_gles2_prefix = "mojo/public/c/gles2/gles2_call_visitor"
+ mojo_gles2_prefix = ("third_party/mojo/src/mojo/public/c/gles2/"
+ "gles2_call_visitor")
gen.WriteMojoGLCallVisitor(mojo_gles2_prefix + "_autogen.h")
gen.WriteMojoGLCallVisitorForExtension(
mojo_gles2_prefix + "_chromium_texture_mailbox_autogen.h",
diff --git a/gpu/command_buffer/client/gles2_c_lib_autogen.h b/gpu/command_buffer/client/gles2_c_lib_autogen.h
index 9264881..597ab2e 100644
--- a/gpu/command_buffer/client/gles2_c_lib_autogen.h
+++ b/gpu/command_buffer/client/gles2_c_lib_autogen.h
@@ -88,6 +88,25 @@
void GLES2Clear(GLbitfield mask) {
gles2::GetGLContext()->Clear(mask);
}
+void GLES2ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) {
+ gles2::GetGLContext()->ClearBufferfi(buffer, drawbuffers, depth, stencil);
+}
+void GLES2ClearBufferfv(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) {
+ gles2::GetGLContext()->ClearBufferfv(buffer, drawbuffers, value);
+}
+void GLES2ClearBufferiv(GLenum buffer, GLint drawbuffers, const GLint* value) {
+ gles2::GetGLContext()->ClearBufferiv(buffer, drawbuffers, value);
+}
+void GLES2ClearBufferuiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) {
+ gles2::GetGLContext()->ClearBufferuiv(buffer, drawbuffers, value);
+}
void GLES2ClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
@@ -1277,6 +1296,22 @@
reinterpret_cast<GLES2FunctionPointer>(glClear),
},
{
+ "glClearBufferfi",
+ reinterpret_cast<GLES2FunctionPointer>(glClearBufferfi),
+ },
+ {
+ "glClearBufferfv",
+ reinterpret_cast<GLES2FunctionPointer>(glClearBufferfv),
+ },
+ {
+ "glClearBufferiv",
+ reinterpret_cast<GLES2FunctionPointer>(glClearBufferiv),
+ },
+ {
+ "glClearBufferuiv",
+ reinterpret_cast<GLES2FunctionPointer>(glClearBufferuiv),
+ },
+ {
"glClearColor",
reinterpret_cast<GLES2FunctionPointer>(glClearColor),
},
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index 7f79e34..dc31b96 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -176,6 +176,49 @@
}
}
+void ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) {
+ gles2::cmds::ClearBufferfi* c = GetCmdSpace<gles2::cmds::ClearBufferfi>();
+ if (c) {
+ c->Init(buffer, drawbuffers, depth, stencil);
+ }
+}
+
+void ClearBufferfvImmediate(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) {
+ const uint32_t size = gles2::cmds::ClearBufferfvImmediate::ComputeSize();
+ gles2::cmds::ClearBufferfvImmediate* c =
+ GetImmediateCmdSpaceTotalSize<gles2::cmds::ClearBufferfvImmediate>(size);
+ if (c) {
+ c->Init(buffer, drawbuffers, value);
+ }
+}
+
+void ClearBufferivImmediate(GLenum buffer,
+ GLint drawbuffers,
+ const GLint* value) {
+ const uint32_t size = gles2::cmds::ClearBufferivImmediate::ComputeSize();
+ gles2::cmds::ClearBufferivImmediate* c =
+ GetImmediateCmdSpaceTotalSize<gles2::cmds::ClearBufferivImmediate>(size);
+ if (c) {
+ c->Init(buffer, drawbuffers, value);
+ }
+}
+
+void ClearBufferuivImmediate(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) {
+ const uint32_t size = gles2::cmds::ClearBufferuivImmediate::ComputeSize();
+ gles2::cmds::ClearBufferuivImmediate* c =
+ GetImmediateCmdSpaceTotalSize<gles2::cmds::ClearBufferuivImmediate>(size);
+ if (c) {
+ c->Init(buffer, drawbuffers, value);
+ }
+}
+
void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
gles2::cmds::ClearColor* c = GetCmdSpace<gles2::cmds::ClearColor>();
if (c) {
diff --git a/gpu/command_buffer/client/gles2_implementation_autogen.h b/gpu/command_buffer/client/gles2_implementation_autogen.h
index c2be814..16753ae 100644
--- a/gpu/command_buffer/client/gles2_implementation_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_autogen.h
@@ -71,6 +71,23 @@
void Clear(GLbitfield mask) override;
+void ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) override;
+
+void ClearBufferfv(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) override;
+
+void ClearBufferiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLint* value) override;
+
+void ClearBufferuiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) override;
+
void ClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
diff --git a/gpu/command_buffer/client/gles2_implementation_impl_autogen.h b/gpu/command_buffer/client/gles2_implementation_impl_autogen.h
index 95ca175..71ad0db 100644
--- a/gpu/command_buffer/client/gles2_implementation_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_impl_autogen.h
@@ -222,6 +222,65 @@
CheckGLError();
}
+void GLES2Implementation::ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) {
+ GPU_CLIENT_SINGLE_THREAD_CHECK();
+ GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClearBufferfi("
+ << GLES2Util::GetStringBufferfv(buffer) << ", "
+ << drawbuffers << ", " << depth << ", " << stencil << ")");
+ helper_->ClearBufferfi(buffer, drawbuffers, depth, stencil);
+ CheckGLError();
+}
+
+void GLES2Implementation::ClearBufferfv(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) {
+ GPU_CLIENT_SINGLE_THREAD_CHECK();
+ GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClearBufferfv("
+ << GLES2Util::GetStringBufferfv(buffer) << ", "
+ << drawbuffers << ", " << static_cast<const void*>(value)
+ << ")");
+ size_t count = GLES2Util::CalcClearBufferfvDataCount(buffer);
+ DCHECK_LE(count, 4u);
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << value[ii]);
+ helper_->ClearBufferfvImmediate(buffer, drawbuffers, value);
+ CheckGLError();
+}
+
+void GLES2Implementation::ClearBufferiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLint* value) {
+ GPU_CLIENT_SINGLE_THREAD_CHECK();
+ GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClearBufferiv("
+ << GLES2Util::GetStringBufferiv(buffer) << ", "
+ << drawbuffers << ", " << static_cast<const void*>(value)
+ << ")");
+ size_t count = GLES2Util::CalcClearBufferivDataCount(buffer);
+ DCHECK_LE(count, 4u);
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << value[ii]);
+ helper_->ClearBufferivImmediate(buffer, drawbuffers, value);
+ CheckGLError();
+}
+
+void GLES2Implementation::ClearBufferuiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) {
+ GPU_CLIENT_SINGLE_THREAD_CHECK();
+ GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClearBufferuiv("
+ << GLES2Util::GetStringBufferuiv(buffer) << ", "
+ << drawbuffers << ", " << static_cast<const void*>(value)
+ << ")");
+ size_t count = 4;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << value[ii]);
+ helper_->ClearBufferuivImmediate(buffer, drawbuffers, value);
+ CheckGLError();
+}
+
void GLES2Implementation::ClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
@@ -1536,7 +1595,9 @@
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glSamplerParameterfv(" << sampler
<< ", " << GLES2Util::GetStringSamplerParameter(pname)
<< ", " << static_cast<const void*>(params) << ")");
- GPU_CLIENT_LOG("values: " << params[0]);
+ size_t count = 1;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << params[ii]);
helper_->SamplerParameterfvImmediate(sampler, pname, params);
CheckGLError();
}
@@ -1559,7 +1620,9 @@
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glSamplerParameteriv(" << sampler
<< ", " << GLES2Util::GetStringSamplerParameter(pname)
<< ", " << static_cast<const void*>(params) << ")");
- GPU_CLIENT_LOG("values: " << params[0]);
+ size_t count = 1;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << params[ii]);
helper_->SamplerParameterivImmediate(sampler, pname, params);
CheckGLError();
}
@@ -1665,7 +1728,9 @@
<< GLES2Util::GetStringTextureBindTarget(target) << ", "
<< GLES2Util::GetStringTextureParameter(pname) << ", "
<< static_cast<const void*>(params) << ")");
- GPU_CLIENT_LOG("values: " << params[0]);
+ size_t count = 1;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << params[ii]);
helper_->TexParameterfvImmediate(target, pname, params);
CheckGLError();
}
@@ -1690,7 +1755,9 @@
<< GLES2Util::GetStringTextureBindTarget(target) << ", "
<< GLES2Util::GetStringTextureParameter(pname) << ", "
<< static_cast<const void*>(params) << ")");
- GPU_CLIENT_LOG("values: " << params[0]);
+ size_t count = 1;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << params[ii]);
helper_->TexParameterivImmediate(target, pname, params);
CheckGLError();
}
@@ -2391,7 +2458,9 @@
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib1fv(" << indx << ", "
<< static_cast<const void*>(values) << ")");
- GPU_CLIENT_LOG("values: " << values[0]);
+ size_t count = 1;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << values[ii]);
helper_->VertexAttrib1fvImmediate(indx, values);
CheckGLError();
}
@@ -2408,7 +2477,9 @@
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib2fv(" << indx << ", "
<< static_cast<const void*>(values) << ")");
- GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1]);
+ size_t count = 2;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << values[ii]);
helper_->VertexAttrib2fvImmediate(indx, values);
CheckGLError();
}
@@ -2428,8 +2499,9 @@
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib3fv(" << indx << ", "
<< static_cast<const void*>(values) << ")");
- GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1] << ", "
- << values[2]);
+ size_t count = 3;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << values[ii]);
helper_->VertexAttrib3fvImmediate(indx, values);
CheckGLError();
}
@@ -2450,8 +2522,9 @@
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttrib4fv(" << indx << ", "
<< static_cast<const void*>(values) << ")");
- GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1] << ", "
- << values[2] << ", " << values[3]);
+ size_t count = 4;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << values[ii]);
helper_->VertexAttrib4fvImmediate(indx, values);
CheckGLError();
}
@@ -2472,8 +2545,9 @@
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttribI4iv(" << indx
<< ", " << static_cast<const void*>(values) << ")");
- GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1] << ", "
- << values[2] << ", " << values[3]);
+ size_t count = 4;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << values[ii]);
helper_->VertexAttribI4ivImmediate(indx, values);
CheckGLError();
}
@@ -2495,8 +2569,9 @@
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttribI4uiv(" << indx
<< ", " << static_cast<const void*>(values) << ")");
- GPU_CLIENT_LOG("values: " << values[0] << ", " << values[1] << ", "
- << values[2] << ", " << values[3]);
+ size_t count = 4;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << values[ii]);
helper_->VertexAttribI4uivImmediate(indx, values);
CheckGLError();
}
@@ -3089,12 +3164,9 @@
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMatrixLoadfCHROMIUM("
<< GLES2Util::GetStringMatrixMode(matrixMode) << ", "
<< static_cast<const void*>(m) << ")");
- GPU_CLIENT_LOG("values: " << m[0] << ", " << m[1] << ", " << m[2] << ", "
- << m[3] << ", " << m[4] << ", " << m[5] << ", "
- << m[6] << ", " << m[7] << ", " << m[8] << ", "
- << m[9] << ", " << m[10] << ", " << m[11] << ", "
- << m[12] << ", " << m[13] << ", " << m[14] << ", "
- << m[15]);
+ size_t count = 16;
+ for (size_t ii = 0; ii < count; ++ii)
+ GPU_CLIENT_LOG("value[" << ii << "]: " << m[ii]);
helper_->MatrixLoadfCHROMIUMImmediate(matrixMode, m);
CheckGLError();
}
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest.cc b/gpu/command_buffer/client/gles2_implementation_unittest.cc
index 0d49e42..29e86df 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest.cc
+++ b/gpu/command_buffer/client/gles2_implementation_unittest.cc
@@ -2647,6 +2647,9 @@
&size, &unpadded_row_size, &padded_row_size));
// Makes sure we can just send over the data in one command.
const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size / kDepth;
+ ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+ kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
+ &size, NULL, NULL));
scoped_ptr<uint8[]> pixels(new uint8[size]);
for (uint32 ii = 0; ii < size; ++ii) {
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h b/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
index c398d61..a327aee 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
@@ -196,6 +196,65 @@
EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
}
+TEST_F(GLES2ImplementationTest, ClearBufferfi) {
+ struct Cmds {
+ cmds::ClearBufferfi cmd;
+ };
+ Cmds expected;
+ expected.cmd.Init(GL_COLOR, 2, 3, 4);
+
+ gl_->ClearBufferfi(GL_COLOR, 2, 3, 4);
+ EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
+
+TEST_F(GLES2ImplementationTest, ClearBufferfv) {
+ GLfloat data[4] = {0};
+ struct Cmds {
+ cmds::ClearBufferfvImmediate cmd;
+ GLfloat data[4];
+ };
+
+ for (int jj = 0; jj < 4; ++jj) {
+ data[jj] = static_cast<GLfloat>(jj);
+ }
+ Cmds expected;
+ expected.cmd.Init(GL_COLOR, 2, &data[0]);
+ gl_->ClearBufferfv(GL_COLOR, 2, &data[0]);
+ EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
+
+TEST_F(GLES2ImplementationTest, ClearBufferiv) {
+ GLint data[4] = {0};
+ struct Cmds {
+ cmds::ClearBufferivImmediate cmd;
+ GLint data[4];
+ };
+
+ for (int jj = 0; jj < 4; ++jj) {
+ data[jj] = static_cast<GLint>(jj);
+ }
+ Cmds expected;
+ expected.cmd.Init(GL_COLOR, 2, &data[0]);
+ gl_->ClearBufferiv(GL_COLOR, 2, &data[0]);
+ EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
+
+TEST_F(GLES2ImplementationTest, ClearBufferuiv) {
+ GLuint data[4] = {0};
+ struct Cmds {
+ cmds::ClearBufferuivImmediate cmd;
+ GLuint data[4];
+ };
+
+ for (int jj = 0; jj < 4; ++jj) {
+ data[jj] = static_cast<GLuint>(jj);
+ }
+ Cmds expected;
+ expected.cmd.Init(GL_COLOR, 2, &data[0]);
+ gl_->ClearBufferuiv(GL_COLOR, 2, &data[0]);
+ EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
+
TEST_F(GLES2ImplementationTest, ClearColor) {
struct Cmds {
cmds::ClearColor cmd;
diff --git a/gpu/command_buffer/client/gles2_interface_autogen.h b/gpu/command_buffer/client/gles2_interface_autogen.h
index 56f4e10..42262ce 100644
--- a/gpu/command_buffer/client/gles2_interface_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_autogen.h
@@ -51,6 +51,19 @@
const void* data) = 0;
virtual GLenum CheckFramebufferStatus(GLenum target) = 0;
virtual void Clear(GLbitfield mask) = 0;
+virtual void ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) = 0;
+virtual void ClearBufferfv(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) = 0;
+virtual void ClearBufferiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLint* value) = 0;
+virtual void ClearBufferuiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) = 0;
virtual void ClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
diff --git a/gpu/command_buffer/client/gles2_interface_stub_autogen.h b/gpu/command_buffer/client/gles2_interface_stub_autogen.h
index d2902c5..974bf39 100644
--- a/gpu/command_buffer/client/gles2_interface_stub_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_stub_autogen.h
@@ -50,6 +50,19 @@
const void* data) override;
GLenum CheckFramebufferStatus(GLenum target) override;
void Clear(GLbitfield mask) override;
+void ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) override;
+void ClearBufferfv(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) override;
+void ClearBufferiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLint* value) override;
+void ClearBufferuiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) override;
void ClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
diff --git a/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h b/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
index b53085f..ce953d7 100644
--- a/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
@@ -79,6 +79,23 @@
}
void GLES2InterfaceStub::Clear(GLbitfield /* mask */) {
}
+void GLES2InterfaceStub::ClearBufferfi(GLenum /* buffer */,
+ GLint /* drawbuffers */,
+ GLfloat /* depth */,
+ GLint /* stencil */) {
+}
+void GLES2InterfaceStub::ClearBufferfv(GLenum /* buffer */,
+ GLint /* drawbuffers */,
+ const GLfloat* /* value */) {
+}
+void GLES2InterfaceStub::ClearBufferiv(GLenum /* buffer */,
+ GLint /* drawbuffers */,
+ const GLint* /* value */) {
+}
+void GLES2InterfaceStub::ClearBufferuiv(GLenum /* buffer */,
+ GLint /* drawbuffers */,
+ const GLuint* /* value */) {
+}
void GLES2InterfaceStub::ClearColor(GLclampf /* red */,
GLclampf /* green */,
GLclampf /* blue */,
diff --git a/gpu/command_buffer/client/gles2_trace_implementation_autogen.h b/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
index 8d4d69c..1f8008b 100644
--- a/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
+++ b/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
@@ -50,6 +50,19 @@
const void* data) override;
GLenum CheckFramebufferStatus(GLenum target) override;
void Clear(GLbitfield mask) override;
+void ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) override;
+void ClearBufferfv(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) override;
+void ClearBufferiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLint* value) override;
+void ClearBufferuiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) override;
void ClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
diff --git a/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h b/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
index 8e05baa..ed5c148 100644
--- a/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
@@ -136,6 +136,35 @@
gl_->Clear(mask);
}
+void GLES2TraceImplementation::ClearBufferfi(GLenum buffer,
+ GLint drawbuffers,
+ GLfloat depth,
+ GLint stencil) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferfi");
+ gl_->ClearBufferfi(buffer, drawbuffers, depth, stencil);
+}
+
+void GLES2TraceImplementation::ClearBufferfv(GLenum buffer,
+ GLint drawbuffers,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferfv");
+ gl_->ClearBufferfv(buffer, drawbuffers, value);
+}
+
+void GLES2TraceImplementation::ClearBufferiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLint* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferiv");
+ gl_->ClearBufferiv(buffer, drawbuffers, value);
+}
+
+void GLES2TraceImplementation::ClearBufferuiv(GLenum buffer,
+ GLint drawbuffers,
+ const GLuint* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferuiv");
+ gl_->ClearBufferuiv(buffer, drawbuffers, value);
+}
+
void GLES2TraceImplementation::ClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
diff --git a/gpu/command_buffer/cmd_buffer_functions.txt b/gpu/command_buffer/cmd_buffer_functions.txt
index f82248c..71e99e1 100644
--- a/gpu/command_buffer/cmd_buffer_functions.txt
+++ b/gpu/command_buffer/cmd_buffer_functions.txt
@@ -24,6 +24,10 @@
GL_APICALL void GL_APIENTRY glBufferSubData (GLenumBufferTarget target, GLintptrNotNegative offset, GLsizeiptr size, const void* data);
GL_APICALL GLenum GL_APIENTRY glCheckFramebufferStatus (GLenumFrameBufferTarget target);
GL_APICALL void GL_APIENTRY glClear (GLbitfield mask);
+GL_APICALL void GL_APIENTRY glClearBufferfi (GLenumBufferfv buffer, GLint drawbuffers, GLfloat depth, GLint stencil);
+GL_APICALL void GL_APIENTRY glClearBufferfv (GLenumBufferfv buffer, GLint drawbuffers, const GLfloat* value);
+GL_APICALL void GL_APIENTRY glClearBufferiv (GLenumBufferiv buffer, GLint drawbuffers, const GLint* value);
+GL_APICALL void GL_APIENTRY glClearBufferuiv (GLenumBufferuiv buffer, GLint drawbuffers, const GLuint* value);
GL_APICALL void GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
GL_APICALL void GL_APIENTRY glClearDepthf (GLclampf depth);
GL_APICALL void GL_APIENTRY glClearStencil (GLint s);
diff --git a/gpu/command_buffer/common/gles2_cmd_format.h b/gpu/command_buffer/common/gles2_cmd_format.h
index 765eeac..b23cae3 100644
--- a/gpu/command_buffer/common/gles2_cmd_format.h
+++ b/gpu/command_buffer/common/gles2_cmd_format.h
@@ -19,6 +19,7 @@
#include "gpu/command_buffer/common/bitfield_helpers.h"
#include "gpu/command_buffer/common/cmd_buffer_common.h"
#include "gpu/command_buffer/common/gles2_cmd_ids.h"
+#include "gpu/command_buffer/common/gles2_cmd_utils.h"
// GL types are forward declared to avoid including the GL headers. The problem
// is determining which GL headers to include from code that is common to the
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index eb6bde3..eb35d4a 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -845,6 +845,216 @@
"offset of Clear header should be 0");
static_assert(offsetof(Clear, mask) == 4, "offset of Clear mask should be 4");
+struct ClearBufferfi {
+ typedef ClearBufferfi ValueType;
+ static const CommandId kCmdId = kClearBufferfi;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLenum _buffer,
+ GLint _drawbuffers,
+ GLfloat _depth,
+ GLint _stencil) {
+ SetHeader();
+ buffer = _buffer;
+ drawbuffers = _drawbuffers;
+ depth = _depth;
+ stencil = _stencil;
+ }
+
+ void* Set(void* cmd,
+ GLenum _buffer,
+ GLint _drawbuffers,
+ GLfloat _depth,
+ GLint _stencil) {
+ static_cast<ValueType*>(cmd)->Init(_buffer, _drawbuffers, _depth, _stencil);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t buffer;
+ int32_t drawbuffers;
+ float depth;
+ int32_t stencil;
+};
+
+static_assert(sizeof(ClearBufferfi) == 20,
+ "size of ClearBufferfi should be 20");
+static_assert(offsetof(ClearBufferfi, header) == 0,
+ "offset of ClearBufferfi header should be 0");
+static_assert(offsetof(ClearBufferfi, buffer) == 4,
+ "offset of ClearBufferfi buffer should be 4");
+static_assert(offsetof(ClearBufferfi, drawbuffers) == 8,
+ "offset of ClearBufferfi drawbuffers should be 8");
+static_assert(offsetof(ClearBufferfi, depth) == 12,
+ "offset of ClearBufferfi depth should be 12");
+static_assert(offsetof(ClearBufferfi, stencil) == 16,
+ "offset of ClearBufferfi stencil should be 16");
+
+struct ClearBufferfvImmediate {
+ typedef ClearBufferfvImmediate ValueType;
+ static const CommandId kCmdId = kClearBufferfvImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLfloat) * 4);
+ }
+
+ static uint32_t ComputeEffectiveDataSize(GLenum buffer) {
+ return static_cast<uint32_t>(sizeof(GLfloat) *
+ GLES2Util::CalcClearBufferfvDataCount(buffer));
+ }
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
+ }
+
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLenum _buffer, GLint _drawbuffers, const GLfloat* _value) {
+ SetHeader();
+ buffer = _buffer;
+ drawbuffers = _drawbuffers;
+ memcpy(ImmediateDataAddress(this), _value,
+ ComputeEffectiveDataSize(buffer));
+ DCHECK_GE(ComputeDataSize(), ComputeEffectiveDataSize(buffer));
+ char* pointer = reinterpret_cast<char*>(ImmediateDataAddress(this)) +
+ ComputeEffectiveDataSize(buffer);
+ memset(pointer, 0, ComputeDataSize() - ComputeEffectiveDataSize(buffer));
+ }
+
+ void* Set(void* cmd,
+ GLenum _buffer,
+ GLint _drawbuffers,
+ const GLfloat* _value) {
+ static_cast<ValueType*>(cmd)->Init(_buffer, _drawbuffers, _value);
+ const uint32_t size = ComputeSize();
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t buffer;
+ int32_t drawbuffers;
+};
+
+static_assert(sizeof(ClearBufferfvImmediate) == 12,
+ "size of ClearBufferfvImmediate should be 12");
+static_assert(offsetof(ClearBufferfvImmediate, header) == 0,
+ "offset of ClearBufferfvImmediate header should be 0");
+static_assert(offsetof(ClearBufferfvImmediate, buffer) == 4,
+ "offset of ClearBufferfvImmediate buffer should be 4");
+static_assert(offsetof(ClearBufferfvImmediate, drawbuffers) == 8,
+ "offset of ClearBufferfvImmediate drawbuffers should be 8");
+
+struct ClearBufferivImmediate {
+ typedef ClearBufferivImmediate ValueType;
+ static const CommandId kCmdId = kClearBufferivImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLint) * 4);
+ }
+
+ static uint32_t ComputeEffectiveDataSize(GLenum buffer) {
+ return static_cast<uint32_t>(sizeof(GLint) *
+ GLES2Util::CalcClearBufferivDataCount(buffer));
+ }
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
+ }
+
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLenum _buffer, GLint _drawbuffers, const GLint* _value) {
+ SetHeader();
+ buffer = _buffer;
+ drawbuffers = _drawbuffers;
+ memcpy(ImmediateDataAddress(this), _value,
+ ComputeEffectiveDataSize(buffer));
+ DCHECK_GE(ComputeDataSize(), ComputeEffectiveDataSize(buffer));
+ char* pointer = reinterpret_cast<char*>(ImmediateDataAddress(this)) +
+ ComputeEffectiveDataSize(buffer);
+ memset(pointer, 0, ComputeDataSize() - ComputeEffectiveDataSize(buffer));
+ }
+
+ void* Set(void* cmd,
+ GLenum _buffer,
+ GLint _drawbuffers,
+ const GLint* _value) {
+ static_cast<ValueType*>(cmd)->Init(_buffer, _drawbuffers, _value);
+ const uint32_t size = ComputeSize();
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t buffer;
+ int32_t drawbuffers;
+};
+
+static_assert(sizeof(ClearBufferivImmediate) == 12,
+ "size of ClearBufferivImmediate should be 12");
+static_assert(offsetof(ClearBufferivImmediate, header) == 0,
+ "offset of ClearBufferivImmediate header should be 0");
+static_assert(offsetof(ClearBufferivImmediate, buffer) == 4,
+ "offset of ClearBufferivImmediate buffer should be 4");
+static_assert(offsetof(ClearBufferivImmediate, drawbuffers) == 8,
+ "offset of ClearBufferivImmediate drawbuffers should be 8");
+
+struct ClearBufferuivImmediate {
+ typedef ClearBufferuivImmediate ValueType;
+ static const CommandId kCmdId = kClearBufferuivImmediate;
+ static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+ static uint32_t ComputeDataSize() {
+ return static_cast<uint32_t>(sizeof(GLuint) * 4);
+ }
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
+ }
+
+ void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+ void Init(GLenum _buffer, GLint _drawbuffers, const GLuint* _value) {
+ SetHeader();
+ buffer = _buffer;
+ drawbuffers = _drawbuffers;
+ memcpy(ImmediateDataAddress(this), _value, ComputeDataSize());
+ }
+
+ void* Set(void* cmd,
+ GLenum _buffer,
+ GLint _drawbuffers,
+ const GLuint* _value) {
+ static_cast<ValueType*>(cmd)->Init(_buffer, _drawbuffers, _value);
+ const uint32_t size = ComputeSize();
+ return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+ }
+
+ gpu::CommandHeader header;
+ uint32_t buffer;
+ int32_t drawbuffers;
+};
+
+static_assert(sizeof(ClearBufferuivImmediate) == 12,
+ "size of ClearBufferuivImmediate should be 12");
+static_assert(offsetof(ClearBufferuivImmediate, header) == 0,
+ "offset of ClearBufferuivImmediate header should be 0");
+static_assert(offsetof(ClearBufferuivImmediate, buffer) == 4,
+ "offset of ClearBufferuivImmediate buffer should be 4");
+static_assert(offsetof(ClearBufferuivImmediate, drawbuffers) == 8,
+ "offset of ClearBufferuivImmediate drawbuffers should be 8");
+
struct ClearColor {
typedef ClearColor ValueType;
static const CommandId kCmdId = kClearColor;
@@ -5509,12 +5719,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLfloat) * 1); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLfloat) * 1);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -5594,12 +5803,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLint) * 1); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLint) * 1);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -6246,12 +6454,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLfloat) * 1); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLfloat) * 1);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -6331,12 +6538,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLint) * 1); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLint) * 1);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -8231,12 +8437,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLfloat) * 1); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLfloat) * 1);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -8312,12 +8517,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLfloat) * 2); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLfloat) * 2);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -8397,12 +8601,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLfloat) * 3); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLfloat) * 3);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -8491,12 +8694,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLfloat) * 4); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLfloat) * 4);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -8580,12 +8782,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLint) * 4); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLint) * 4);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -8674,12 +8875,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLuint) * 4); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLuint) * 4);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -10370,12 +10570,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLbyte) * 64);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -10410,12 +10609,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLbyte) * 64);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -10460,12 +10658,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLbyte) * 64); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLbyte) * 64);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ -11570,12 +11767,11 @@
static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
static uint32_t ComputeDataSize() {
- return static_cast<uint32_t>(sizeof(GLfloat) * 16); // NOLINT
+ return static_cast<uint32_t>(sizeof(GLfloat) * 16);
}
static uint32_t ComputeSize() {
- return static_cast<uint32_t>(sizeof(ValueType) +
- ComputeDataSize()); // NOLINT
+ return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
}
void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
diff --git a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
index 12b9842..319ce6e 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -275,6 +275,90 @@
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
+TEST_F(GLES2FormatTest, ClearBufferfi) {
+ cmds::ClearBufferfi& cmd = *GetBufferAs<cmds::ClearBufferfi>();
+ void* next_cmd =
+ cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+ static_cast<GLfloat>(13), static_cast<GLint>(14));
+ EXPECT_EQ(static_cast<uint32_t>(cmds::ClearBufferfi::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+ EXPECT_EQ(static_cast<GLenum>(11), cmd.buffer);
+ EXPECT_EQ(static_cast<GLint>(12), cmd.drawbuffers);
+ EXPECT_EQ(static_cast<GLfloat>(13), cmd.depth);
+ EXPECT_EQ(static_cast<GLint>(14), cmd.stencil);
+ CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
+}
+
+TEST_F(GLES2FormatTest, ClearBufferfvImmediate) {
+ const int kSomeBaseValueToTestWith = 51;
+ static GLfloat data[] = {
+ static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
+ static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
+ static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
+ static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
+ };
+ cmds::ClearBufferfvImmediate& cmd =
+ *GetBufferAs<cmds::ClearBufferfvImmediate>();
+ void* next_cmd =
+ cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12), data);
+ EXPECT_EQ(static_cast<uint32_t>(cmds::ClearBufferfvImmediate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
+ cmd.header.size * 4u);
+ EXPECT_EQ(static_cast<GLenum>(11), cmd.buffer);
+ EXPECT_EQ(static_cast<GLint>(12), cmd.drawbuffers);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
+ // TODO(gman): Check that data was inserted;
+}
+
+TEST_F(GLES2FormatTest, ClearBufferivImmediate) {
+ const int kSomeBaseValueToTestWith = 51;
+ static GLint data[] = {
+ static_cast<GLint>(kSomeBaseValueToTestWith + 0),
+ static_cast<GLint>(kSomeBaseValueToTestWith + 1),
+ static_cast<GLint>(kSomeBaseValueToTestWith + 2),
+ static_cast<GLint>(kSomeBaseValueToTestWith + 3),
+ };
+ cmds::ClearBufferivImmediate& cmd =
+ *GetBufferAs<cmds::ClearBufferivImmediate>();
+ void* next_cmd =
+ cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12), data);
+ EXPECT_EQ(static_cast<uint32_t>(cmds::ClearBufferivImmediate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
+ cmd.header.size * 4u);
+ EXPECT_EQ(static_cast<GLenum>(11), cmd.buffer);
+ EXPECT_EQ(static_cast<GLint>(12), cmd.drawbuffers);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
+ // TODO(gman): Check that data was inserted;
+}
+
+TEST_F(GLES2FormatTest, ClearBufferuivImmediate) {
+ const int kSomeBaseValueToTestWith = 51;
+ static GLuint data[] = {
+ static_cast<GLuint>(kSomeBaseValueToTestWith + 0),
+ static_cast<GLuint>(kSomeBaseValueToTestWith + 1),
+ static_cast<GLuint>(kSomeBaseValueToTestWith + 2),
+ static_cast<GLuint>(kSomeBaseValueToTestWith + 3),
+ };
+ cmds::ClearBufferuivImmediate& cmd =
+ *GetBufferAs<cmds::ClearBufferuivImmediate>();
+ void* next_cmd =
+ cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12), data);
+ EXPECT_EQ(static_cast<uint32_t>(cmds::ClearBufferuivImmediate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
+ cmd.header.size * 4u);
+ EXPECT_EQ(static_cast<GLenum>(11), cmd.buffer);
+ EXPECT_EQ(static_cast<GLint>(12), cmd.drawbuffers);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
+ // TODO(gman): Check that data was inserted;
+}
+
TEST_F(GLES2FormatTest, ClearColor) {
cmds::ClearColor& cmd = *GetBufferAs<cmds::ClearColor>();
void* next_cmd =
diff --git a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
index c1dc521..b3ca924 100644
--- a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
@@ -32,240 +32,244 @@
OP(BufferSubData) /* 273 */ \
OP(CheckFramebufferStatus) /* 274 */ \
OP(Clear) /* 275 */ \
- OP(ClearColor) /* 276 */ \
- OP(ClearDepthf) /* 277 */ \
- OP(ClearStencil) /* 278 */ \
- OP(ColorMask) /* 279 */ \
- OP(CompileShader) /* 280 */ \
- OP(CompressedTexImage2DBucket) /* 281 */ \
- OP(CompressedTexImage2D) /* 282 */ \
- OP(CompressedTexSubImage2DBucket) /* 283 */ \
- OP(CompressedTexSubImage2D) /* 284 */ \
- OP(CopyBufferSubData) /* 285 */ \
- OP(CopyTexImage2D) /* 286 */ \
- OP(CopyTexSubImage2D) /* 287 */ \
- OP(CreateProgram) /* 288 */ \
- OP(CreateShader) /* 289 */ \
- OP(CullFace) /* 290 */ \
- OP(DeleteBuffersImmediate) /* 291 */ \
- OP(DeleteFramebuffersImmediate) /* 292 */ \
- OP(DeleteProgram) /* 293 */ \
- OP(DeleteRenderbuffersImmediate) /* 294 */ \
- OP(DeleteSamplersImmediate) /* 295 */ \
- OP(DeleteShader) /* 296 */ \
- OP(DeleteTexturesImmediate) /* 297 */ \
- OP(DeleteTransformFeedbacksImmediate) /* 298 */ \
- OP(DepthFunc) /* 299 */ \
- OP(DepthMask) /* 300 */ \
- OP(DepthRangef) /* 301 */ \
- OP(DetachShader) /* 302 */ \
- OP(Disable) /* 303 */ \
- OP(DisableVertexAttribArray) /* 304 */ \
- OP(DrawArrays) /* 305 */ \
- OP(DrawElements) /* 306 */ \
- OP(Enable) /* 307 */ \
- OP(EnableVertexAttribArray) /* 308 */ \
- OP(Finish) /* 309 */ \
- OP(Flush) /* 310 */ \
- OP(FramebufferRenderbuffer) /* 311 */ \
- OP(FramebufferTexture2D) /* 312 */ \
- OP(FramebufferTextureLayer) /* 313 */ \
- OP(FrontFace) /* 314 */ \
- OP(GenBuffersImmediate) /* 315 */ \
- OP(GenerateMipmap) /* 316 */ \
- OP(GenFramebuffersImmediate) /* 317 */ \
- OP(GenRenderbuffersImmediate) /* 318 */ \
- OP(GenSamplersImmediate) /* 319 */ \
- OP(GenTexturesImmediate) /* 320 */ \
- OP(GenTransformFeedbacksImmediate) /* 321 */ \
- OP(GetActiveAttrib) /* 322 */ \
- OP(GetActiveUniform) /* 323 */ \
- OP(GetAttachedShaders) /* 324 */ \
- OP(GetAttribLocation) /* 325 */ \
- OP(GetBooleanv) /* 326 */ \
- OP(GetBufferParameteriv) /* 327 */ \
- OP(GetError) /* 328 */ \
- OP(GetFloatv) /* 329 */ \
- OP(GetFramebufferAttachmentParameteriv) /* 330 */ \
- OP(GetIntegerv) /* 331 */ \
- OP(GetInternalformativ) /* 332 */ \
- OP(GetProgramiv) /* 333 */ \
- OP(GetProgramInfoLog) /* 334 */ \
- OP(GetRenderbufferParameteriv) /* 335 */ \
- OP(GetSamplerParameterfv) /* 336 */ \
- OP(GetSamplerParameteriv) /* 337 */ \
- OP(GetShaderiv) /* 338 */ \
- OP(GetShaderInfoLog) /* 339 */ \
- OP(GetShaderPrecisionFormat) /* 340 */ \
- OP(GetShaderSource) /* 341 */ \
- OP(GetString) /* 342 */ \
- OP(GetTexParameterfv) /* 343 */ \
- OP(GetTexParameteriv) /* 344 */ \
- OP(GetUniformfv) /* 345 */ \
- OP(GetUniformiv) /* 346 */ \
- OP(GetUniformLocation) /* 347 */ \
- OP(GetVertexAttribfv) /* 348 */ \
- OP(GetVertexAttribiv) /* 349 */ \
- OP(GetVertexAttribPointerv) /* 350 */ \
- OP(Hint) /* 351 */ \
- OP(InvalidateFramebufferImmediate) /* 352 */ \
- OP(InvalidateSubFramebufferImmediate) /* 353 */ \
- OP(IsBuffer) /* 354 */ \
- OP(IsEnabled) /* 355 */ \
- OP(IsFramebuffer) /* 356 */ \
- OP(IsProgram) /* 357 */ \
- OP(IsRenderbuffer) /* 358 */ \
- OP(IsSampler) /* 359 */ \
- OP(IsShader) /* 360 */ \
- OP(IsTexture) /* 361 */ \
- OP(IsTransformFeedback) /* 362 */ \
- OP(LineWidth) /* 363 */ \
- OP(LinkProgram) /* 364 */ \
- OP(PauseTransformFeedback) /* 365 */ \
- OP(PixelStorei) /* 366 */ \
- OP(PolygonOffset) /* 367 */ \
- OP(ReadBuffer) /* 368 */ \
- OP(ReadPixels) /* 369 */ \
- OP(ReleaseShaderCompiler) /* 370 */ \
- OP(RenderbufferStorage) /* 371 */ \
- OP(ResumeTransformFeedback) /* 372 */ \
- OP(SampleCoverage) /* 373 */ \
- OP(SamplerParameterf) /* 374 */ \
- OP(SamplerParameterfvImmediate) /* 375 */ \
- OP(SamplerParameteri) /* 376 */ \
- OP(SamplerParameterivImmediate) /* 377 */ \
- OP(Scissor) /* 378 */ \
- OP(ShaderBinary) /* 379 */ \
- OP(ShaderSourceBucket) /* 380 */ \
- OP(StencilFunc) /* 381 */ \
- OP(StencilFuncSeparate) /* 382 */ \
- OP(StencilMask) /* 383 */ \
- OP(StencilMaskSeparate) /* 384 */ \
- OP(StencilOp) /* 385 */ \
- OP(StencilOpSeparate) /* 386 */ \
- OP(TexImage2D) /* 387 */ \
- OP(TexImage3D) /* 388 */ \
- OP(TexParameterf) /* 389 */ \
- OP(TexParameterfvImmediate) /* 390 */ \
- OP(TexParameteri) /* 391 */ \
- OP(TexParameterivImmediate) /* 392 */ \
- OP(TexStorage3D) /* 393 */ \
- OP(TexSubImage2D) /* 394 */ \
- OP(TexSubImage3D) /* 395 */ \
- OP(Uniform1f) /* 396 */ \
- OP(Uniform1fvImmediate) /* 397 */ \
- OP(Uniform1i) /* 398 */ \
- OP(Uniform1ivImmediate) /* 399 */ \
- OP(Uniform1ui) /* 400 */ \
- OP(Uniform1uivImmediate) /* 401 */ \
- OP(Uniform2f) /* 402 */ \
- OP(Uniform2fvImmediate) /* 403 */ \
- OP(Uniform2i) /* 404 */ \
- OP(Uniform2ivImmediate) /* 405 */ \
- OP(Uniform2ui) /* 406 */ \
- OP(Uniform2uivImmediate) /* 407 */ \
- OP(Uniform3f) /* 408 */ \
- OP(Uniform3fvImmediate) /* 409 */ \
- OP(Uniform3i) /* 410 */ \
- OP(Uniform3ivImmediate) /* 411 */ \
- OP(Uniform3ui) /* 412 */ \
- OP(Uniform3uivImmediate) /* 413 */ \
- OP(Uniform4f) /* 414 */ \
- OP(Uniform4fvImmediate) /* 415 */ \
- OP(Uniform4i) /* 416 */ \
- OP(Uniform4ivImmediate) /* 417 */ \
- OP(Uniform4ui) /* 418 */ \
- OP(Uniform4uivImmediate) /* 419 */ \
- OP(UniformMatrix2fvImmediate) /* 420 */ \
- OP(UniformMatrix2x3fvImmediate) /* 421 */ \
- OP(UniformMatrix2x4fvImmediate) /* 422 */ \
- OP(UniformMatrix3fvImmediate) /* 423 */ \
- OP(UniformMatrix3x2fvImmediate) /* 424 */ \
- OP(UniformMatrix3x4fvImmediate) /* 425 */ \
- OP(UniformMatrix4fvImmediate) /* 426 */ \
- OP(UniformMatrix4x2fvImmediate) /* 427 */ \
- OP(UniformMatrix4x3fvImmediate) /* 428 */ \
- OP(UseProgram) /* 429 */ \
- OP(ValidateProgram) /* 430 */ \
- OP(VertexAttrib1f) /* 431 */ \
- OP(VertexAttrib1fvImmediate) /* 432 */ \
- OP(VertexAttrib2f) /* 433 */ \
- OP(VertexAttrib2fvImmediate) /* 434 */ \
- OP(VertexAttrib3f) /* 435 */ \
- OP(VertexAttrib3fvImmediate) /* 436 */ \
- OP(VertexAttrib4f) /* 437 */ \
- OP(VertexAttrib4fvImmediate) /* 438 */ \
- OP(VertexAttribI4i) /* 439 */ \
- OP(VertexAttribI4ivImmediate) /* 440 */ \
- OP(VertexAttribI4ui) /* 441 */ \
- OP(VertexAttribI4uivImmediate) /* 442 */ \
- OP(VertexAttribIPointer) /* 443 */ \
- OP(VertexAttribPointer) /* 444 */ \
- OP(Viewport) /* 445 */ \
- OP(BlitFramebufferCHROMIUM) /* 446 */ \
- OP(RenderbufferStorageMultisampleCHROMIUM) /* 447 */ \
- OP(RenderbufferStorageMultisampleEXT) /* 448 */ \
- OP(FramebufferTexture2DMultisampleEXT) /* 449 */ \
- OP(TexStorage2DEXT) /* 450 */ \
- OP(GenQueriesEXTImmediate) /* 451 */ \
- OP(DeleteQueriesEXTImmediate) /* 452 */ \
- OP(BeginQueryEXT) /* 453 */ \
- OP(BeginTransformFeedback) /* 454 */ \
- OP(EndQueryEXT) /* 455 */ \
- OP(EndTransformFeedback) /* 456 */ \
- OP(InsertEventMarkerEXT) /* 457 */ \
- OP(PushGroupMarkerEXT) /* 458 */ \
- OP(PopGroupMarkerEXT) /* 459 */ \
- OP(GenVertexArraysOESImmediate) /* 460 */ \
- OP(DeleteVertexArraysOESImmediate) /* 461 */ \
- OP(IsVertexArrayOES) /* 462 */ \
- OP(BindVertexArrayOES) /* 463 */ \
- OP(SwapBuffers) /* 464 */ \
- OP(GetMaxValueInBufferCHROMIUM) /* 465 */ \
- OP(EnableFeatureCHROMIUM) /* 466 */ \
- OP(ResizeCHROMIUM) /* 467 */ \
- OP(GetRequestableExtensionsCHROMIUM) /* 468 */ \
- OP(RequestExtensionCHROMIUM) /* 469 */ \
- OP(GetProgramInfoCHROMIUM) /* 470 */ \
- OP(GetTranslatedShaderSourceANGLE) /* 471 */ \
- OP(PostSubBufferCHROMIUM) /* 472 */ \
- OP(TexImageIOSurface2DCHROMIUM) /* 473 */ \
- OP(CopyTextureCHROMIUM) /* 474 */ \
- OP(DrawArraysInstancedANGLE) /* 475 */ \
- OP(DrawElementsInstancedANGLE) /* 476 */ \
- OP(VertexAttribDivisorANGLE) /* 477 */ \
- OP(GenMailboxCHROMIUM) /* 478 */ \
- OP(ProduceTextureCHROMIUMImmediate) /* 479 */ \
- OP(ProduceTextureDirectCHROMIUMImmediate) /* 480 */ \
- OP(ConsumeTextureCHROMIUMImmediate) /* 481 */ \
- OP(CreateAndConsumeTextureCHROMIUMImmediate) /* 482 */ \
- OP(BindUniformLocationCHROMIUMBucket) /* 483 */ \
- OP(GenValuebuffersCHROMIUMImmediate) /* 484 */ \
- OP(DeleteValuebuffersCHROMIUMImmediate) /* 485 */ \
- OP(IsValuebufferCHROMIUM) /* 486 */ \
- OP(BindValuebufferCHROMIUM) /* 487 */ \
- OP(SubscribeValueCHROMIUM) /* 488 */ \
- OP(PopulateSubscribedValuesCHROMIUM) /* 489 */ \
- OP(UniformValuebufferCHROMIUM) /* 490 */ \
- OP(BindTexImage2DCHROMIUM) /* 491 */ \
- OP(ReleaseTexImage2DCHROMIUM) /* 492 */ \
- OP(TraceBeginCHROMIUM) /* 493 */ \
- OP(TraceEndCHROMIUM) /* 494 */ \
- OP(AsyncTexSubImage2DCHROMIUM) /* 495 */ \
- OP(AsyncTexImage2DCHROMIUM) /* 496 */ \
- OP(WaitAsyncTexImage2DCHROMIUM) /* 497 */ \
- OP(WaitAllAsyncTexImage2DCHROMIUM) /* 498 */ \
- OP(DiscardFramebufferEXTImmediate) /* 499 */ \
- OP(LoseContextCHROMIUM) /* 500 */ \
- OP(InsertSyncPointCHROMIUM) /* 501 */ \
- OP(WaitSyncPointCHROMIUM) /* 502 */ \
- OP(DrawBuffersEXTImmediate) /* 503 */ \
- OP(DiscardBackbufferCHROMIUM) /* 504 */ \
- OP(ScheduleOverlayPlaneCHROMIUM) /* 505 */ \
- OP(SwapInterval) /* 506 */ \
- OP(MatrixLoadfCHROMIUMImmediate) /* 507 */ \
- OP(MatrixLoadIdentityCHROMIUM) /* 508 */ \
- OP(BlendBarrierKHR) /* 509 */
+ OP(ClearBufferfi) /* 276 */ \
+ OP(ClearBufferfvImmediate) /* 277 */ \
+ OP(ClearBufferivImmediate) /* 278 */ \
+ OP(ClearBufferuivImmediate) /* 279 */ \
+ OP(ClearColor) /* 280 */ \
+ OP(ClearDepthf) /* 281 */ \
+ OP(ClearStencil) /* 282 */ \
+ OP(ColorMask) /* 283 */ \
+ OP(CompileShader) /* 284 */ \
+ OP(CompressedTexImage2DBucket) /* 285 */ \
+ OP(CompressedTexImage2D) /* 286 */ \
+ OP(CompressedTexSubImage2DBucket) /* 287 */ \
+ OP(CompressedTexSubImage2D) /* 288 */ \
+ OP(CopyBufferSubData) /* 289 */ \
+ OP(CopyTexImage2D) /* 290 */ \
+ OP(CopyTexSubImage2D) /* 291 */ \
+ OP(CreateProgram) /* 292 */ \
+ OP(CreateShader) /* 293 */ \
+ OP(CullFace) /* 294 */ \
+ OP(DeleteBuffersImmediate) /* 295 */ \
+ OP(DeleteFramebuffersImmediate) /* 296 */ \
+ OP(DeleteProgram) /* 297 */ \
+ OP(DeleteRenderbuffersImmediate) /* 298 */ \
+ OP(DeleteSamplersImmediate) /* 299 */ \
+ OP(DeleteShader) /* 300 */ \
+ OP(DeleteTexturesImmediate) /* 301 */ \
+ OP(DeleteTransformFeedbacksImmediate) /* 302 */ \
+ OP(DepthFunc) /* 303 */ \
+ OP(DepthMask) /* 304 */ \
+ OP(DepthRangef) /* 305 */ \
+ OP(DetachShader) /* 306 */ \
+ OP(Disable) /* 307 */ \
+ OP(DisableVertexAttribArray) /* 308 */ \
+ OP(DrawArrays) /* 309 */ \
+ OP(DrawElements) /* 310 */ \
+ OP(Enable) /* 311 */ \
+ OP(EnableVertexAttribArray) /* 312 */ \
+ OP(Finish) /* 313 */ \
+ OP(Flush) /* 314 */ \
+ OP(FramebufferRenderbuffer) /* 315 */ \
+ OP(FramebufferTexture2D) /* 316 */ \
+ OP(FramebufferTextureLayer) /* 317 */ \
+ OP(FrontFace) /* 318 */ \
+ OP(GenBuffersImmediate) /* 319 */ \
+ OP(GenerateMipmap) /* 320 */ \
+ OP(GenFramebuffersImmediate) /* 321 */ \
+ OP(GenRenderbuffersImmediate) /* 322 */ \
+ OP(GenSamplersImmediate) /* 323 */ \
+ OP(GenTexturesImmediate) /* 324 */ \
+ OP(GenTransformFeedbacksImmediate) /* 325 */ \
+ OP(GetActiveAttrib) /* 326 */ \
+ OP(GetActiveUniform) /* 327 */ \
+ OP(GetAttachedShaders) /* 328 */ \
+ OP(GetAttribLocation) /* 329 */ \
+ OP(GetBooleanv) /* 330 */ \
+ OP(GetBufferParameteriv) /* 331 */ \
+ OP(GetError) /* 332 */ \
+ OP(GetFloatv) /* 333 */ \
+ OP(GetFramebufferAttachmentParameteriv) /* 334 */ \
+ OP(GetIntegerv) /* 335 */ \
+ OP(GetInternalformativ) /* 336 */ \
+ OP(GetProgramiv) /* 337 */ \
+ OP(GetProgramInfoLog) /* 338 */ \
+ OP(GetRenderbufferParameteriv) /* 339 */ \
+ OP(GetSamplerParameterfv) /* 340 */ \
+ OP(GetSamplerParameteriv) /* 341 */ \
+ OP(GetShaderiv) /* 342 */ \
+ OP(GetShaderInfoLog) /* 343 */ \
+ OP(GetShaderPrecisionFormat) /* 344 */ \
+ OP(GetShaderSource) /* 345 */ \
+ OP(GetString) /* 346 */ \
+ OP(GetTexParameterfv) /* 347 */ \
+ OP(GetTexParameteriv) /* 348 */ \
+ OP(GetUniformfv) /* 349 */ \
+ OP(GetUniformiv) /* 350 */ \
+ OP(GetUniformLocation) /* 351 */ \
+ OP(GetVertexAttribfv) /* 352 */ \
+ OP(GetVertexAttribiv) /* 353 */ \
+ OP(GetVertexAttribPointerv) /* 354 */ \
+ OP(Hint) /* 355 */ \
+ OP(InvalidateFramebufferImmediate) /* 356 */ \
+ OP(InvalidateSubFramebufferImmediate) /* 357 */ \
+ OP(IsBuffer) /* 358 */ \
+ OP(IsEnabled) /* 359 */ \
+ OP(IsFramebuffer) /* 360 */ \
+ OP(IsProgram) /* 361 */ \
+ OP(IsRenderbuffer) /* 362 */ \
+ OP(IsSampler) /* 363 */ \
+ OP(IsShader) /* 364 */ \
+ OP(IsTexture) /* 365 */ \
+ OP(IsTransformFeedback) /* 366 */ \
+ OP(LineWidth) /* 367 */ \
+ OP(LinkProgram) /* 368 */ \
+ OP(PauseTransformFeedback) /* 369 */ \
+ OP(PixelStorei) /* 370 */ \
+ OP(PolygonOffset) /* 371 */ \
+ OP(ReadBuffer) /* 372 */ \
+ OP(ReadPixels) /* 373 */ \
+ OP(ReleaseShaderCompiler) /* 374 */ \
+ OP(RenderbufferStorage) /* 375 */ \
+ OP(ResumeTransformFeedback) /* 376 */ \
+ OP(SampleCoverage) /* 377 */ \
+ OP(SamplerParameterf) /* 378 */ \
+ OP(SamplerParameterfvImmediate) /* 379 */ \
+ OP(SamplerParameteri) /* 380 */ \
+ OP(SamplerParameterivImmediate) /* 381 */ \
+ OP(Scissor) /* 382 */ \
+ OP(ShaderBinary) /* 383 */ \
+ OP(ShaderSourceBucket) /* 384 */ \
+ OP(StencilFunc) /* 385 */ \
+ OP(StencilFuncSeparate) /* 386 */ \
+ OP(StencilMask) /* 387 */ \
+ OP(StencilMaskSeparate) /* 388 */ \
+ OP(StencilOp) /* 389 */ \
+ OP(StencilOpSeparate) /* 390 */ \
+ OP(TexImage2D) /* 391 */ \
+ OP(TexImage3D) /* 392 */ \
+ OP(TexParameterf) /* 393 */ \
+ OP(TexParameterfvImmediate) /* 394 */ \
+ OP(TexParameteri) /* 395 */ \
+ OP(TexParameterivImmediate) /* 396 */ \
+ OP(TexStorage3D) /* 397 */ \
+ OP(TexSubImage2D) /* 398 */ \
+ OP(TexSubImage3D) /* 399 */ \
+ OP(Uniform1f) /* 400 */ \
+ OP(Uniform1fvImmediate) /* 401 */ \
+ OP(Uniform1i) /* 402 */ \
+ OP(Uniform1ivImmediate) /* 403 */ \
+ OP(Uniform1ui) /* 404 */ \
+ OP(Uniform1uivImmediate) /* 405 */ \
+ OP(Uniform2f) /* 406 */ \
+ OP(Uniform2fvImmediate) /* 407 */ \
+ OP(Uniform2i) /* 408 */ \
+ OP(Uniform2ivImmediate) /* 409 */ \
+ OP(Uniform2ui) /* 410 */ \
+ OP(Uniform2uivImmediate) /* 411 */ \
+ OP(Uniform3f) /* 412 */ \
+ OP(Uniform3fvImmediate) /* 413 */ \
+ OP(Uniform3i) /* 414 */ \
+ OP(Uniform3ivImmediate) /* 415 */ \
+ OP(Uniform3ui) /* 416 */ \
+ OP(Uniform3uivImmediate) /* 417 */ \
+ OP(Uniform4f) /* 418 */ \
+ OP(Uniform4fvImmediate) /* 419 */ \
+ OP(Uniform4i) /* 420 */ \
+ OP(Uniform4ivImmediate) /* 421 */ \
+ OP(Uniform4ui) /* 422 */ \
+ OP(Uniform4uivImmediate) /* 423 */ \
+ OP(UniformMatrix2fvImmediate) /* 424 */ \
+ OP(UniformMatrix2x3fvImmediate) /* 425 */ \
+ OP(UniformMatrix2x4fvImmediate) /* 426 */ \
+ OP(UniformMatrix3fvImmediate) /* 427 */ \
+ OP(UniformMatrix3x2fvImmediate) /* 428 */ \
+ OP(UniformMatrix3x4fvImmediate) /* 429 */ \
+ OP(UniformMatrix4fvImmediate) /* 430 */ \
+ OP(UniformMatrix4x2fvImmediate) /* 431 */ \
+ OP(UniformMatrix4x3fvImmediate) /* 432 */ \
+ OP(UseProgram) /* 433 */ \
+ OP(ValidateProgram) /* 434 */ \
+ OP(VertexAttrib1f) /* 435 */ \
+ OP(VertexAttrib1fvImmediate) /* 436 */ \
+ OP(VertexAttrib2f) /* 437 */ \
+ OP(VertexAttrib2fvImmediate) /* 438 */ \
+ OP(VertexAttrib3f) /* 439 */ \
+ OP(VertexAttrib3fvImmediate) /* 440 */ \
+ OP(VertexAttrib4f) /* 441 */ \
+ OP(VertexAttrib4fvImmediate) /* 442 */ \
+ OP(VertexAttribI4i) /* 443 */ \
+ OP(VertexAttribI4ivImmediate) /* 444 */ \
+ OP(VertexAttribI4ui) /* 445 */ \
+ OP(VertexAttribI4uivImmediate) /* 446 */ \
+ OP(VertexAttribIPointer) /* 447 */ \
+ OP(VertexAttribPointer) /* 448 */ \
+ OP(Viewport) /* 449 */ \
+ OP(BlitFramebufferCHROMIUM) /* 450 */ \
+ OP(RenderbufferStorageMultisampleCHROMIUM) /* 451 */ \
+ OP(RenderbufferStorageMultisampleEXT) /* 452 */ \
+ OP(FramebufferTexture2DMultisampleEXT) /* 453 */ \
+ OP(TexStorage2DEXT) /* 454 */ \
+ OP(GenQueriesEXTImmediate) /* 455 */ \
+ OP(DeleteQueriesEXTImmediate) /* 456 */ \
+ OP(BeginQueryEXT) /* 457 */ \
+ OP(BeginTransformFeedback) /* 458 */ \
+ OP(EndQueryEXT) /* 459 */ \
+ OP(EndTransformFeedback) /* 460 */ \
+ OP(InsertEventMarkerEXT) /* 461 */ \
+ OP(PushGroupMarkerEXT) /* 462 */ \
+ OP(PopGroupMarkerEXT) /* 463 */ \
+ OP(GenVertexArraysOESImmediate) /* 464 */ \
+ OP(DeleteVertexArraysOESImmediate) /* 465 */ \
+ OP(IsVertexArrayOES) /* 466 */ \
+ OP(BindVertexArrayOES) /* 467 */ \
+ OP(SwapBuffers) /* 468 */ \
+ OP(GetMaxValueInBufferCHROMIUM) /* 469 */ \
+ OP(EnableFeatureCHROMIUM) /* 470 */ \
+ OP(ResizeCHROMIUM) /* 471 */ \
+ OP(GetRequestableExtensionsCHROMIUM) /* 472 */ \
+ OP(RequestExtensionCHROMIUM) /* 473 */ \
+ OP(GetProgramInfoCHROMIUM) /* 474 */ \
+ OP(GetTranslatedShaderSourceANGLE) /* 475 */ \
+ OP(PostSubBufferCHROMIUM) /* 476 */ \
+ OP(TexImageIOSurface2DCHROMIUM) /* 477 */ \
+ OP(CopyTextureCHROMIUM) /* 478 */ \
+ OP(DrawArraysInstancedANGLE) /* 479 */ \
+ OP(DrawElementsInstancedANGLE) /* 480 */ \
+ OP(VertexAttribDivisorANGLE) /* 481 */ \
+ OP(GenMailboxCHROMIUM) /* 482 */ \
+ OP(ProduceTextureCHROMIUMImmediate) /* 483 */ \
+ OP(ProduceTextureDirectCHROMIUMImmediate) /* 484 */ \
+ OP(ConsumeTextureCHROMIUMImmediate) /* 485 */ \
+ OP(CreateAndConsumeTextureCHROMIUMImmediate) /* 486 */ \
+ OP(BindUniformLocationCHROMIUMBucket) /* 487 */ \
+ OP(GenValuebuffersCHROMIUMImmediate) /* 488 */ \
+ OP(DeleteValuebuffersCHROMIUMImmediate) /* 489 */ \
+ OP(IsValuebufferCHROMIUM) /* 490 */ \
+ OP(BindValuebufferCHROMIUM) /* 491 */ \
+ OP(SubscribeValueCHROMIUM) /* 492 */ \
+ OP(PopulateSubscribedValuesCHROMIUM) /* 493 */ \
+ OP(UniformValuebufferCHROMIUM) /* 494 */ \
+ OP(BindTexImage2DCHROMIUM) /* 495 */ \
+ OP(ReleaseTexImage2DCHROMIUM) /* 496 */ \
+ OP(TraceBeginCHROMIUM) /* 497 */ \
+ OP(TraceEndCHROMIUM) /* 498 */ \
+ OP(AsyncTexSubImage2DCHROMIUM) /* 499 */ \
+ OP(AsyncTexImage2DCHROMIUM) /* 500 */ \
+ OP(WaitAsyncTexImage2DCHROMIUM) /* 501 */ \
+ OP(WaitAllAsyncTexImage2DCHROMIUM) /* 502 */ \
+ OP(DiscardFramebufferEXTImmediate) /* 503 */ \
+ OP(LoseContextCHROMIUM) /* 504 */ \
+ OP(InsertSyncPointCHROMIUM) /* 505 */ \
+ OP(WaitSyncPointCHROMIUM) /* 506 */ \
+ OP(DrawBuffersEXTImmediate) /* 507 */ \
+ OP(DiscardBackbufferCHROMIUM) /* 508 */ \
+ OP(ScheduleOverlayPlaneCHROMIUM) /* 509 */ \
+ OP(SwapInterval) /* 510 */ \
+ OP(MatrixLoadfCHROMIUMImmediate) /* 511 */ \
+ OP(MatrixLoadIdentityCHROMIUM) /* 512 */ \
+ OP(BlendBarrierKHR) /* 513 */
enum CommandId {
kStartPoint = cmd::kLastCommonId, // All GLES2 commands start after this.
diff --git a/gpu/command_buffer/common/gles2_cmd_utils.cc b/gpu/command_buffer/common/gles2_cmd_utils.cc
index 1d31f70..6a483f6 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils.cc
+++ b/gpu/command_buffer/common/gles2_cmd_utils.cc
@@ -822,6 +822,28 @@
return true;
}
+size_t GLES2Util::CalcClearBufferivDataCount(int buffer) {
+ switch (buffer) {
+ case GL_COLOR:
+ return 4;
+ case GL_STENCIL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+size_t GLES2Util::CalcClearBufferfvDataCount(int buffer) {
+ switch (buffer) {
+ case GL_COLOR:
+ return 4;
+ case GL_DEPTH:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
namespace {
// WebGraphicsContext3DCommandBufferImpl configuration attributes. Those in
diff --git a/gpu/command_buffer/common/gles2_cmd_utils.h b/gpu/command_buffer/common/gles2_cmd_utils.h
index 414e140..127c2be 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils.h
@@ -184,6 +184,9 @@
int* element_index,
bool* getting_array);
+ static size_t CalcClearBufferivDataCount(int buffer);
+ static size_t CalcClearBufferfvDataCount(int buffer);
+
#include "../common/gles2_cmd_utils_autogen.h"
private:
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
index e6a26fe..8820225 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
@@ -17,6 +17,10 @@
static std::string GetStringBufferParameter(uint32_t value);
static std::string GetStringBufferTarget(uint32_t value);
static std::string GetStringBufferUsage(uint32_t value);
+static std::string GetStringBufferfi(uint32_t value);
+static std::string GetStringBufferfv(uint32_t value);
+static std::string GetStringBufferiv(uint32_t value);
+static std::string GetStringBufferuiv(uint32_t value);
static std::string GetStringCapability(uint32_t value);
static std::string GetStringCmpFunction(uint32_t value);
static std::string GetStringCompressedTextureFormat(uint32_t value);
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
index 3fafbcb..b28c5e5 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
@@ -4502,6 +4502,38 @@
arraysize(string_table), value);
}
+std::string GLES2Util::GetStringBufferfi(uint32_t value) {
+ static const EnumToString string_table[] = {
+ {GL_DEPTH_STENCIL, "GL_DEPTH_STENCIL"},
+ };
+ return GLES2Util::GetQualifiedEnumString(string_table,
+ arraysize(string_table), value);
+}
+
+std::string GLES2Util::GetStringBufferfv(uint32_t value) {
+ static const EnumToString string_table[] = {
+ {GL_COLOR, "GL_COLOR"}, {GL_DEPTH, "GL_DEPTH"},
+ };
+ return GLES2Util::GetQualifiedEnumString(string_table,
+ arraysize(string_table), value);
+}
+
+std::string GLES2Util::GetStringBufferiv(uint32_t value) {
+ static const EnumToString string_table[] = {
+ {GL_COLOR, "GL_COLOR"}, {GL_STENCIL, "GL_STENCIL"},
+ };
+ return GLES2Util::GetQualifiedEnumString(string_table,
+ arraysize(string_table), value);
+}
+
+std::string GLES2Util::GetStringBufferuiv(uint32_t value) {
+ static const EnumToString string_table[] = {
+ {GL_COLOR, "GL_COLOR"},
+ };
+ return GLES2Util::GetQualifiedEnumString(string_table,
+ arraysize(string_table), value);
+}
+
std::string GLES2Util::GetStringCapability(uint32_t value) {
static const EnumToString string_table[] = {
{GL_BLEND, "GL_BLEND"},
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_android.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_android.cc
index eadc34f..5b86b87 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_android.cc
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_android.cc
@@ -4,12 +4,14 @@
#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
+#include "base/command_line.h"
#include "base/debug/trace_event.h"
#include "base/sys_info.h"
#include "gpu/command_buffer/service/async_pixel_transfer_manager_egl.h"
#include "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
#include "gpu/command_buffer/service/async_pixel_transfer_manager_stub.h"
#include "gpu/command_buffer/service/async_pixel_transfer_manager_sync.h"
+#include "gpu/command_buffer/service/gpu_switches.h"
#include "ui/gl/gl_context.h"
#include "ui/gl/gl_implementation.h"
@@ -75,6 +77,13 @@
AsyncPixelTransferManager* AsyncPixelTransferManager::Create(
gfx::GLContext* context) {
DCHECK(context->IsCurrent(NULL));
+ // Threaded mailbox uses EGLImage which conflicts with EGL uploader.
+ // The spec only allows one EGL image per sibling group, but currently the
+ // image handle cannot be shared between the threaded mailbox code and
+ // AsyncPixelTransferManagerEGL.
+ bool uses_threaded_mailboxes =
+ base::CommandLine::ForCurrentProcess()->HasSwitch(
+ switches::kEnableThreadedTextureMailboxes);
switch (gfx::GetGLImplementation()) {
case gfx::kGLImplementationEGLGLES2:
DCHECK(context);
@@ -84,6 +93,7 @@
context->HasExtension("EGL_KHR_image_base") &&
context->HasExtension("EGL_KHR_gl_texture_2D_image") &&
context->HasExtension("GL_OES_EGL_image") &&
+ !uses_threaded_mailboxes &&
AllowTransferThreadForGpu()) {
TRACE_EVENT0("gpu", "AsyncPixelTransferManager_CreateWithThread");
return new AsyncPixelTransferManagerEGL;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index efd75dd..f56d47b 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -6427,12 +6427,17 @@
glBindTexture(
textarget,
texture_manager()->black_texture_id(uniform_info->type));
- LOCAL_RENDER_WARNING(
- std::string("texture bound to texture unit ") +
- base::IntToString(texture_unit_index) +
- " is not renderable. It maybe non-power-of-2 and have"
- " incompatible texture filtering or is not"
- " 'texture complete'");
+ if (!texture_ref) {
+ LOCAL_RENDER_WARNING(
+ std::string("there is no texture bound to the unit ") +
+ base::IntToString(texture_unit_index));
+ } else {
+ LOCAL_RENDER_WARNING(
+ std::string("texture bound to texture unit ") +
+ base::IntToString(texture_unit_index) +
+ " is not renderable. It maybe non-power-of-2 and have"
+ " incompatible texture filtering.");
+ }
continue;
}
@@ -9140,10 +9145,17 @@
Clip(x, width, size.width(), ©X, ©Width);
Clip(y, height, size.height(), ©Y, ©Height);
- if (!texture_manager()->ClearTextureLevel(this, texture_ref, target, level)) {
- LOCAL_SET_GL_ERROR(
- GL_OUT_OF_MEMORY, "glCopyTexSubImage2D", "dimensions too big");
- return;
+ if (xoffset != 0 || yoffset != 0 || width != size.width() ||
+ height != size.height()) {
+ if (!texture_manager()->ClearTextureLevel(this, texture_ref, target,
+ level)) {
+ LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D",
+ "dimensions too big");
+ return;
+ }
+ } else {
+ // Write all pixels in below.
+ texture_manager()->SetLevelCleared(texture_ref, target, level, true);
}
if (copyX != x ||
@@ -9748,6 +9760,9 @@
TRACE_EVENT_SYNTHETIC_DELAY("gpu.PresentingFrame");
}
+ ScopedGPUTrace scoped_gpu_trace(gpu_tracer_.get(), kTraceDecoder,
+ "gpu_toplevel", "SwapBuffer");
+
bool is_tracing;
TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
&is_tracing);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index 6764910..7766b0d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -384,6 +384,99 @@
return error::kNoError;
}
+error::Error GLES2DecoderImpl::HandleClearBufferfi(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ if (!unsafe_es3_apis_enabled())
+ return error::kUnknownCommand;
+ const gles2::cmds::ClearBufferfi& c =
+ *static_cast<const gles2::cmds::ClearBufferfi*>(cmd_data);
+ (void)c;
+ GLenum buffer = static_cast<GLenum>(c.buffer);
+ GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
+ GLfloat depth = static_cast<GLfloat>(c.depth);
+ GLint stencil = static_cast<GLint>(c.stencil);
+ glClearBufferfi(buffer, drawbuffers, depth, stencil);
+ return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleClearBufferfvImmediate(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ if (!unsafe_es3_apis_enabled())
+ return error::kUnknownCommand;
+ const gles2::cmds::ClearBufferfvImmediate& c =
+ *static_cast<const gles2::cmds::ClearBufferfvImmediate*>(cmd_data);
+ (void)c;
+ GLenum buffer = static_cast<GLenum>(c.buffer);
+ GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
+ uint32_t data_size;
+ if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
+ return error::kOutOfBounds;
+ }
+ if (data_size > immediate_data_size) {
+ return error::kOutOfBounds;
+ }
+ const GLfloat* value =
+ GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
+ if (value == NULL) {
+ return error::kOutOfBounds;
+ }
+ glClearBufferfv(buffer, drawbuffers, value);
+ return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleClearBufferivImmediate(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ if (!unsafe_es3_apis_enabled())
+ return error::kUnknownCommand;
+ const gles2::cmds::ClearBufferivImmediate& c =
+ *static_cast<const gles2::cmds::ClearBufferivImmediate*>(cmd_data);
+ (void)c;
+ GLenum buffer = static_cast<GLenum>(c.buffer);
+ GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
+ uint32_t data_size;
+ if (!ComputeDataSize(1, sizeof(GLint), 4, &data_size)) {
+ return error::kOutOfBounds;
+ }
+ if (data_size > immediate_data_size) {
+ return error::kOutOfBounds;
+ }
+ const GLint* value =
+ GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
+ if (value == NULL) {
+ return error::kOutOfBounds;
+ }
+ glClearBufferiv(buffer, drawbuffers, value);
+ return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleClearBufferuivImmediate(
+ uint32_t immediate_data_size,
+ const void* cmd_data) {
+ if (!unsafe_es3_apis_enabled())
+ return error::kUnknownCommand;
+ const gles2::cmds::ClearBufferuivImmediate& c =
+ *static_cast<const gles2::cmds::ClearBufferuivImmediate*>(cmd_data);
+ (void)c;
+ GLenum buffer = static_cast<GLenum>(c.buffer);
+ GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
+ uint32_t data_size;
+ if (!ComputeDataSize(1, sizeof(GLuint), 4, &data_size)) {
+ return error::kOutOfBounds;
+ }
+ if (data_size > immediate_data_size) {
+ return error::kOutOfBounds;
+ }
+ const GLuint* value =
+ GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
+ if (value == NULL) {
+ return error::kOutOfBounds;
+ }
+ glClearBufferuiv(buffer, drawbuffers, value);
+ return error::kNoError;
+}
+
error::Error GLES2DecoderImpl::HandleClearColor(uint32_t immediate_data_size,
const void* cmd_data) {
const gles2::cmds::ClearColor& c =
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
index d1208f8..7794274 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
@@ -394,6 +394,72 @@
EXPECT_EQ(GL_NO_ERROR, GetGLError());
}
+TEST_P(GLES2DecoderTest1, ClearBufferfiValidArgs) {
+ EXPECT_CALL(*gl_, ClearBufferfi(GL_COLOR, 2, 3, 4));
+ SpecializedSetup<cmds::ClearBufferfi, 0>(true);
+ cmds::ClearBufferfi cmd;
+ cmd.Init(GL_COLOR, 2, 3, 4);
+ decoder_->set_unsafe_es3_apis_enabled(true);
+ EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+ EXPECT_EQ(GL_NO_ERROR, GetGLError());
+ decoder_->set_unsafe_es3_apis_enabled(false);
+ EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+}
+
+TEST_P(GLES2DecoderTest1, ClearBufferfvImmediateValidArgs) {
+ cmds::ClearBufferfvImmediate& cmd =
+ *GetImmediateAs<cmds::ClearBufferfvImmediate>();
+ SpecializedSetup<cmds::ClearBufferfvImmediate, 0>(true);
+ GLfloat temp[4] = {
+ 0,
+ };
+ cmd.Init(GL_COLOR, 2, &temp[0]);
+ EXPECT_CALL(*gl_,
+ ClearBufferfv(GL_COLOR, 2, reinterpret_cast<GLfloat*>(
+ ImmediateDataAddress(&cmd))));
+ decoder_->set_unsafe_es3_apis_enabled(true);
+ EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
+ EXPECT_EQ(GL_NO_ERROR, GetGLError());
+ decoder_->set_unsafe_es3_apis_enabled(false);
+ EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
+}
+
+TEST_P(GLES2DecoderTest1, ClearBufferivImmediateValidArgs) {
+ cmds::ClearBufferivImmediate& cmd =
+ *GetImmediateAs<cmds::ClearBufferivImmediate>();
+ SpecializedSetup<cmds::ClearBufferivImmediate, 0>(true);
+ GLint temp[4] = {
+ 0,
+ };
+ cmd.Init(GL_COLOR, 2, &temp[0]);
+ EXPECT_CALL(*gl_, ClearBufferiv(
+ GL_COLOR, 2,
+ reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
+ decoder_->set_unsafe_es3_apis_enabled(true);
+ EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
+ EXPECT_EQ(GL_NO_ERROR, GetGLError());
+ decoder_->set_unsafe_es3_apis_enabled(false);
+ EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
+}
+
+TEST_P(GLES2DecoderTest1, ClearBufferuivImmediateValidArgs) {
+ cmds::ClearBufferuivImmediate& cmd =
+ *GetImmediateAs<cmds::ClearBufferuivImmediate>();
+ SpecializedSetup<cmds::ClearBufferuivImmediate, 0>(true);
+ GLuint temp[4] = {
+ 0,
+ };
+ cmd.Init(GL_COLOR, 2, &temp[0]);
+ EXPECT_CALL(*gl_, ClearBufferuiv(
+ GL_COLOR, 2,
+ reinterpret_cast<GLuint*>(ImmediateDataAddress(&cmd))));
+ decoder_->set_unsafe_es3_apis_enabled(true);
+ EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
+ EXPECT_EQ(GL_NO_ERROR, GetGLError());
+ decoder_->set_unsafe_es3_apis_enabled(false);
+ EXPECT_EQ(error::kUnknownCommand, ExecuteImmediateCmd(cmd, sizeof(temp)));
+}
+
TEST_P(GLES2DecoderTest1, ClearColorValidArgs) {
EXPECT_CALL(*gl_, ClearColor(1, 2, 3, 4));
SpecializedSetup<cmds::ClearColor, 0>(true);
@@ -1930,25 +1996,4 @@
EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
EXPECT_EQ(0u, result->size);
}
-// TODO(gman): GetVertexAttribPointerv
-
-TEST_P(GLES2DecoderTest1, HintValidArgs) {
- EXPECT_CALL(*gl_, Hint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST));
- SpecializedSetup<cmds::Hint, 0>(true);
- cmds::Hint cmd;
- cmd.Init(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);
- EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
- EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest1, HintInvalidArgs0_0) {
- EXPECT_CALL(*gl_, Hint(_, _)).Times(0);
- SpecializedSetup<cmds::Hint, 0>(false);
- cmds::Hint cmd;
- cmd.Init(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
- EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
- EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-// TODO(gman): InvalidateFramebufferImmediate
-// TODO(gman): InvalidateSubFramebufferImmediate
#endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_1_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
index 2e8f532..aa387be 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
@@ -12,6 +12,28 @@
#ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
+// TODO(gman): GetVertexAttribPointerv
+
+TEST_P(GLES2DecoderTest2, HintValidArgs) {
+ EXPECT_CALL(*gl_, Hint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST));
+ SpecializedSetup<cmds::Hint, 0>(true);
+ cmds::Hint cmd;
+ cmd.Init(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);
+ EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+ EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+
+TEST_P(GLES2DecoderTest2, HintInvalidArgs0_0) {
+ EXPECT_CALL(*gl_, Hint(_, _)).Times(0);
+ SpecializedSetup<cmds::Hint, 0>(false);
+ cmds::Hint cmd;
+ cmd.Init(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+ EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+ EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
+}
+// TODO(gman): InvalidateFramebufferImmediate
+// TODO(gman): InvalidateSubFramebufferImmediate
+
TEST_P(GLES2DecoderTest2, IsBufferValidArgs) {
SpecializedSetup<cmds::IsBuffer, 0>(true);
cmds::IsBuffer cmd;
@@ -1326,6 +1348,4 @@
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
}
-// TODO(gman): TexStorage2DEXT
-// TODO(gman): GenQueriesEXTImmediate
#endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
index 314a9b6..ba2f4c2 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
@@ -12,6 +12,8 @@
#ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
+// TODO(gman): TexStorage2DEXT
+// TODO(gman): GenQueriesEXTImmediate
// TODO(gman): DeleteQueriesEXTImmediate
// TODO(gman): BeginQueryEXT
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
index b0e8e8c..f0cadf1 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
@@ -1803,6 +1803,32 @@
CopyTexSubImage2D cmd;
cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+
+ TextureManager* manager = group().texture_manager();
+ TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
+ ASSERT_TRUE(texture_ref != NULL);
+ Texture* texture = texture_ref->texture();
+ EXPECT_TRUE(texture->SafeToRenderFrom());
+}
+
+TEST_P(GLES2DecoderTest, CopyTexSubImage2DClearsUnclearedBackBufferSizedTexture) {
+ DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
+ DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kBackBufferWidth, kBackBufferHeight,
+ 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
+
+ EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0,
+ kBackBufferWidth, kBackBufferHeight))
+ .Times(1)
+ .RetiresOnSaturation();
+ CopyTexSubImage2D cmd;
+ cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, kBackBufferWidth, kBackBufferHeight);
+ EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+
+ TextureManager* manager = group().texture_manager();
+ TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
+ ASSERT_TRUE(texture_ref != NULL);
+ Texture* texture = texture_ref->texture();
+ EXPECT_TRUE(texture->SafeToRenderFrom());
}
TEST_P(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
index 5692847..e163642 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
@@ -17,6 +17,10 @@
ValueValidator<GLenum> buffer_parameter;
ValueValidator<GLenum> buffer_target;
ValueValidator<GLenum> buffer_usage;
+ValueValidator<GLenum> bufferfi;
+ValueValidator<GLenum> bufferfv;
+ValueValidator<GLenum> bufferiv;
+ValueValidator<GLenum> bufferuiv;
ValueValidator<GLenum> capability;
ValueValidator<GLenum> cmp_function;
ValueValidator<GLenum> compressed_texture_format;
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
index d81b896..febce20 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
@@ -44,6 +44,24 @@
GL_DYNAMIC_DRAW,
};
+static const GLenum valid_bufferfi_table[] = {
+ GL_DEPTH_STENCIL,
+};
+
+static const GLenum valid_bufferfv_table[] = {
+ GL_COLOR,
+ GL_DEPTH,
+};
+
+static const GLenum valid_bufferiv_table[] = {
+ GL_COLOR,
+ GL_STENCIL,
+};
+
+static const GLenum valid_bufferuiv_table[] = {
+ GL_COLOR,
+};
+
static const GLenum valid_capability_table[] = {
GL_BLEND,
GL_CULL_FACE,
@@ -573,6 +591,10 @@
arraysize(valid_buffer_target_table)),
buffer_usage(valid_buffer_usage_table,
arraysize(valid_buffer_usage_table)),
+ bufferfi(valid_bufferfi_table, arraysize(valid_bufferfi_table)),
+ bufferfv(valid_bufferfv_table, arraysize(valid_bufferfv_table)),
+ bufferiv(valid_bufferiv_table, arraysize(valid_bufferiv_table)),
+ bufferuiv(valid_bufferuiv_table, arraysize(valid_bufferuiv_table)),
capability(valid_capability_table, arraysize(valid_capability_table)),
cmp_function(valid_cmp_function_table,
arraysize(valid_cmp_function_table)),
diff --git a/gpu/command_buffer/service/gpu_tracer.cc b/gpu/command_buffer/service/gpu_tracer.cc
index 2853e96c..364159b 100644
--- a/gpu/command_buffer/service/gpu_tracer.cc
+++ b/gpu/command_buffer/service/gpu_tracer.cc
@@ -76,19 +76,15 @@
}
void TraceOutputter::TraceServiceBegin(const std::string& category,
- const std::string& name,
- void* id) {
- TRACE_EVENT_COPY_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("gpu.service"),
- name.c_str(), this,
- "gl_category", category.c_str());
+ const std::string& name) {
+ TRACE_EVENT_COPY_BEGIN1(TRACE_DISABLED_BY_DEFAULT("gpu.service"),
+ name.c_str(), "gl_category", category.c_str());
}
void TraceOutputter::TraceServiceEnd(const std::string& category,
- const std::string& name,
- void* id) {
- TRACE_EVENT_COPY_ASYNC_END1(TRACE_DISABLED_BY_DEFAULT("gpu.service"),
- name.c_str(), this,
- "gl_category", category.c_str());
+ const std::string& name) {
+ TRACE_EVENT_COPY_END1(TRACE_DISABLED_BY_DEFAULT("gpu.service"),
+ name.c_str(), "gl_category", category.c_str());
}
GPUTrace::GPUTrace(scoped_refptr<Outputter> outputter,
@@ -132,7 +128,7 @@
void GPUTrace::Start(bool trace_service) {
if (trace_service) {
- outputter_->TraceServiceBegin(category_, name_, this);
+ outputter_->TraceServiceBegin(category_, name_);
}
switch (tracer_type_) {
@@ -174,7 +170,7 @@
}
if (tracing_service) {
- outputter_->TraceServiceEnd(category_, name_, this);
+ outputter_->TraceServiceEnd(category_, name_);
}
}
diff --git a/gpu/command_buffer/service/gpu_tracer.h b/gpu/command_buffer/service/gpu_tracer.h
index 64f13cc..594a98e 100644
--- a/gpu/command_buffer/service/gpu_tracer.h
+++ b/gpu/command_buffer/service/gpu_tracer.h
@@ -134,12 +134,10 @@
int64 end_time) = 0;
virtual void TraceServiceBegin(const std::string& category,
- const std::string& name,
- void* id) = 0;
+ const std::string& name) = 0;
virtual void TraceServiceEnd(const std::string& category,
- const std::string& name,
- void* id) = 0;
+ const std::string& name) = 0;
protected:
virtual ~Outputter() {}
@@ -155,12 +153,10 @@
int64 end_time) override;
void TraceServiceBegin(const std::string& category,
- const std::string& name,
- void* id) override;
+ const std::string& name) override;
void TraceServiceEnd(const std::string& category,
- const std::string& name,
- void* id) override;
+ const std::string& name) override;
protected:
friend class base::RefCounted<Outputter>;
@@ -213,6 +209,24 @@
DISALLOW_COPY_AND_ASSIGN(GPUTrace);
};
+class ScopedGPUTrace {
+ public:
+ ScopedGPUTrace(GPUTracer* gpu_tracer, GpuTracerSource source,
+ const std::string& category, const std::string& name)
+ : gpu_tracer_(gpu_tracer),
+ source_(source) {
+ gpu_tracer_->Begin(category, name, source_);
+ }
+
+ ~ScopedGPUTrace() {
+ gpu_tracer_->End(source_);
+ }
+
+ private:
+ GPUTracer* gpu_tracer_;
+ GpuTracerSource source_;
+};
+
} // namespace gles2
} // namespace gpu
diff --git a/gpu/command_buffer/service/gpu_tracer_unittest.cc b/gpu/command_buffer/service/gpu_tracer_unittest.cc
index ae4c970..1b55e78 100644
--- a/gpu/command_buffer/service/gpu_tracer_unittest.cc
+++ b/gpu/command_buffer/service/gpu_tracer_unittest.cc
@@ -50,13 +50,11 @@
void(const std::string& category, const std::string& name,
int64 start_time, int64 end_time));
- MOCK_METHOD3(TraceServiceBegin,
- void(const std::string& category, const std::string& name,
- void* id));
+ MOCK_METHOD2(TraceServiceBegin,
+ void(const std::string& category, const std::string& name));
- MOCK_METHOD3(TraceServiceEnd,
- void(const std::string& category, const std::string& name,
- void* id));
+ MOCK_METHOD2(TraceServiceEnd,
+ void(const std::string& category, const std::string& name));
protected:
~MockOutputter() {}
@@ -287,7 +285,7 @@
const std::string& category,
const std::string& name) {
EXPECT_CALL(*outputter,
- TraceServiceBegin(category, name, NotNull()));
+ TraceServiceBegin(category, name));
}
void ExpectOutputterEndMocks(MockOutputter* outputter,
@@ -296,7 +294,7 @@
int64 expect_end_time,
bool trace_device) {
EXPECT_CALL(*outputter,
- TraceServiceEnd(category, name, NotNull()));
+ TraceServiceEnd(category, name));
if (trace_device) {
EXPECT_CALL(*outputter,
diff --git a/gpu/command_buffer/service/in_process_command_buffer.cc b/gpu/command_buffer/service/in_process_command_buffer.cc
index c312345..c671073 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.cc
+++ b/gpu/command_buffer/service/in_process_command_buffer.cc
@@ -437,7 +437,11 @@
return false;
}
- if (service_->UseVirtualizedGLContexts()) {
+ if (service_->UseVirtualizedGLContexts() ||
+ decoder_->GetContextGroup()
+ ->feature_info()
+ ->workarounds()
+ .use_virtualized_gl_contexts) {
context_ = gl_share_group_->GetSharedContext();
if (!context_.get()) {
context_ = gfx::GLContext::CreateGLContext(
diff --git a/gpu/command_buffer/service/mailbox_manager_sync.cc b/gpu/command_buffer/service/mailbox_manager_sync.cc
index 65376af..b12e9b4 100644
--- a/gpu/command_buffer/service/mailbox_manager_sync.cc
+++ b/gpu/command_buffer/service/mailbox_manager_sync.cc
@@ -31,11 +31,6 @@
if (texture->target() != GL_TEXTURE_2D || needs_mips || !texture->IsDefined())
return true;
- // Skip compositor resources/tile textures.
- // TODO: Remove this, see crbug.com/399226.
- if (texture->pool() == GL_TEXTURE_POOL_MANAGED_CHROMIUM)
- return true;
-
return false;
}
