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 #include "gpu/command_buffer/service/program_manager.h" | 5 #include "gpu/command_buffer/service/program_manager.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/memory/scoped_ptr.h" | 9 #include "base/memory/scoped_ptr.h" |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
(...skipping 18 matching lines...) Expand all Loading... |
29 using ::testing::ReturnRef; | 29 using ::testing::ReturnRef; |
30 using ::testing::SetArrayArgument; | 30 using ::testing::SetArrayArgument; |
31 using ::testing::SetArgumentPointee; | 31 using ::testing::SetArgumentPointee; |
32 using ::testing::StrEq; | 32 using ::testing::StrEq; |
33 using ::testing::StrictMock; | 33 using ::testing::StrictMock; |
34 | 34 |
35 namespace gpu { | 35 namespace gpu { |
36 namespace gles2 { | 36 namespace gles2 { |
37 | 37 |
38 namespace { | 38 namespace { |
| 39 const uint32 kMaxVaryingVectors = 8; |
| 40 |
39 void ShaderCacheCb(const std::string& key, const std::string& shader) {} | 41 void ShaderCacheCb(const std::string& key, const std::string& shader) {} |
40 } // namespace | 42 } // namespace anonymous |
41 | 43 |
42 class ProgramManagerTest : public testing::Test { | 44 class ProgramManagerTest : public testing::Test { |
43 public: | 45 public: |
44 ProgramManagerTest() : manager_(NULL) { } | 46 ProgramManagerTest() : manager_(NULL, kMaxVaryingVectors) { } |
45 virtual ~ProgramManagerTest() { | 47 virtual ~ProgramManagerTest() { |
46 manager_.Destroy(false); | 48 manager_.Destroy(false); |
47 } | 49 } |
48 | 50 |
49 protected: | 51 protected: |
50 virtual void SetUp() { | 52 virtual void SetUp() { |
51 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); | 53 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); |
52 ::gfx::GLInterface::SetGLInterface(gl_.get()); | 54 ::gfx::GLInterface::SetGLInterface(gl_.get()); |
53 } | 55 } |
54 | 56 |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
132 EXPECT_FALSE(program1->InUse()); | 134 EXPECT_FALSE(program1->InUse()); |
133 EXPECT_FALSE(program1->IsValid()); | 135 EXPECT_FALSE(program1->IsValid()); |
134 EXPECT_FALSE(program1->IsDeleted()); | 136 EXPECT_FALSE(program1->IsDeleted()); |
135 EXPECT_FALSE(program1->CanLink()); | 137 EXPECT_FALSE(program1->CanLink()); |
136 EXPECT_TRUE(program1->log_info() == NULL); | 138 EXPECT_TRUE(program1->log_info() == NULL); |
137 } | 139 } |
138 | 140 |
139 class ProgramManagerWithShaderTest : public testing::Test { | 141 class ProgramManagerWithShaderTest : public testing::Test { |
140 public: | 142 public: |
141 ProgramManagerWithShaderTest() | 143 ProgramManagerWithShaderTest() |
142 : manager_(NULL), program_(NULL) { | 144 : manager_(NULL, kMaxVaryingVectors), program_(NULL) { |
143 } | 145 } |
144 | 146 |
145 virtual ~ProgramManagerWithShaderTest() { | 147 virtual ~ProgramManagerWithShaderTest() { |
146 manager_.Destroy(false); | 148 manager_.Destroy(false); |
147 shader_manager_.Destroy(false); | 149 shader_manager_.Destroy(false); |
148 } | 150 } |
149 | 151 |
150 static const GLint kNumVertexAttribs = 16; | 152 static const GLint kNumVertexAttribs = 16; |
151 | 153 |
152 static const GLuint kClientProgramId = 123; | 154 static const GLuint kClientProgramId = 123; |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
202 static const GLenum kUniform3Type = GL_FLOAT_VEC3; | 204 static const GLenum kUniform3Type = GL_FLOAT_VEC3; |
203 static const GLint kInvalidUniformLocation = 30; | 205 static const GLint kInvalidUniformLocation = 30; |
204 static const GLint kBadUniformIndex = 1000; | 206 static const GLint kBadUniformIndex = 1000; |
205 | 207 |
206 static const size_t kNumAttribs; | 208 static const size_t kNumAttribs; |
207 static const size_t kNumUniforms; | 209 static const size_t kNumUniforms; |
208 | 210 |
209 protected: | 211 protected: |
210 typedef TestHelper::AttribInfo AttribInfo; | 212 typedef TestHelper::AttribInfo AttribInfo; |
211 typedef TestHelper::UniformInfo UniformInfo; | 213 typedef TestHelper::UniformInfo UniformInfo; |
| 214 typedef struct { |
| 215 int type; |
| 216 int size; |
| 217 int precision; |
| 218 int static_use; |
| 219 std::string name; |
| 220 } VarInfo; |
212 | 221 |
213 virtual void SetUp() { | 222 virtual void SetUp() { |
214 gl_.reset(new StrictMock<gfx::MockGLInterface>()); | 223 gl_.reset(new StrictMock<gfx::MockGLInterface>()); |
215 ::gfx::GLInterface::SetGLInterface(gl_.get()); | 224 ::gfx::GLInterface::SetGLInterface(gl_.get()); |
216 | 225 |
217 SetupDefaultShaderExpectations(); | 226 SetupDefaultShaderExpectations(); |
218 | 227 |
219 Shader* vertex_shader = shader_manager_.CreateShader( | 228 Shader* vertex_shader = shader_manager_.CreateShader( |
220 kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER); | 229 kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER); |
221 Shader* fragment_shader = | 230 Shader* fragment_shader = |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
265 if (expected_link_status) { | 274 if (expected_link_status) { |
266 SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms, | 275 SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms, |
267 service_id); | 276 service_id); |
268 } | 277 } |
269 program->Link(NULL, NULL, NULL, NULL, base::Bind(&ShaderCacheCb)); | 278 program->Link(NULL, NULL, NULL, NULL, base::Bind(&ShaderCacheCb)); |
270 GLint link_status; | 279 GLint link_status; |
271 program->GetProgramiv(GL_LINK_STATUS, &link_status); | 280 program->GetProgramiv(GL_LINK_STATUS, &link_status); |
272 return (static_cast<bool>(link_status) == expected_link_status); | 281 return (static_cast<bool>(link_status) == expected_link_status); |
273 } | 282 } |
274 | 283 |
275 Program* SetupVaryingsMatchingTest(bool vertex_varying_declare, | 284 Program* SetupVaryingsTest(const VarInfo* vertex_varyings, |
276 int vertex_varying_type, | 285 size_t vertex_varying_size, |
277 int vertex_varying_size, | 286 const VarInfo* fragment_varyings, |
278 int vertex_varying_precision, | 287 size_t fragment_varying_size) { |
279 int vertex_varying_static_use, | |
280 bool frag_varying_declare, | |
281 int frag_varying_type, | |
282 int frag_varying_size, | |
283 int frag_varying_precision, | |
284 int frag_varying_static_use) { | |
285 // Set up shader | 288 // Set up shader |
286 const GLuint kVShaderClientId = 1; | 289 const GLuint kVShaderClientId = 1; |
287 const GLuint kVShaderServiceId = 11; | 290 const GLuint kVShaderServiceId = 11; |
288 const GLuint kFShaderClientId = 2; | 291 const GLuint kFShaderClientId = 2; |
289 const GLuint kFShaderServiceId = 12; | 292 const GLuint kFShaderServiceId = 12; |
290 | 293 |
291 MockShaderTranslator vertex_shader_translator; | 294 MockShaderTranslator vertex_shader_translator; |
292 ShaderTranslator::VariableMap vertex_attrib_map; | 295 ShaderTranslator::VariableMap vertex_attrib_map; |
293 ShaderTranslator::VariableMap vertex_uniform_map; | 296 ShaderTranslator::VariableMap vertex_uniform_map; |
294 ShaderTranslator::VariableMap vertex_varying_map; | 297 ShaderTranslator::VariableMap vertex_varying_map; |
295 if (vertex_varying_declare) { | 298 for (size_t ii = 0; ii < vertex_varying_size; ++ii) { |
296 vertex_varying_map["a"] = ShaderTranslator::VariableInfo( | 299 vertex_varying_map[vertex_varyings[ii].name] = |
297 vertex_varying_type, vertex_varying_size, | 300 ShaderTranslator::VariableInfo(vertex_varyings[ii].type, |
298 vertex_varying_precision, vertex_varying_static_use, "a"); | 301 vertex_varyings[ii].size, |
| 302 vertex_varyings[ii].precision, |
| 303 vertex_varyings[ii].static_use, |
| 304 vertex_varyings[ii].name); |
299 } | 305 } |
300 ShaderTranslator::NameMap vertex_name_map; | 306 ShaderTranslator::NameMap vertex_name_map; |
301 EXPECT_CALL(vertex_shader_translator, attrib_map()) | 307 EXPECT_CALL(vertex_shader_translator, attrib_map()) |
302 .WillRepeatedly(ReturnRef(vertex_attrib_map)); | 308 .WillRepeatedly(ReturnRef(vertex_attrib_map)); |
303 EXPECT_CALL(vertex_shader_translator, uniform_map()) | 309 EXPECT_CALL(vertex_shader_translator, uniform_map()) |
304 .WillRepeatedly(ReturnRef(vertex_uniform_map)); | 310 .WillRepeatedly(ReturnRef(vertex_uniform_map)); |
305 EXPECT_CALL(vertex_shader_translator, varying_map()) | 311 EXPECT_CALL(vertex_shader_translator, varying_map()) |
306 .WillRepeatedly(ReturnRef(vertex_varying_map)); | 312 .WillRepeatedly(ReturnRef(vertex_varying_map)); |
307 EXPECT_CALL(vertex_shader_translator, name_map()) | 313 EXPECT_CALL(vertex_shader_translator, name_map()) |
308 .WillRepeatedly(ReturnRef(vertex_name_map)); | 314 .WillRepeatedly(ReturnRef(vertex_name_map)); |
309 | 315 |
310 MockShaderTranslator frag_shader_translator; | 316 MockShaderTranslator frag_shader_translator; |
311 ShaderTranslator::VariableMap frag_attrib_map; | 317 ShaderTranslator::VariableMap frag_attrib_map; |
312 ShaderTranslator::VariableMap frag_uniform_map; | 318 ShaderTranslator::VariableMap frag_uniform_map; |
313 ShaderTranslator::VariableMap frag_varying_map; | 319 ShaderTranslator::VariableMap frag_varying_map; |
314 if (frag_varying_declare) { | 320 for (size_t ii = 0; ii < fragment_varying_size; ++ii) { |
315 frag_varying_map["a"] = ShaderTranslator::VariableInfo( | 321 frag_varying_map[fragment_varyings[ii].name] = |
316 frag_varying_type, frag_varying_size, | 322 ShaderTranslator::VariableInfo(fragment_varyings[ii].type, |
317 frag_varying_precision, frag_varying_static_use, "a"); | 323 fragment_varyings[ii].size, |
| 324 fragment_varyings[ii].precision, |
| 325 fragment_varyings[ii].static_use, |
| 326 fragment_varyings[ii].name); |
318 } | 327 } |
319 ShaderTranslator::NameMap frag_name_map; | 328 ShaderTranslator::NameMap frag_name_map; |
320 EXPECT_CALL(frag_shader_translator, attrib_map()) | 329 EXPECT_CALL(frag_shader_translator, attrib_map()) |
321 .WillRepeatedly(ReturnRef(frag_attrib_map)); | 330 .WillRepeatedly(ReturnRef(frag_attrib_map)); |
322 EXPECT_CALL(frag_shader_translator, uniform_map()) | 331 EXPECT_CALL(frag_shader_translator, uniform_map()) |
323 .WillRepeatedly(ReturnRef(frag_uniform_map)); | 332 .WillRepeatedly(ReturnRef(frag_uniform_map)); |
324 EXPECT_CALL(frag_shader_translator, varying_map()) | 333 EXPECT_CALL(frag_shader_translator, varying_map()) |
325 .WillRepeatedly(ReturnRef(frag_varying_map)); | 334 .WillRepeatedly(ReturnRef(frag_varying_map)); |
326 EXPECT_CALL(frag_shader_translator, name_map()) | 335 EXPECT_CALL(frag_shader_translator, name_map()) |
327 .WillRepeatedly(ReturnRef(frag_name_map)); | 336 .WillRepeatedly(ReturnRef(frag_name_map)); |
(...skipping 832 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1160 EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader)); | 1169 EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader)); |
1161 EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader)); | 1170 EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader)); |
1162 | 1171 |
1163 EXPECT_TRUE(program->DetectUniformsMismatch()); | 1172 EXPECT_TRUE(program->DetectUniformsMismatch()); |
1164 EXPECT_TRUE(LinkAsExpected(program, false)); | 1173 EXPECT_TRUE(LinkAsExpected(program, false)); |
1165 } | 1174 } |
1166 | 1175 |
1167 // If a varying has different type in the vertex and fragment | 1176 // If a varying has different type in the vertex and fragment |
1168 // shader, linking should fail. | 1177 // shader, linking should fail. |
1169 TEST_F(ProgramManagerWithShaderTest, VaryingTypeMismatch) { | 1178 TEST_F(ProgramManagerWithShaderTest, VaryingTypeMismatch) { |
1170 Program* program = SetupVaryingsMatchingTest( | 1179 const VarInfo kVertexVarying = |
1171 true, SH_FLOAT_VEC3, 1, SH_PRECISION_MEDIUMP, 1, | 1180 { SH_FLOAT_VEC3, 1, SH_PRECISION_MEDIUMP, 1, "a" }; |
1172 true, SH_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1); | 1181 const VarInfo kFragmentVarying = |
| 1182 { SH_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a" }; |
| 1183 Program* program = SetupVaryingsTest( |
| 1184 &kVertexVarying, 1, &kFragmentVarying, 1); |
1173 | 1185 |
1174 EXPECT_TRUE(program->DetectVaryingsMismatch()); | 1186 EXPECT_TRUE(program->DetectVaryingsMismatch()); |
1175 EXPECT_TRUE(LinkAsExpected(program, false)); | 1187 EXPECT_TRUE(LinkAsExpected(program, false)); |
1176 } | 1188 } |
1177 | 1189 |
1178 // If a varying has different array size in the vertex and fragment | 1190 // If a varying has different array size in the vertex and fragment |
1179 // shader, linking should fail. | 1191 // shader, linking should fail. |
1180 TEST_F(ProgramManagerWithShaderTest, VaryingArraySizeMismatch) { | 1192 TEST_F(ProgramManagerWithShaderTest, VaryingArraySizeMismatch) { |
1181 Program* program = SetupVaryingsMatchingTest( | 1193 const VarInfo kVertexVarying = |
1182 true, SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, | 1194 { SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a" }; |
1183 true, SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1); | 1195 const VarInfo kFragmentVarying = |
| 1196 { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a" }; |
| 1197 Program* program = SetupVaryingsTest( |
| 1198 &kVertexVarying, 1, &kFragmentVarying, 1); |
1184 | 1199 |
1185 EXPECT_TRUE(program->DetectVaryingsMismatch()); | 1200 EXPECT_TRUE(program->DetectVaryingsMismatch()); |
1186 EXPECT_TRUE(LinkAsExpected(program, false)); | 1201 EXPECT_TRUE(LinkAsExpected(program, false)); |
1187 } | 1202 } |
1188 | 1203 |
1189 // If a varying has different precision in the vertex and fragment | 1204 // If a varying has different precision in the vertex and fragment |
1190 // shader, linking should succeed. | 1205 // shader, linking should succeed. |
1191 TEST_F(ProgramManagerWithShaderTest, VaryingPrecisionMismatch) { | 1206 TEST_F(ProgramManagerWithShaderTest, VaryingPrecisionMismatch) { |
1192 Program* program = SetupVaryingsMatchingTest( | 1207 const VarInfo kVertexVarying = |
1193 true, SH_FLOAT, 2, SH_PRECISION_HIGHP, 1, | 1208 { SH_FLOAT, 2, SH_PRECISION_HIGHP, 1, "a" }; |
1194 true, SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1); | 1209 const VarInfo kFragmentVarying = |
| 1210 { SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a" }; |
| 1211 Program* program = SetupVaryingsTest( |
| 1212 &kVertexVarying, 1, &kFragmentVarying, 1); |
1195 | 1213 |
1196 EXPECT_FALSE(program->DetectVaryingsMismatch()); | 1214 EXPECT_FALSE(program->DetectVaryingsMismatch()); |
1197 EXPECT_TRUE(LinkAsExpected(program, true)); | 1215 EXPECT_TRUE(LinkAsExpected(program, true)); |
1198 } | 1216 } |
1199 | 1217 |
1200 // If a varying is statically used in fragment shader but not | 1218 // If a varying is statically used in fragment shader but not |
1201 // declared in vertex shader, link should fail. | 1219 // declared in vertex shader, link should fail. |
1202 TEST_F(ProgramManagerWithShaderTest, VaryingMissing) { | 1220 TEST_F(ProgramManagerWithShaderTest, VaryingMissing) { |
1203 Program* program = SetupVaryingsMatchingTest( | 1221 const VarInfo kFragmentVarying = |
1204 false, 0, 0, 0, 0, | 1222 { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a" }; |
1205 true, SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1); | 1223 Program* program = SetupVaryingsTest( |
| 1224 NULL, 0, &kFragmentVarying, 1); |
1206 | 1225 |
1207 EXPECT_TRUE(program->DetectVaryingsMismatch()); | 1226 EXPECT_TRUE(program->DetectVaryingsMismatch()); |
1208 EXPECT_TRUE(LinkAsExpected(program, false)); | 1227 EXPECT_TRUE(LinkAsExpected(program, false)); |
1209 } | 1228 } |
1210 | 1229 |
1211 // If a varying is declared but not statically used in fragment | 1230 // If a varying is declared but not statically used in fragment |
1212 // shader, even if it's not declared in vertex shader, link should | 1231 // shader, even if it's not declared in vertex shader, link should |
1213 // succeed. | 1232 // succeed. |
1214 TEST_F(ProgramManagerWithShaderTest, InactiveVarying) { | 1233 TEST_F(ProgramManagerWithShaderTest, InactiveVarying) { |
1215 Program* program = SetupVaryingsMatchingTest( | 1234 const VarInfo kFragmentVarying = |
1216 false, 0, 0, 0, 0, | 1235 { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 0, "a" }; |
1217 true, SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 0); | 1236 Program* program = SetupVaryingsTest( |
| 1237 NULL, 0, &kFragmentVarying, 1); |
1218 | 1238 |
1219 EXPECT_FALSE(program->DetectVaryingsMismatch()); | 1239 EXPECT_FALSE(program->DetectVaryingsMismatch()); |
1220 EXPECT_TRUE(LinkAsExpected(program, true)); | 1240 EXPECT_TRUE(LinkAsExpected(program, true)); |
1221 } | 1241 } |
1222 | 1242 |
| 1243 // Varyings go over 8 rows. |
| 1244 TEST_F(ProgramManagerWithShaderTest, TooManyVaryings) { |
| 1245 const VarInfo kVertexVaryings[] = { |
| 1246 { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a" }, |
| 1247 { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" } |
| 1248 }; |
| 1249 const VarInfo kFragmentVaryings[] = { |
| 1250 { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a" }, |
| 1251 { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" } |
| 1252 }; |
| 1253 Program* program = SetupVaryingsTest( |
| 1254 kVertexVaryings, 2, kFragmentVaryings, 2); |
| 1255 |
| 1256 EXPECT_FALSE(program->CheckVaryingsPacking()); |
| 1257 EXPECT_TRUE(LinkAsExpected(program, false)); |
| 1258 } |
| 1259 |
| 1260 // Varyings go over 8 rows but some are inactive |
| 1261 TEST_F(ProgramManagerWithShaderTest, TooManyInactiveVaryings) { |
| 1262 const VarInfo kVertexVaryings[] = { |
| 1263 { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a" }, |
| 1264 { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" } |
| 1265 }; |
| 1266 const VarInfo kFragmentVaryings[] = { |
| 1267 { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 0, "a" }, |
| 1268 { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" } |
| 1269 }; |
| 1270 Program* program = SetupVaryingsTest( |
| 1271 kVertexVaryings, 2, kFragmentVaryings, 2); |
| 1272 |
| 1273 EXPECT_TRUE(program->CheckVaryingsPacking()); |
| 1274 EXPECT_TRUE(LinkAsExpected(program, true)); |
| 1275 } |
| 1276 |
1223 TEST_F(ProgramManagerWithShaderTest, ClearWithSamplerTypes) { | 1277 TEST_F(ProgramManagerWithShaderTest, ClearWithSamplerTypes) { |
1224 const GLuint kVShaderClientId = 2001; | 1278 const GLuint kVShaderClientId = 2001; |
1225 const GLuint kFShaderClientId = 2002; | 1279 const GLuint kFShaderClientId = 2002; |
1226 const GLuint kVShaderServiceId = 3001; | 1280 const GLuint kVShaderServiceId = 3001; |
1227 const GLuint kFShaderServiceId = 3002; | 1281 const GLuint kFShaderServiceId = 3002; |
1228 Shader* vshader = shader_manager_.CreateShader( | 1282 Shader* vshader = shader_manager_.CreateShader( |
1229 kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER); | 1283 kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER); |
1230 ASSERT_TRUE(vshader != NULL); | 1284 ASSERT_TRUE(vshader != NULL); |
1231 vshader->SetStatus(true, NULL, NULL); | 1285 vshader->SetStatus(true, NULL, NULL); |
1232 Shader* fshader = shader_manager_.CreateShader( | 1286 Shader* fshader = shader_manager_.CreateShader( |
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1371 public: | 1425 public: |
1372 static const GLuint kClientProgramId = 1; | 1426 static const GLuint kClientProgramId = 1; |
1373 static const GLuint kServiceProgramId = 10; | 1427 static const GLuint kServiceProgramId = 10; |
1374 static const GLuint kVertexShaderClientId = 2; | 1428 static const GLuint kVertexShaderClientId = 2; |
1375 static const GLuint kFragmentShaderClientId = 20; | 1429 static const GLuint kFragmentShaderClientId = 20; |
1376 static const GLuint kVertexShaderServiceId = 3; | 1430 static const GLuint kVertexShaderServiceId = 3; |
1377 static const GLuint kFragmentShaderServiceId = 30; | 1431 static const GLuint kFragmentShaderServiceId = 30; |
1378 | 1432 |
1379 ProgramManagerWithCacheTest() | 1433 ProgramManagerWithCacheTest() |
1380 : cache_(new MockProgramCache()), | 1434 : cache_(new MockProgramCache()), |
1381 manager_(cache_.get()), | 1435 manager_(cache_.get(), kMaxVaryingVectors), |
1382 vertex_shader_(NULL), | 1436 vertex_shader_(NULL), |
1383 fragment_shader_(NULL), | 1437 fragment_shader_(NULL), |
1384 program_(NULL) { | 1438 program_(NULL) { |
1385 } | 1439 } |
1386 virtual ~ProgramManagerWithCacheTest() { | 1440 virtual ~ProgramManagerWithCacheTest() { |
1387 manager_.Destroy(false); | 1441 manager_.Destroy(false); |
1388 shader_manager_.Destroy(false); | 1442 shader_manager_.Destroy(false); |
1389 } | 1443 } |
1390 | 1444 |
1391 protected: | 1445 protected: |
(...skipping 201 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1593 SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS); | 1647 SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS); |
1594 SetExpectationsForNotCachingProgram(); | 1648 SetExpectationsForNotCachingProgram(); |
1595 SetExpectationsForProgramLoadSuccess(); | 1649 SetExpectationsForProgramLoadSuccess(); |
1596 | 1650 |
1597 EXPECT_TRUE(program_->Link(NULL, NULL, NULL, NULL, | 1651 EXPECT_TRUE(program_->Link(NULL, NULL, NULL, NULL, |
1598 base::Bind(&ShaderCacheCb))); | 1652 base::Bind(&ShaderCacheCb))); |
1599 } | 1653 } |
1600 | 1654 |
1601 } // namespace gles2 | 1655 } // namespace gles2 |
1602 } // namespace gpu | 1656 } // namespace gpu |
OLD | NEW |