?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Handle account removal correctly on all platforms.
[chromium-blink-merge.git] / gpu / command_buffer / service / texture_manager_unittest.cc
blob2d509aebd75fbee7800e89a27d68c8f35ae5c49f
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
3 // found in the LICENSE file.
4
5 #include "gpu/command_buffer/service/texture_manager.h"
6
7 #include <utility>
8
9 #include "base/memory/scoped_ptr.h"
10 #include "gpu/command_buffer/service/error_state_mock.h"
11 #include "gpu/command_buffer/service/feature_info.h"
12 #include "gpu/command_buffer/service/framebuffer_manager.h"
13 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
14 #include "gpu/command_buffer/service/gpu_service_test.h"
15 #include "gpu/command_buffer/service/mailbox_manager.h"
16 #include "gpu/command_buffer/service/memory_tracking.h"
17 #include "gpu/command_buffer/service/mocks.h"
18 #include "gpu/command_buffer/service/test_helper.h"
19 #include "testing/gtest/include/gtest/gtest.h"
20 #include "ui/gl/gl_image_stub.h"
21 #include "ui/gl/gl_mock.h"
22
23 using ::testing::AtLeast;
24 using ::testing::Pointee;
25 using ::testing::Return;
26 using ::testing::SetArgumentPointee;
27 using ::testing::StrictMock;
28 using ::testing::_;
29
30 namespace gpu {
31 namespace gles2 {
32
33 class TextureTestHelper {
34 public:
35 static bool IsNPOT(const Texture* texture) {
36 return texture->npot();
37 }
38 static bool IsTextureComplete(const Texture* texture) {
39 return texture->texture_complete();
40 }
41 static bool IsCubeComplete(const Texture* texture) {
42 return texture->cube_complete();
43 }
44 };
45
46 class TextureManagerTest : public GpuServiceTest {
47 public:
48 static const GLint kMaxTextureSize = 16;
49 static const GLint kMaxCubeMapTextureSize = 8;
50 static const GLint kMaxExternalTextureSize = 16;
51 static const GLint kMax2dLevels = 5;
52 static const GLint kMaxCubeMapLevels = 4;
53 static const GLint kMaxExternalLevels = 1;
54 static const bool kUseDefaultTextures = false;
55
56 TextureManagerTest() : feature_info_(new FeatureInfo()) {}
57
58 virtual ~TextureManagerTest() {
59 }
60
61 protected:
62 virtual void SetUp() {
63 GpuServiceTest::SetUp();
64 manager_.reset(new TextureManager(NULL,
65 feature_info_.get(),
66 kMaxTextureSize,
67 kMaxCubeMapTextureSize,
68 kUseDefaultTextures));
69 TestHelper::SetupTextureManagerInitExpectations(
70 gl_.get(), "", kUseDefaultTextures);
71 manager_->Initialize();
72 error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
73 }
74
75 virtual void TearDown() {
76 manager_->Destroy(false);
77 manager_.reset();
78 GpuServiceTest::TearDown();
79 }
80
81 void SetParameter(
82 TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
83 TestHelper::SetTexParameteriWithExpectations(
84 gl_.get(), error_state_.get(), manager_.get(),
85 texture_ref, pname, value, error);
86 }
87
88 scoped_refptr<FeatureInfo> feature_info_;
89 scoped_ptr<TextureManager> manager_;
90 scoped_ptr<MockErrorState> error_state_;
91 };
92
93 // GCC requires these declarations, but MSVC requires they not be present
94 #ifndef COMPILER_MSVC
95 const GLint TextureManagerTest::kMaxTextureSize;
96 const GLint TextureManagerTest::kMaxCubeMapTextureSize;
97 const GLint TextureManagerTest::kMaxExternalTextureSize;
98 const GLint TextureManagerTest::kMax2dLevels;
99 const GLint TextureManagerTest::kMaxCubeMapLevels;
100 const GLint TextureManagerTest::kMaxExternalLevels;
101 #endif
102
103 TEST_F(TextureManagerTest, Basic) {
104 const GLuint kClient1Id = 1;
105 const GLuint kService1Id = 11;
106 const GLuint kClient2Id = 2;
107 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
108 EXPECT_FALSE(manager_->HaveUnsafeTextures());
109 EXPECT_FALSE(manager_->HaveUnclearedMips());
110 // Check we can create texture.
111 manager_->CreateTexture(kClient1Id, kService1Id);
112 // Check texture got created.
113 scoped_refptr<TextureRef> texture = manager_->GetTexture(kClient1Id);
114 ASSERT_TRUE(texture.get() != NULL);
115 EXPECT_EQ(kService1Id, texture->service_id());
116 EXPECT_EQ(kClient1Id, texture->client_id());
117 EXPECT_EQ(texture->texture(), manager_->GetTextureForServiceId(
118 texture->service_id()));
119 // Check we get nothing for a non-existent texture.
120 EXPECT_TRUE(manager_->GetTexture(kClient2Id) == NULL);
121 // Check trying to a remove non-existent textures does not crash.
122 manager_->RemoveTexture(kClient2Id);
123 // Check that it gets deleted when the last reference is released.
124 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id)))
125 .Times(1)
126 .RetiresOnSaturation();
127 // Check we can't get the texture after we remove it.
128 manager_->RemoveTexture(kClient1Id);
129 EXPECT_TRUE(manager_->GetTexture(kClient1Id) == NULL);
130 EXPECT_EQ(0u, texture->client_id());
131 }
132
133 TEST_F(TextureManagerTest, SetParameter) {
134 const GLuint kClient1Id = 1;
135 const GLuint kService1Id = 11;
136 // Check we can create texture.
137 manager_->CreateTexture(kClient1Id, kService1Id);
138 // Check texture got created.
139 TextureRef* texture_ref = manager_->GetTexture(kClient1Id);
140 ASSERT_TRUE(texture_ref != NULL);
141 Texture* texture = texture_ref->texture();
142 manager_->SetTarget(texture_ref, GL_TEXTURE_2D);
143 SetParameter(texture_ref, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
144 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
145 SetParameter(texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
146 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->mag_filter());
147 SetParameter(texture_ref, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
148 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s());
149 SetParameter(texture_ref, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
150 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
151 SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1, GL_NO_ERROR);
152 SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2, GL_NO_ERROR);
153 SetParameter(
154 texture_ref, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
155 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
156 SetParameter(
157 texture_ref, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
158 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
159 SetParameter(texture_ref, GL_TEXTURE_WRAP_S, GL_NEAREST, GL_INVALID_ENUM);
160 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s());
161 SetParameter(texture_ref, GL_TEXTURE_WRAP_T, GL_NEAREST, GL_INVALID_ENUM);
162 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
163 SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE);
164 }
165
166 TEST_F(TextureManagerTest, UseDefaultTexturesTrue) {
167 bool use_default_textures = true;
168 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
169
170 TestHelper::SetupTextureManagerInitExpectations(
171 gl_.get(), "GL_ANGLE_texture_usage", use_default_textures);
172 TextureManager manager(NULL,
173 feature_info_.get(),
174 kMaxTextureSize,
175 kMaxCubeMapTextureSize,
176 use_default_textures);
177 manager.Initialize();
178
179 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) != NULL);
180 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) != NULL);
181
182 // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB.
183
184 manager.Destroy(false);
185 }
186
187 TEST_F(TextureManagerTest, UseDefaultTexturesFalse) {
188 bool use_default_textures = false;
189 TestHelper::SetupTextureManagerInitExpectations(
190 gl_.get(), "GL_ANGLE_texture_usage", use_default_textures);
191 TextureManager manager(NULL,
192 feature_info_.get(),
193 kMaxTextureSize,
194 kMaxCubeMapTextureSize,
195 use_default_textures);
196 manager.Initialize();
197
198 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) == NULL);
199 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) == NULL);
200
201 // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB.
202
203 manager.Destroy(false);
204 }
205
206 TEST_F(TextureManagerTest, TextureUsageExt) {
207 TestHelper::SetupTextureManagerInitExpectations(
208 gl_.get(), "GL_ANGLE_texture_usage", kUseDefaultTextures);
209 TextureManager manager(NULL,
210 feature_info_.get(),
211 kMaxTextureSize,
212 kMaxCubeMapTextureSize,
213 kUseDefaultTextures);
214 manager.Initialize();
215 const GLuint kClient1Id = 1;
216 const GLuint kService1Id = 11;
217 // Check we can create texture.
218 manager.CreateTexture(kClient1Id, kService1Id);
219 // Check texture got created.
220 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
221 ASSERT_TRUE(texture_ref != NULL);
222 TestHelper::SetTexParameteriWithExpectations(
223 gl_.get(), error_state_.get(), &manager, texture_ref,
224 GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE, GL_NO_ERROR);
225 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE),
226 texture_ref->texture()->usage());
227 manager.Destroy(false);
228 }
229
230 TEST_F(TextureManagerTest, Destroy) {
231 const GLuint kClient1Id = 1;
232 const GLuint kService1Id = 11;
233 TestHelper::SetupTextureManagerInitExpectations(
234 gl_.get(), "", kUseDefaultTextures);
235 TextureManager manager(NULL,
236 feature_info_.get(),
237 kMaxTextureSize,
238 kMaxCubeMapTextureSize,
239 kUseDefaultTextures);
240 manager.Initialize();
241 // Check we can create texture.
242 manager.CreateTexture(kClient1Id, kService1Id);
243 // Check texture got created.
244 TextureRef* texture = manager.GetTexture(kClient1Id);
245 ASSERT_TRUE(texture != NULL);
246 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id)))
247 .Times(1)
248 .RetiresOnSaturation();
249 TestHelper::SetupTextureManagerDestructionExpectations(
250 gl_.get(), "", kUseDefaultTextures);
251 manager.Destroy(true);
252 // Check that resources got freed.
253 texture = manager.GetTexture(kClient1Id);
254 ASSERT_TRUE(texture == NULL);
255 }
256
257 TEST_F(TextureManagerTest, MaxValues) {
258 // Check we get the right values for the max sizes.
259 EXPECT_EQ(kMax2dLevels, manager_->MaxLevelsForTarget(GL_TEXTURE_2D));
260 EXPECT_EQ(kMaxCubeMapLevels,
261 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP));
262 EXPECT_EQ(kMaxCubeMapLevels,
263 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X));
264 EXPECT_EQ(kMaxCubeMapLevels,
265 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_X));
266 EXPECT_EQ(kMaxCubeMapLevels,
267 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Y));
268 EXPECT_EQ(kMaxCubeMapLevels,
269 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y));
270 EXPECT_EQ(kMaxCubeMapLevels,
271 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Z));
272 EXPECT_EQ(kMaxCubeMapLevels,
273 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z));
274 EXPECT_EQ(kMaxExternalLevels,
275 manager_->MaxLevelsForTarget(GL_TEXTURE_EXTERNAL_OES));
276 EXPECT_EQ(kMaxTextureSize, manager_->MaxSizeForTarget(GL_TEXTURE_2D));
277 EXPECT_EQ(kMaxCubeMapTextureSize,
278 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP));
279 EXPECT_EQ(kMaxCubeMapTextureSize,
280 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X));
281 EXPECT_EQ(kMaxCubeMapTextureSize,
282 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_X));
283 EXPECT_EQ(kMaxCubeMapTextureSize,
284 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Y));
285 EXPECT_EQ(kMaxCubeMapTextureSize,
286 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y));
287 EXPECT_EQ(kMaxCubeMapTextureSize,
288 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Z));
289 EXPECT_EQ(kMaxCubeMapTextureSize,
290 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z));
291 EXPECT_EQ(kMaxExternalTextureSize,
292 manager_->MaxSizeForTarget(GL_TEXTURE_EXTERNAL_OES));
293 }
294
295 TEST_F(TextureManagerTest, ValidForTarget) {
296 // check 2d
297 EXPECT_TRUE(manager_->ValidForTarget(
298 GL_TEXTURE_2D, 0, kMaxTextureSize, kMaxTextureSize, 1));
299 EXPECT_TRUE(manager_->ValidForTarget(
300 GL_TEXTURE_2D, kMax2dLevels - 1, 1, 1, 1));
301 EXPECT_FALSE(manager_->ValidForTarget(
302 GL_TEXTURE_2D, kMax2dLevels - 1, 1, 2, 1));
303 EXPECT_FALSE(manager_->ValidForTarget(
304 GL_TEXTURE_2D, kMax2dLevels - 1, 2, 1, 1));
305 // check level out of range.
306 EXPECT_FALSE(manager_->ValidForTarget(
307 GL_TEXTURE_2D, kMax2dLevels, kMaxTextureSize, 1, 1));
308 // check has depth.
309 EXPECT_FALSE(manager_->ValidForTarget(
310 GL_TEXTURE_2D, kMax2dLevels, kMaxTextureSize, 1, 2));
311 // Check NPOT width on level 0
312 EXPECT_TRUE(manager_->ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1));
313 // Check NPOT height on level 0
314 EXPECT_TRUE(manager_->ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1));
315 // Check NPOT width on level 1
316 EXPECT_FALSE(manager_->ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1));
317 // Check NPOT height on level 1
318 EXPECT_FALSE(manager_->ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1));
319
320 // check cube
321 EXPECT_TRUE(manager_->ValidForTarget(
322 GL_TEXTURE_CUBE_MAP, 0,
323 kMaxCubeMapTextureSize, kMaxCubeMapTextureSize, 1));
324 EXPECT_TRUE(manager_->ValidForTarget(
325 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels - 1, 1, 1, 1));
326 EXPECT_FALSE(manager_->ValidForTarget(
327 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels - 1, 2, 2, 1));
328 // check level out of range.
329 EXPECT_FALSE(manager_->ValidForTarget(
330 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels,
331 kMaxCubeMapTextureSize, 1, 1));
332 // check not square.
333 EXPECT_FALSE(manager_->ValidForTarget(
334 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels,
335 kMaxCubeMapTextureSize, 1, 1));
336 // check has depth.
337 EXPECT_FALSE(manager_->ValidForTarget(
338 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels,
339 kMaxCubeMapTextureSize, 1, 2));
340
341 for (GLint level = 0; level < kMax2dLevels; ++level) {
342 EXPECT_TRUE(manager_->ValidForTarget(
343 GL_TEXTURE_2D, level, kMaxTextureSize >> level, 1, 1));
344 EXPECT_TRUE(manager_->ValidForTarget(
345 GL_TEXTURE_2D, level, 1, kMaxTextureSize >> level, 1));
346 EXPECT_FALSE(manager_->ValidForTarget(
347 GL_TEXTURE_2D, level, (kMaxTextureSize >> level) + 1, 1, 1));
348 EXPECT_FALSE(manager_->ValidForTarget(
349 GL_TEXTURE_2D, level, 1, (kMaxTextureSize >> level) + 1, 1));
350 }
351
352 for (GLint level = 0; level < kMaxCubeMapLevels; ++level) {
353 EXPECT_TRUE(manager_->ValidForTarget(
354 GL_TEXTURE_CUBE_MAP, level,
355 kMaxCubeMapTextureSize >> level,
356 kMaxCubeMapTextureSize >> level,
357 1));
358 EXPECT_FALSE(manager_->ValidForTarget(
359 GL_TEXTURE_CUBE_MAP, level,
360 (kMaxCubeMapTextureSize >> level) * 2,
361 (kMaxCubeMapTextureSize >> level) * 2,
362 1));
363 }
364 }
365
366 TEST_F(TextureManagerTest, ValidForTargetNPOT) {
367 TestHelper::SetupFeatureInfoInitExpectations(
368 gl_.get(), "GL_OES_texture_npot");
369 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
370 feature_info->Initialize();
371 TextureManager manager(NULL,
372 feature_info.get(),
373 kMaxTextureSize,
374 kMaxCubeMapTextureSize,
375 kUseDefaultTextures);
376 // Check NPOT width on level 0
377 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1));
378 // Check NPOT height on level 0
379 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1));
380 // Check NPOT width on level 1
381 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1));
382 // Check NPOT height on level 1
383 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1));
384 manager.Destroy(false);
385 }
386
387 class TextureTestBase : public GpuServiceTest {
388 public:
389 static const GLint kMaxTextureSize = 16;
390 static const GLint kMaxCubeMapTextureSize = 8;
391 static const GLint kMax2dLevels = 5;
392 static const GLint kMaxCubeMapLevels = 4;
393 static const GLuint kClient1Id = 1;
394 static const GLuint kService1Id = 11;
395 static const bool kUseDefaultTextures = false;
396
397 TextureTestBase()
398 : feature_info_(new FeatureInfo()) {
399 }
400 virtual ~TextureTestBase() {
401 texture_ref_ = NULL;
402 }
403
404 protected:
405 void SetUpBase(MemoryTracker* memory_tracker, std::string extensions) {
406 GpuServiceTest::SetUp();
407 if (!extensions.empty()) {
408 TestHelper::SetupFeatureInfoInitExpectations(gl_.get(),
409 extensions.c_str());
410 feature_info_->Initialize();
411 }
412
413 manager_.reset(new TextureManager(memory_tracker,
414 feature_info_.get(),
415 kMaxTextureSize,
416 kMaxCubeMapTextureSize,
417 kUseDefaultTextures));
418 decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
419 error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
420 manager_->CreateTexture(kClient1Id, kService1Id);
421 texture_ref_ = manager_->GetTexture(kClient1Id);
422 ASSERT_TRUE(texture_ref_.get() != NULL);
423 }
424
425 virtual void TearDown() {
426 if (texture_ref_.get()) {
427 // If it's not in the manager then setting texture_ref_ to NULL will
428 // delete the texture.
429 if (!texture_ref_->client_id()) {
430 // Check that it gets deleted when the last reference is released.
431 EXPECT_CALL(*gl_,
432 DeleteTextures(1, ::testing::Pointee(texture_ref_->service_id())))
433 .Times(1)
434 .RetiresOnSaturation();
435 }
436 texture_ref_ = NULL;
437 }
438 manager_->Destroy(false);
439 manager_.reset();
440 GpuServiceTest::TearDown();
441 }
442
443 void SetParameter(
444 TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
445 TestHelper::SetTexParameteriWithExpectations(
446 gl_.get(), error_state_.get(), manager_.get(),
447 texture_ref, pname, value, error);
448 }
449
450 scoped_ptr<MockGLES2Decoder> decoder_;
451 scoped_ptr<MockErrorState> error_state_;
452 scoped_refptr<FeatureInfo> feature_info_;
453 scoped_ptr<TextureManager> manager_;
454 scoped_refptr<TextureRef> texture_ref_;
455 };
456
457 class TextureTest : public TextureTestBase {
458 protected:
459 virtual void SetUp() {
460 SetUpBase(NULL, std::string());
461 }
462 };
463
464 class TextureMemoryTrackerTest : public TextureTestBase {
465 protected:
466 virtual void SetUp() {
467 mock_memory_tracker_ = new StrictMock<MockMemoryTracker>();
468 SetUpBase(mock_memory_tracker_.get(), std::string());
469 }
470
471 scoped_refptr<MockMemoryTracker> mock_memory_tracker_;
472 };
473
474 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \
475 EXPECT_CALL(*mock_memory_tracker_.get(), \
476 TrackMemoryAllocatedChange(old_size, new_size, pool)) \
477 .Times(1).RetiresOnSaturation()
478
479 TEST_F(TextureTest, Basic) {
480 Texture* texture = texture_ref_->texture();
481 EXPECT_EQ(0u, texture->target());
482 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
483 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
484 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
485 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
486 EXPECT_EQ(0, texture->num_uncleared_mips());
487 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
488 EXPECT_TRUE(texture->SafeToRenderFrom());
489 EXPECT_FALSE(texture->IsImmutable());
490 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR),
491 texture->min_filter());
492 EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), texture->mag_filter());
493 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_s());
494 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_t());
495 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
496 EXPECT_FALSE(manager_->HaveUnsafeTextures());
497 EXPECT_EQ(0u, texture->estimated_size());
498 }
499
500 TEST_F(TextureTest, SetTargetTexture2D) {
501 Texture* texture = texture_ref_->texture();
502 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
503 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
504 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
505 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
506 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
507 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
508 EXPECT_TRUE(texture->SafeToRenderFrom());
509 EXPECT_FALSE(texture->IsImmutable());
510 }
511
512 TEST_F(TextureTest, SetTargetTextureExternalOES) {
513 Texture* texture = texture_ref_->texture();
514 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES);
515 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
516 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
517 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
518 EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
519 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
520 EXPECT_TRUE(texture->SafeToRenderFrom());
521 EXPECT_TRUE(texture->IsImmutable());
522 }
523
524 TEST_F(TextureTest, ZeroSizeCanNotRender) {
525 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
526 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
527 manager_->SetLevelInfo(texture_ref_.get(),
528 GL_TEXTURE_2D,
529 0,
530 GL_RGBA,
531 1,
532 1,
533 1,
534 0,
535 GL_RGBA,
536 GL_UNSIGNED_BYTE,
537 true);
538 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
539 manager_->SetLevelInfo(texture_ref_.get(),
540 GL_TEXTURE_2D,
541 0,
542 GL_RGBA,
543 0,
544 0,
545 1,
546 0,
547 GL_RGBA,
548 GL_UNSIGNED_BYTE,
549 true);
550 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
551 }
552
553 TEST_F(TextureTest, EstimatedSize) {
554 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
555 manager_->SetLevelInfo(texture_ref_.get(),
556 GL_TEXTURE_2D,
557 0,
558 GL_RGBA,
559 8,
560 4,
561 1,
562 0,
563 GL_RGBA,
564 GL_UNSIGNED_BYTE,
565 true);
566 EXPECT_EQ(8u * 4u * 4u, texture_ref_->texture()->estimated_size());
567 manager_->SetLevelInfo(texture_ref_.get(),
568 GL_TEXTURE_2D,
569 2,
570 GL_RGBA,
571 8,
572 4,
573 1,
574 0,
575 GL_RGBA,
576 GL_UNSIGNED_BYTE,
577 true);
578 EXPECT_EQ(8u * 4u * 4u * 2u, texture_ref_->texture()->estimated_size());
579 }
580
581 TEST_F(TextureMemoryTrackerTest, EstimatedSize) {
582 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
583 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
584 manager_->SetLevelInfo(texture_ref_.get(),
585 GL_TEXTURE_2D,
586 0,
587 GL_RGBA,
588 8,
589 4,
590 1,
591 0,
592 GL_RGBA,
593 GL_UNSIGNED_BYTE,
594 true);
595 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
596 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged);
597 manager_->SetLevelInfo(texture_ref_.get(),
598 GL_TEXTURE_2D,
599 2,
600 GL_RGBA,
601 8,
602 4,
603 1,
604 0,
605 GL_RGBA,
606 GL_UNSIGNED_BYTE,
607 true);
608 // Add expectation for texture deletion.
609 EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged);
610 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
611 }
612
613 TEST_F(TextureMemoryTrackerTest, SetParameterPool) {
614 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
615 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
616 manager_->SetLevelInfo(texture_ref_.get(),
617 GL_TEXTURE_2D,
618 0,
619 GL_RGBA,
620 8,
621 4,
622 1,
623 0,
624 GL_RGBA,
625 GL_UNSIGNED_BYTE,
626 true);
627 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
628 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged);
629 SetParameter(texture_ref_.get(),
630 GL_TEXTURE_POOL_CHROMIUM,
631 GL_TEXTURE_POOL_MANAGED_CHROMIUM,
632 GL_NO_ERROR);
633 // Add expectation for texture deletion.
634 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged);
635 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
636 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged);
637 }
638
639 TEST_F(TextureTest, POT2D) {
640 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
641 Texture* texture = texture_ref_->texture();
642 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
643 // Check Setting level 0 to POT
644 manager_->SetLevelInfo(texture_ref_.get(),
645 GL_TEXTURE_2D,
646 0,
647 GL_RGBA,
648 4,
649 4,
650 1,
651 0,
652 GL_RGBA,
653 GL_UNSIGNED_BYTE,
654 true);
655 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
656 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
657 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
658 EXPECT_EQ(0, texture->num_uncleared_mips());
659 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
660 // Set filters to something that will work with a single mip.
661 SetParameter(
662 texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
663 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
664 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
665 // Set them back.
666 SetParameter(texture_ref_.get(),
667 GL_TEXTURE_MIN_FILTER,
668 GL_LINEAR_MIPMAP_LINEAR,
669 GL_NO_ERROR);
670 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
671
672 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
673 // Make mips.
674 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
675 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
676 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
677 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
678 // Change a mip.
679 manager_->SetLevelInfo(texture_ref_.get(),
680 GL_TEXTURE_2D,
681 1,
682 GL_RGBA,
683 4,
684 4,
685 1,
686 0,
687 GL_RGBA,
688 GL_UNSIGNED_BYTE,
689 true);
690 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
691 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
692 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
693 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
694 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
695 // Set a level past the number of mips that would get generated.
696 manager_->SetLevelInfo(texture_ref_.get(),
697 GL_TEXTURE_2D,
698 3,
699 GL_RGBA,
700 4,
701 4,
702 1,
703 0,
704 GL_RGBA,
705 GL_UNSIGNED_BYTE,
706 true);
707 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
708 // Make mips.
709 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
710 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
711 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
712 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
713 }
714
715 TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) {
716 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
717 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged);
718 manager_->SetLevelInfo(texture_ref_.get(),
719 GL_TEXTURE_2D,
720 0,
721 GL_RGBA,
722 4,
723 4,
724 1,
725 0,
726 GL_RGBA,
727 GL_UNSIGNED_BYTE,
728 true);
729 EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged);
730 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged);
731 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
732 EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged);
733 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
734 }
735
736 TEST_F(TextureTest, UnusedMips) {
737 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
738 Texture* texture = texture_ref_->texture();
739 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
740 // Set level zero to large size.
741 manager_->SetLevelInfo(texture_ref_.get(),
742 GL_TEXTURE_2D,
743 0,
744 GL_RGBA,
745 4,
746 4,
747 1,
748 0,
749 GL_RGBA,
750 GL_UNSIGNED_BYTE,
751 true);
752 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
753 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
754 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
755 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
756 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
757 // Set level zero to large smaller (levels unused mips)
758 manager_->SetLevelInfo(texture_ref_.get(),
759 GL_TEXTURE_2D,
760 0,
761 GL_RGBA,
762 2,
763 2,
764 1,
765 0,
766 GL_RGBA,
767 GL_UNSIGNED_BYTE,
768 true);
769 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
770 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
771 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
772 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
773 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
774 // Set an unused level to some size
775 manager_->SetLevelInfo(texture_ref_.get(),
776 GL_TEXTURE_2D,
777 4,
778 GL_RGBA,
779 16,
780 16,
781 1,
782 0,
783 GL_RGBA,
784 GL_UNSIGNED_BYTE,
785 true);
786 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
787 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
788 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
789 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
790 }
791
792 TEST_F(TextureTest, NPOT2D) {
793 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
794 Texture* texture = texture_ref_->texture();
795 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
796 // Check Setting level 0 to NPOT
797 manager_->SetLevelInfo(texture_ref_.get(),
798 GL_TEXTURE_2D,
799 0,
800 GL_RGBA,
801 4,
802 5,
803 1,
804 0,
805 GL_RGBA,
806 GL_UNSIGNED_BYTE,
807 true);
808 EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
809 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
810 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
811 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
812 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
813 SetParameter(
814 texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
815 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
816 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
817 SetParameter(
818 texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
819 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
820 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
821 SetParameter(
822 texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
823 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
824 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
825 // Change it to POT.
826 manager_->SetLevelInfo(texture_ref_.get(),
827 GL_TEXTURE_2D,
828 0,
829 GL_RGBA,
830 4,
831 4,
832 1,
833 0,
834 GL_RGBA,
835 GL_UNSIGNED_BYTE,
836 true);
837 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
838 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
839 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
840 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
841 }
842
843 TEST_F(TextureTest, NPOT2DNPOTOK) {
844 TestHelper::SetupFeatureInfoInitExpectations(
845 gl_.get(), "GL_OES_texture_npot");
846 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
847 feature_info->Initialize();
848 TextureManager manager(NULL,
849 feature_info.get(),
850 kMaxTextureSize,
851 kMaxCubeMapTextureSize,
852 kUseDefaultTextures);
853 manager.CreateTexture(kClient1Id, kService1Id);
854 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
855 ASSERT_TRUE(texture_ref != NULL);
856 Texture* texture = texture_ref->texture();
857
858 manager.SetTarget(texture_ref, GL_TEXTURE_2D);
859 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
860 // Check Setting level 0 to NPOT
861 manager.SetLevelInfo(texture_ref,
862 GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
863 EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
864 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
865 EXPECT_TRUE(manager.CanGenerateMipmaps(texture_ref));
866 EXPECT_FALSE(manager.CanRender(texture_ref));
867 EXPECT_TRUE(manager.HaveUnrenderableTextures());
868 EXPECT_TRUE(manager.MarkMipmapsGenerated(texture_ref));
869 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
870 EXPECT_TRUE(manager.CanRender(texture_ref));
871 EXPECT_FALSE(manager.HaveUnrenderableTextures());
872 manager.Destroy(false);
873 }
874
875 TEST_F(TextureTest, POTCubeMap) {
876 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_CUBE_MAP);
877 Texture* texture = texture_ref_->texture();
878 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
879 // Check Setting level 0 each face to POT
880 manager_->SetLevelInfo(texture_ref_.get(),
881 GL_TEXTURE_CUBE_MAP_POSITIVE_X,
882 0,
883 GL_RGBA,
884 4,
885 4,
886 1,
887 0,
888 GL_RGBA,
889 GL_UNSIGNED_BYTE,
890 true);
891 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
892 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
893 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
894 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
895 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
896 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
897 manager_->SetLevelInfo(texture_ref_.get(),
898 GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
899 0,
900 GL_RGBA,
901 4,
902 4,
903 1,
904 0,
905 GL_RGBA,
906 GL_UNSIGNED_BYTE,
907 true);
908 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
909 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
910 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
911 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
912 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
913 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
914 manager_->SetLevelInfo(texture_ref_.get(),
915 GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
916 0,
917 GL_RGBA,
918 4,
919 4,
920 1,
921 0,
922 GL_RGBA,
923 GL_UNSIGNED_BYTE,
924 true);
925 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
926 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
927 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
928 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
929 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
930 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
931 manager_->SetLevelInfo(texture_ref_.get(),
932 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
933 0,
934 GL_RGBA,
935 4,
936 4,
937 1,
938 0,
939 GL_RGBA,
940 GL_UNSIGNED_BYTE,
941 true);
942 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
943 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
944 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
945 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
946 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
947 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
948 manager_->SetLevelInfo(texture_ref_.get(),
949 GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
950 0,
951 GL_RGBA,
952 4,
953 4,
954 1,
955 0,
956 GL_RGBA,
957 GL_UNSIGNED_BYTE,
958 true);
959 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
960 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
961 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
962 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get()));
963 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
964 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
965 manager_->SetLevelInfo(texture_ref_.get(),
966 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
967 0,
968 GL_RGBA,
969 4,
970 4,
971 1,
972 0,
973 GL_RGBA,
974 GL_UNSIGNED_BYTE,
975 true);
976 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
977 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
978 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
979 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
980 EXPECT_FALSE(manager_->CanRender(texture_ref_.get()));
981 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
982
983 // Make mips.
984 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
985 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
986 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
987 EXPECT_TRUE(manager_->CanRender(texture_ref_.get()));
988 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
989
990 // Change a mip.
991 manager_->SetLevelInfo(texture_ref_.get(),
992 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
993 1,
994 GL_RGBA,
995 4,
996 4,
997 1,
998 0,
999 GL_RGBA,
1000 GL_UNSIGNED_BYTE,
1001 true);
1002 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
1003 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
1004 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
1005 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
1006 // Set a level past the number of mips that would get generated.
1007 manager_->SetLevelInfo(texture_ref_.get(),
1008 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
1009 3,
1010 GL_RGBA,
1011 4,
1012 4,
1013 1,
1014 0,
1015 GL_RGBA,
1016 GL_UNSIGNED_BYTE,
1017 true);
1018 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
1019 // Make mips.
1020 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
1021 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
1022 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
1023 }
1024
1025 TEST_F(TextureTest, GetLevelSize) {
1026 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1027 manager_->SetLevelInfo(texture_ref_.get(),
1028 GL_TEXTURE_2D,
1029 1,
1030 GL_RGBA,
1031 4,
1032 5,
1033 1,
1034 0,
1035 GL_RGBA,
1036 GL_UNSIGNED_BYTE,
1037 true);
1038 GLsizei width = -1;
1039 GLsizei height = -1;
1040 Texture* texture = texture_ref_->texture();
1041 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height));
1042 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height));
1043 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
1044 EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
1045 EXPECT_EQ(4, width);
1046 EXPECT_EQ(5, height);
1047 manager_->RemoveTexture(kClient1Id);
1048 EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
1049 EXPECT_EQ(4, width);
1050 EXPECT_EQ(5, height);
1051 }
1052
1053 TEST_F(TextureTest, GetLevelType) {
1054 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1055 manager_->SetLevelInfo(texture_ref_.get(),
1056 GL_TEXTURE_2D,
1057 1,
1058 GL_RGBA,
1059 4,
1060 5,
1061 1,
1062 0,
1063 GL_RGBA,
1064 GL_UNSIGNED_BYTE,
1065 true);
1066 GLenum type = 0;
1067 GLenum format = 0;
1068 Texture* texture = texture_ref_->texture();
1069 EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, -1, &type, &format));
1070 EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format));
1071 EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &format));
1072 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
1073 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
1074 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
1075 manager_->RemoveTexture(kClient1Id);
1076 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
1077 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
1078 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
1079 }
1080
1081 TEST_F(TextureTest, ValidForTexture) {
1082 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1083 manager_->SetLevelInfo(texture_ref_.get(),
1084 GL_TEXTURE_2D,
1085 1,
1086 GL_RGBA,
1087 4,
1088 5,
1089 1,
1090 0,
1091 GL_RGBA,
1092 GL_UNSIGNED_BYTE,
1093 true);
1094 // Check bad face.
1095 Texture* texture = texture_ref_->texture();
1096 EXPECT_FALSE(texture->ValidForTexture(
1097 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
1098 1, 0, 0, 4, 5, GL_UNSIGNED_BYTE));
1099 // Check bad level.
1100 EXPECT_FALSE(texture->ValidForTexture(
1101 GL_TEXTURE_2D, 0, 0, 0, 4, 5, GL_UNSIGNED_BYTE));
1102 // Check bad xoffset.
1103 EXPECT_FALSE(texture->ValidForTexture(
1104 GL_TEXTURE_2D, 1, -1, 0, 4, 5, GL_UNSIGNED_BYTE));
1105 // Check bad xoffset + width > width.
1106 EXPECT_FALSE(texture->ValidForTexture(
1107 GL_TEXTURE_2D, 1, 1, 0, 4, 5, GL_UNSIGNED_BYTE));
1108 // Check bad yoffset.
1109 EXPECT_FALSE(texture->ValidForTexture(
1110 GL_TEXTURE_2D, 1, 0, -1, 4, 5, GL_UNSIGNED_BYTE));
1111 // Check bad yoffset + height > height.
1112 EXPECT_FALSE(texture->ValidForTexture(
1113 GL_TEXTURE_2D, 1, 0, 1, 4, 5, GL_UNSIGNED_BYTE));
1114 // Check bad width.
1115 EXPECT_FALSE(texture->ValidForTexture(
1116 GL_TEXTURE_2D, 1, 0, 0, 5, 5, GL_UNSIGNED_BYTE));
1117 // Check bad height.
1118 EXPECT_FALSE(texture->ValidForTexture(
1119 GL_TEXTURE_2D, 1, 0, 0, 4, 6, GL_UNSIGNED_BYTE));
1120 // Check bad type.
1121 EXPECT_FALSE(texture->ValidForTexture(
1122 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_UNSIGNED_SHORT_4_4_4_4));
1123 // Check valid full size
1124 EXPECT_TRUE(texture->ValidForTexture(
1125 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_UNSIGNED_BYTE));
1126 // Check valid particial size.
1127 EXPECT_TRUE(texture->ValidForTexture(
1128 GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_UNSIGNED_BYTE));
1129 manager_->RemoveTexture(kClient1Id);
1130 EXPECT_TRUE(texture->ValidForTexture(
1131 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_UNSIGNED_BYTE));
1132 }
1133
1134 TEST_F(TextureTest, FloatNotLinear) {
1135 TestHelper::SetupFeatureInfoInitExpectations(
1136 gl_.get(), "GL_OES_texture_float");
1137 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
1138 feature_info->Initialize();
1139 TextureManager manager(NULL,
1140 feature_info.get(),
1141 kMaxTextureSize,
1142 kMaxCubeMapTextureSize,
1143 kUseDefaultTextures);
1144 manager.CreateTexture(kClient1Id, kService1Id);
1145 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
1146 ASSERT_TRUE(texture_ref != NULL);
1147 manager.SetTarget(texture_ref, GL_TEXTURE_2D);
1148 Texture* texture = texture_ref->texture();
1149 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
1150 manager.SetLevelInfo(texture_ref,
1151 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
1152 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
1153 TestHelper::SetTexParameteriWithExpectations(
1154 gl_.get(), error_state_.get(), &manager,
1155 texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
1156 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
1157 TestHelper::SetTexParameteriWithExpectations(
1158 gl_.get(), error_state_.get(), &manager, texture_ref,
1159 GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
1160 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
1161 manager.Destroy(false);
1162 }
1163
1164 TEST_F(TextureTest, FloatLinear) {
1165 TestHelper::SetupFeatureInfoInitExpectations(
1166 gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear");
1167 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
1168 feature_info->Initialize();
1169 TextureManager manager(NULL,
1170 feature_info.get(),
1171 kMaxTextureSize,
1172 kMaxCubeMapTextureSize,
1173 kUseDefaultTextures);
1174 manager.CreateTexture(kClient1Id, kService1Id);
1175 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
1176 ASSERT_TRUE(texture_ref != NULL);
1177 manager.SetTarget(texture_ref, GL_TEXTURE_2D);
1178 Texture* texture = texture_ref->texture();
1179 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
1180 manager.SetLevelInfo(texture_ref,
1181 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
1182 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
1183 manager.Destroy(false);
1184 }
1185
1186 TEST_F(TextureTest, HalfFloatNotLinear) {
1187 TestHelper::SetupFeatureInfoInitExpectations(
1188 gl_.get(), "GL_OES_texture_half_float");
1189 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
1190 feature_info->Initialize();
1191 TextureManager manager(NULL,
1192 feature_info.get(),
1193 kMaxTextureSize,
1194 kMaxCubeMapTextureSize,
1195 kUseDefaultTextures);
1196 manager.CreateTexture(kClient1Id, kService1Id);
1197 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
1198 ASSERT_TRUE(texture_ref != NULL);
1199 manager.SetTarget(texture_ref, GL_TEXTURE_2D);
1200 Texture* texture = texture_ref->texture();
1201 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
1202 manager.SetLevelInfo(texture_ref,
1203 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
1204 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
1205 TestHelper::SetTexParameteriWithExpectations(
1206 gl_.get(), error_state_.get(), &manager,
1207 texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
1208 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
1209 TestHelper::SetTexParameteriWithExpectations(
1210 gl_.get(), error_state_.get(), &manager, texture_ref,
1211 GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
1212 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
1213 manager.Destroy(false);
1214 }
1215
1216 TEST_F(TextureTest, HalfFloatLinear) {
1217 TestHelper::SetupFeatureInfoInitExpectations(
1218 gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear");
1219 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
1220 feature_info->Initialize();
1221 TextureManager manager(NULL,
1222 feature_info.get(),
1223 kMaxTextureSize,
1224 kMaxCubeMapTextureSize,
1225 kUseDefaultTextures);
1226 manager.CreateTexture(kClient1Id, kService1Id);
1227 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
1228 ASSERT_TRUE(texture_ref != NULL);
1229 manager.SetTarget(texture_ref, GL_TEXTURE_2D);
1230 Texture* texture = texture_ref->texture();
1231 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
1232 manager.SetLevelInfo(texture_ref,
1233 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
1234 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
1235 manager.Destroy(false);
1236 }
1237
1238 TEST_F(TextureTest, EGLImageExternal) {
1239 TestHelper::SetupFeatureInfoInitExpectations(
1240 gl_.get(), "GL_OES_EGL_image_external");
1241 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
1242 feature_info->Initialize();
1243 TextureManager manager(NULL,
1244 feature_info.get(),
1245 kMaxTextureSize,
1246 kMaxCubeMapTextureSize,
1247 kUseDefaultTextures);
1248 manager.CreateTexture(kClient1Id, kService1Id);
1249 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
1250 ASSERT_TRUE(texture_ref != NULL);
1251 manager.SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
1252 Texture* texture = texture_ref->texture();
1253 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
1254 EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
1255 manager.Destroy(false);
1256 }
1257
1258 TEST_F(TextureTest, DepthTexture) {
1259 TestHelper::SetupFeatureInfoInitExpectations(
1260 gl_.get(), "GL_ANGLE_depth_texture");
1261 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
1262 feature_info->Initialize();
1263 TextureManager manager(NULL,
1264 feature_info.get(),
1265 kMaxTextureSize,
1266 kMaxCubeMapTextureSize,
1267 kUseDefaultTextures);
1268 manager.CreateTexture(kClient1Id, kService1Id);
1269 TextureRef* texture_ref = manager.GetTexture(kClient1Id);
1270 ASSERT_TRUE(texture_ref != NULL);
1271 manager.SetTarget(texture_ref, GL_TEXTURE_2D);
1272 manager.SetLevelInfo(
1273 texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
1274 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
1275 EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
1276 manager.Destroy(false);
1277 }
1278
1279 TEST_F(TextureTest, SafeUnsafe) {
1280 static const GLuint kClient2Id = 2;
1281 static const GLuint kService2Id = 12;
1282 static const GLuint kClient3Id = 3;
1283 static const GLuint kService3Id = 13;
1284 EXPECT_FALSE(manager_->HaveUnclearedMips());
1285 Texture* texture = texture_ref_->texture();
1286 EXPECT_EQ(0, texture->num_uncleared_mips());
1287 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1288 manager_->SetLevelInfo(texture_ref_.get(),
1289 GL_TEXTURE_2D,
1290 0,
1291 GL_RGBA,
1292 4,
1293 4,
1294 1,
1295 0,
1296 GL_RGBA,
1297 GL_UNSIGNED_BYTE,
1298 false);
1299 EXPECT_FALSE(texture->SafeToRenderFrom());
1300 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1301 EXPECT_TRUE(manager_->HaveUnclearedMips());
1302 EXPECT_EQ(1, texture->num_uncleared_mips());
1303 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true);
1304 EXPECT_TRUE(texture->SafeToRenderFrom());
1305 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1306 EXPECT_FALSE(manager_->HaveUnclearedMips());
1307 EXPECT_EQ(0, texture->num_uncleared_mips());
1308 manager_->SetLevelInfo(texture_ref_.get(),
1309 GL_TEXTURE_2D,
1310 1,
1311 GL_RGBA,
1312 8,
1313 8,
1314 1,
1315 0,
1316 GL_RGBA,
1317 GL_UNSIGNED_BYTE,
1318 false);
1319 EXPECT_FALSE(texture->SafeToRenderFrom());
1320 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1321 EXPECT_TRUE(manager_->HaveUnclearedMips());
1322 EXPECT_EQ(1, texture->num_uncleared_mips());
1323 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true);
1324 EXPECT_TRUE(texture->SafeToRenderFrom());
1325 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1326 EXPECT_FALSE(manager_->HaveUnclearedMips());
1327 EXPECT_EQ(0, texture->num_uncleared_mips());
1328 manager_->SetLevelInfo(texture_ref_.get(),
1329 GL_TEXTURE_2D,
1330 0,
1331 GL_RGBA,
1332 4,
1333 4,
1334 1,
1335 0,
1336 GL_RGBA,
1337 GL_UNSIGNED_BYTE,
1338 false);
1339 manager_->SetLevelInfo(texture_ref_.get(),
1340 GL_TEXTURE_2D,
1341 1,
1342 GL_RGBA,
1343 8,
1344 8,
1345 1,
1346 0,
1347 GL_RGBA,
1348 GL_UNSIGNED_BYTE,
1349 false);
1350 EXPECT_FALSE(texture->SafeToRenderFrom());
1351 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1352 EXPECT_TRUE(manager_->HaveUnclearedMips());
1353 EXPECT_EQ(2, texture->num_uncleared_mips());
1354 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true);
1355 EXPECT_FALSE(texture->SafeToRenderFrom());
1356 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1357 EXPECT_TRUE(manager_->HaveUnclearedMips());
1358 EXPECT_EQ(1, texture->num_uncleared_mips());
1359 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true);
1360 EXPECT_TRUE(texture->SafeToRenderFrom());
1361 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1362 EXPECT_FALSE(manager_->HaveUnclearedMips());
1363 EXPECT_EQ(0, texture->num_uncleared_mips());
1364 manager_->SetLevelInfo(texture_ref_.get(),
1365 GL_TEXTURE_2D,
1366 1,
1367 GL_RGBA,
1368 8,
1369 8,
1370 1,
1371 0,
1372 GL_RGBA,
1373 GL_UNSIGNED_BYTE,
1374 false);
1375 EXPECT_FALSE(texture->SafeToRenderFrom());
1376 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1377 EXPECT_TRUE(manager_->HaveUnclearedMips());
1378 EXPECT_EQ(1, texture->num_uncleared_mips());
1379 manager_->MarkMipmapsGenerated(texture_ref_.get());
1380 EXPECT_TRUE(texture->SafeToRenderFrom());
1381 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1382 EXPECT_FALSE(manager_->HaveUnclearedMips());
1383 EXPECT_EQ(0, texture->num_uncleared_mips());
1384
1385 manager_->CreateTexture(kClient2Id, kService2Id);
1386 scoped_refptr<TextureRef> texture_ref2(
1387 manager_->GetTexture(kClient2Id));
1388 ASSERT_TRUE(texture_ref2.get() != NULL);
1389 manager_->SetTarget(texture_ref2.get(), GL_TEXTURE_2D);
1390 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1391 EXPECT_FALSE(manager_->HaveUnclearedMips());
1392 Texture* texture2 = texture_ref2->texture();
1393 EXPECT_EQ(0, texture2->num_uncleared_mips());
1394 manager_->SetLevelInfo(texture_ref2.get(),
1395 GL_TEXTURE_2D,
1396 0,
1397 GL_RGBA,
1398 8,
1399 8,
1400 1,
1401 0,
1402 GL_RGBA,
1403 GL_UNSIGNED_BYTE,
1404 true);
1405 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1406 EXPECT_FALSE(manager_->HaveUnclearedMips());
1407 EXPECT_EQ(0, texture2->num_uncleared_mips());
1408 manager_->SetLevelInfo(texture_ref2.get(),
1409 GL_TEXTURE_2D,
1410 0,
1411 GL_RGBA,
1412 8,
1413 8,
1414 1,
1415 0,
1416 GL_RGBA,
1417 GL_UNSIGNED_BYTE,
1418 false);
1419 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1420 EXPECT_TRUE(manager_->HaveUnclearedMips());
1421 EXPECT_EQ(1, texture2->num_uncleared_mips());
1422
1423 manager_->CreateTexture(kClient3Id, kService3Id);
1424 scoped_refptr<TextureRef> texture_ref3(
1425 manager_->GetTexture(kClient3Id));
1426 ASSERT_TRUE(texture_ref3.get() != NULL);
1427 manager_->SetTarget(texture_ref3.get(), GL_TEXTURE_2D);
1428 manager_->SetLevelInfo(texture_ref3.get(),
1429 GL_TEXTURE_2D,
1430 0,
1431 GL_RGBA,
1432 8,
1433 8,
1434 1,
1435 0,
1436 GL_RGBA,
1437 GL_UNSIGNED_BYTE,
1438 false);
1439 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1440 EXPECT_TRUE(manager_->HaveUnclearedMips());
1441 Texture* texture3 = texture_ref3->texture();
1442 EXPECT_EQ(1, texture3->num_uncleared_mips());
1443 manager_->SetLevelCleared(texture_ref2.get(), GL_TEXTURE_2D, 0, true);
1444 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1445 EXPECT_TRUE(manager_->HaveUnclearedMips());
1446 EXPECT_EQ(0, texture2->num_uncleared_mips());
1447 manager_->SetLevelCleared(texture_ref3.get(), GL_TEXTURE_2D, 0, true);
1448 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1449 EXPECT_FALSE(manager_->HaveUnclearedMips());
1450 EXPECT_EQ(0, texture3->num_uncleared_mips());
1451
1452 manager_->SetLevelInfo(texture_ref2.get(),
1453 GL_TEXTURE_2D,
1454 0,
1455 GL_RGBA,
1456 8,
1457 8,
1458 1,
1459 0,
1460 GL_RGBA,
1461 GL_UNSIGNED_BYTE,
1462 false);
1463 manager_->SetLevelInfo(texture_ref3.get(),
1464 GL_TEXTURE_2D,
1465 0,
1466 GL_RGBA,
1467 8,
1468 8,
1469 1,
1470 0,
1471 GL_RGBA,
1472 GL_UNSIGNED_BYTE,
1473 false);
1474 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1475 EXPECT_TRUE(manager_->HaveUnclearedMips());
1476 EXPECT_EQ(1, texture2->num_uncleared_mips());
1477 EXPECT_EQ(1, texture3->num_uncleared_mips());
1478 manager_->RemoveTexture(kClient3Id);
1479 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1480 EXPECT_TRUE(manager_->HaveUnclearedMips());
1481 manager_->RemoveTexture(kClient2Id);
1482 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1483 EXPECT_TRUE(manager_->HaveUnclearedMips());
1484 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
1485 .Times(1)
1486 .RetiresOnSaturation();
1487 texture_ref2 = NULL;
1488 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1489 EXPECT_TRUE(manager_->HaveUnclearedMips());
1490 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id)))
1491 .Times(1)
1492 .RetiresOnSaturation();
1493 texture_ref3 = NULL;
1494 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1495 EXPECT_FALSE(manager_->HaveUnclearedMips());
1496 }
1497
1498 TEST_F(TextureTest, ClearTexture) {
1499 EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _, _))
1500 .WillRepeatedly(Return(true));
1501 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1502 manager_->SetLevelInfo(texture_ref_.get(),
1503 GL_TEXTURE_2D,
1504 0,
1505 GL_RGBA,
1506 4,
1507 4,
1508 1,
1509 0,
1510 GL_RGBA,
1511 GL_UNSIGNED_BYTE,
1512 false);
1513 manager_->SetLevelInfo(texture_ref_.get(),
1514 GL_TEXTURE_2D,
1515 1,
1516 GL_RGBA,
1517 4,
1518 4,
1519 1,
1520 0,
1521 GL_RGBA,
1522 GL_UNSIGNED_BYTE,
1523 false);
1524 Texture* texture = texture_ref_->texture();
1525 EXPECT_FALSE(texture->SafeToRenderFrom());
1526 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1527 EXPECT_TRUE(manager_->HaveUnclearedMips());
1528 EXPECT_EQ(2, texture->num_uncleared_mips());
1529 manager_->ClearRenderableLevels(decoder_.get(), texture_ref_.get());
1530 EXPECT_TRUE(texture->SafeToRenderFrom());
1531 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1532 EXPECT_FALSE(manager_->HaveUnclearedMips());
1533 EXPECT_EQ(0, texture->num_uncleared_mips());
1534 manager_->SetLevelInfo(texture_ref_.get(),
1535 GL_TEXTURE_2D,
1536 0,
1537 GL_RGBA,
1538 4,
1539 4,
1540 1,
1541 0,
1542 GL_RGBA,
1543 GL_UNSIGNED_BYTE,
1544 false);
1545 manager_->SetLevelInfo(texture_ref_.get(),
1546 GL_TEXTURE_2D,
1547 1,
1548 GL_RGBA,
1549 4,
1550 4,
1551 1,
1552 0,
1553 GL_RGBA,
1554 GL_UNSIGNED_BYTE,
1555 false);
1556 EXPECT_FALSE(texture->SafeToRenderFrom());
1557 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1558 EXPECT_TRUE(manager_->HaveUnclearedMips());
1559 EXPECT_EQ(2, texture->num_uncleared_mips());
1560 manager_->ClearTextureLevel(
1561 decoder_.get(), texture_ref_.get(), GL_TEXTURE_2D, 0);
1562 EXPECT_FALSE(texture->SafeToRenderFrom());
1563 EXPECT_TRUE(manager_->HaveUnsafeTextures());
1564 EXPECT_TRUE(manager_->HaveUnclearedMips());
1565 EXPECT_EQ(1, texture->num_uncleared_mips());
1566 manager_->ClearTextureLevel(
1567 decoder_.get(), texture_ref_.get(), GL_TEXTURE_2D, 1);
1568 EXPECT_TRUE(texture->SafeToRenderFrom());
1569 EXPECT_FALSE(manager_->HaveUnsafeTextures());
1570 EXPECT_FALSE(manager_->HaveUnclearedMips());
1571 EXPECT_EQ(0, texture->num_uncleared_mips());
1572 }
1573
1574 TEST_F(TextureTest, UseDeletedTexture) {
1575 static const GLuint kClient2Id = 2;
1576 static const GLuint kService2Id = 12;
1577 // Make the default texture renderable
1578 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1579 manager_->SetLevelInfo(texture_ref_.get(),
1580 GL_TEXTURE_2D,
1581 0,
1582 GL_RGBA,
1583 1,
1584 1,
1585 1,
1586 0,
1587 GL_RGBA,
1588 GL_UNSIGNED_BYTE,
1589 false);
1590 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
1591 // Make a new texture
1592 manager_->CreateTexture(kClient2Id, kService2Id);
1593 scoped_refptr<TextureRef> texture_ref(
1594 manager_->GetTexture(kClient2Id));
1595 manager_->SetTarget(texture_ref.get(), GL_TEXTURE_2D);
1596 EXPECT_FALSE(manager_->CanRender(texture_ref.get()));
1597 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
1598 // Remove it.
1599 manager_->RemoveTexture(kClient2Id);
1600 EXPECT_FALSE(manager_->CanRender(texture_ref.get()));
1601 EXPECT_TRUE(manager_->HaveUnrenderableTextures());
1602 // Check that we can still manipulate it and it effects the manager.
1603 manager_->SetLevelInfo(texture_ref.get(),
1604 GL_TEXTURE_2D,
1605 0,
1606 GL_RGBA,
1607 1,
1608 1,
1609 1,
1610 0,
1611 GL_RGBA,
1612 GL_UNSIGNED_BYTE,
1613 false);
1614 EXPECT_TRUE(manager_->CanRender(texture_ref.get()));
1615 EXPECT_FALSE(manager_->HaveUnrenderableTextures());
1616 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
1617 .Times(1)
1618 .RetiresOnSaturation();
1619 texture_ref = NULL;
1620 }
1621
1622 TEST_F(TextureTest, GetLevelImage) {
1623 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1624 manager_->SetLevelInfo(texture_ref_.get(),
1625 GL_TEXTURE_2D,
1626 1,
1627 GL_RGBA,
1628 2,
1629 2,
1630 1,
1631 0,
1632 GL_RGBA,
1633 GL_UNSIGNED_BYTE,
1634 true);
1635 Texture* texture = texture_ref_->texture();
1636 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
1637 // Set image.
1638 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
1639 manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, image.get());
1640 EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
1641 // Remove it.
1642 manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, NULL);
1643 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
1644 manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, image.get());
1645 // Image should be reset when SetLevelInfo is called.
1646 manager_->SetLevelInfo(texture_ref_.get(),
1647 GL_TEXTURE_2D,
1648 1,
1649 GL_RGBA,
1650 2,
1651 2,
1652 1,
1653 0,
1654 GL_RGBA,
1655 GL_UNSIGNED_BYTE,
1656 true);
1657 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
1658 }
1659
1660 namespace {
1661
1662 bool InSet(std::set<std::string>* string_set, const std::string& str) {
1663 std::pair<std::set<std::string>::iterator, bool> result =
1664 string_set->insert(str);
1665 return !result.second;
1666 }
1667
1668 } // anonymous namespace
1669
1670 TEST_F(TextureTest, AddToSignature) {
1671 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1672 manager_->SetLevelInfo(texture_ref_.get(),
1673 GL_TEXTURE_2D,
1674 1,
1675 GL_RGBA,
1676 2,
1677 2,
1678 1,
1679 0,
1680 GL_RGBA,
1681 GL_UNSIGNED_BYTE,
1682 true);
1683 std::string signature1;
1684 std::string signature2;
1685 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature1);
1686
1687 std::set<std::string> string_set;
1688 EXPECT_FALSE(InSet(&string_set, signature1));
1689
1690 // check changing 1 thing makes a different signature.
1691 manager_->SetLevelInfo(texture_ref_.get(),
1692 GL_TEXTURE_2D,
1693 1,
1694 GL_RGBA,
1695 4,
1696 2,
1697 1,
1698 0,
1699 GL_RGBA,
1700 GL_UNSIGNED_BYTE,
1701 true);
1702 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1703 EXPECT_FALSE(InSet(&string_set, signature2));
1704
1705 // check putting it back makes the same signature.
1706 manager_->SetLevelInfo(texture_ref_.get(),
1707 GL_TEXTURE_2D,
1708 1,
1709 GL_RGBA,
1710 2,
1711 2,
1712 1,
1713 0,
1714 GL_RGBA,
1715 GL_UNSIGNED_BYTE,
1716 true);
1717 signature2.clear();
1718 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1719 EXPECT_EQ(signature1, signature2);
1720
1721 // Check setting cleared status does not change signature.
1722 manager_->SetLevelInfo(texture_ref_.get(),
1723 GL_TEXTURE_2D,
1724 1,
1725 GL_RGBA,
1726 2,
1727 2,
1728 1,
1729 0,
1730 GL_RGBA,
1731 GL_UNSIGNED_BYTE,
1732 false);
1733 signature2.clear();
1734 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1735 EXPECT_EQ(signature1, signature2);
1736
1737 // Check changing other settings changes signature.
1738 manager_->SetLevelInfo(texture_ref_.get(),
1739 GL_TEXTURE_2D,
1740 1,
1741 GL_RGBA,
1742 2,
1743 4,
1744 1,
1745 0,
1746 GL_RGBA,
1747 GL_UNSIGNED_BYTE,
1748 false);
1749 signature2.clear();
1750 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1751 EXPECT_FALSE(InSet(&string_set, signature2));
1752
1753 manager_->SetLevelInfo(texture_ref_.get(),
1754 GL_TEXTURE_2D,
1755 1,
1756 GL_RGBA,
1757 2,
1758 2,
1759 2,
1760 0,
1761 GL_RGBA,
1762 GL_UNSIGNED_BYTE,
1763 false);
1764 signature2.clear();
1765 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1766 EXPECT_FALSE(InSet(&string_set, signature2));
1767
1768 manager_->SetLevelInfo(texture_ref_.get(),
1769 GL_TEXTURE_2D,
1770 1,
1771 GL_RGBA,
1772 2,
1773 2,
1774 1,
1775 1,
1776 GL_RGBA,
1777 GL_UNSIGNED_BYTE,
1778 false);
1779 signature2.clear();
1780 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1781 EXPECT_FALSE(InSet(&string_set, signature2));
1782
1783 manager_->SetLevelInfo(texture_ref_.get(),
1784 GL_TEXTURE_2D,
1785 1,
1786 GL_RGBA,
1787 2,
1788 2,
1789 1,
1790 0,
1791 GL_RGB,
1792 GL_UNSIGNED_BYTE,
1793 false);
1794 signature2.clear();
1795 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1796 EXPECT_FALSE(InSet(&string_set, signature2));
1797
1798 manager_->SetLevelInfo(texture_ref_.get(),
1799 GL_TEXTURE_2D,
1800 1,
1801 GL_RGBA,
1802 2,
1803 2,
1804 1,
1805 0,
1806 GL_RGBA,
1807 GL_FLOAT,
1808 false);
1809 signature2.clear();
1810 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1811 EXPECT_FALSE(InSet(&string_set, signature2));
1812
1813 // put it back
1814 manager_->SetLevelInfo(texture_ref_.get(),
1815 GL_TEXTURE_2D,
1816 1,
1817 GL_RGBA,
1818 2,
1819 2,
1820 1,
1821 0,
1822 GL_RGBA,
1823 GL_UNSIGNED_BYTE,
1824 false);
1825 signature2.clear();
1826 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1827 EXPECT_EQ(signature1, signature2);
1828
1829 // check changing parameters changes signature.
1830 SetParameter(
1831 texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
1832 signature2.clear();
1833 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1834 EXPECT_FALSE(InSet(&string_set, signature2));
1835
1836 SetParameter(texture_ref_.get(),
1837 GL_TEXTURE_MIN_FILTER,
1838 GL_NEAREST_MIPMAP_LINEAR,
1839 GL_NO_ERROR);
1840 SetParameter(
1841 texture_ref_.get(), GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
1842 signature2.clear();
1843 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1844 EXPECT_FALSE(InSet(&string_set, signature2));
1845
1846 SetParameter(
1847 texture_ref_.get(), GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR);
1848 SetParameter(
1849 texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
1850 signature2.clear();
1851 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1852 EXPECT_FALSE(InSet(&string_set, signature2));
1853
1854 SetParameter(texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
1855 SetParameter(
1856 texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
1857 signature2.clear();
1858 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1859 EXPECT_FALSE(InSet(&string_set, signature2));
1860
1861 // Check putting it back genenerates the same signature
1862 SetParameter(texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
1863 signature2.clear();
1864 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2);
1865 EXPECT_EQ(signature1, signature2);
1866
1867 // Check the set was acutally getting different signatures.
1868 EXPECT_EQ(11u, string_set.size());
1869 }
1870
1871 class ProduceConsumeTextureTest : public TextureTest,
1872 public ::testing::WithParamInterface<GLenum> {
1873 public:
1874 virtual void SetUp() {
1875 TextureTest::SetUpBase(NULL, "GL_OES_EGL_image_external");
1876 manager_->CreateTexture(kClient2Id, kService2Id);
1877 texture2_ = manager_->GetTexture(kClient2Id);
1878
1879 EXPECT_CALL(*decoder_.get(), GetErrorState())
1880 .WillRepeatedly(Return(error_state_.get()));
1881 }
1882
1883 virtual void TearDown() {
1884 if (texture2_.get()) {
1885 // If it's not in the manager then setting texture2_ to NULL will
1886 // delete the texture.
1887 if (!texture2_->client_id()) {
1888 // Check that it gets deleted when the last reference is released.
1889 EXPECT_CALL(
1890 *gl_,
1891 DeleteTextures(1, ::testing::Pointee(texture2_->service_id())))
1892 .Times(1).RetiresOnSaturation();
1893 }
1894 texture2_ = NULL;
1895 }
1896 TextureTest::TearDown();
1897 }
1898
1899 protected:
1900 struct LevelInfo {
1901 LevelInfo(GLenum target,
1902 GLenum format,
1903 GLsizei width,
1904 GLsizei height,
1905 GLsizei depth,
1906 GLint border,
1907 GLenum type,
1908 bool cleared)
1909 : target(target),
1910 format(format),
1911 width(width),
1912 height(height),
1913 depth(depth),
1914 border(border),
1915 type(type),
1916 cleared(cleared) {}
1917
1918 LevelInfo()
1919 : target(0),
1920 format(0),
1921 width(-1),
1922 height(-1),
1923 depth(1),
1924 border(0),
1925 type(0),
1926 cleared(false) {}
1927
1928 bool operator==(const LevelInfo& other) const {
1929 return target == other.target && format == other.format &&
1930 width == other.width && height == other.height &&
1931 depth == other.depth && border == other.border &&
1932 type == other.type && cleared == other.cleared;
1933 }
1934
1935 GLenum target;
1936 GLenum format;
1937 GLsizei width;
1938 GLsizei height;
1939 GLsizei depth;
1940 GLint border;
1941 GLenum type;
1942 bool cleared;
1943 };
1944
1945 void SetLevelInfo(TextureRef* texture_ref,
1946 GLint level,
1947 const LevelInfo& info) {
1948 manager_->SetLevelInfo(texture_ref,
1949 info.target,
1950 level,
1951 info.format,
1952 info.width,
1953 info.height,
1954 info.depth,
1955 info.border,
1956 info.format,
1957 info.type,
1958 info.cleared);
1959 }
1960
1961 static LevelInfo GetLevelInfo(const TextureRef* texture_ref,
1962 GLint target,
1963 GLint level) {
1964 const Texture* texture = texture_ref->texture();
1965 LevelInfo info;
1966 info.target = target;
1967 EXPECT_TRUE(texture->GetLevelSize(target, level, &info.width,
1968 &info.height));
1969 EXPECT_TRUE(texture->GetLevelType(target, level, &info.type,
1970 &info.format));
1971 info.cleared = texture->IsLevelCleared(target, level);
1972 return info;
1973 }
1974
1975 Texture* Produce(TextureRef* texture_ref) {
1976 Texture* texture = manager_->Produce(texture_ref);
1977 EXPECT_TRUE(texture != NULL);
1978 return texture;
1979 }
1980
1981 void Consume(GLuint client_id, Texture* texture) {
1982 EXPECT_TRUE(manager_->Consume(client_id, texture));
1983 }
1984
1985 scoped_refptr<TextureRef> texture2_;
1986
1987 private:
1988 static const GLuint kClient2Id;
1989 static const GLuint kService2Id;
1990 };
1991
1992 const GLuint ProduceConsumeTextureTest::kClient2Id = 2;
1993 const GLuint ProduceConsumeTextureTest::kService2Id = 12;
1994
1995 TEST_F(ProduceConsumeTextureTest, ProduceConsume2D) {
1996 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D);
1997 Texture* texture = texture_ref_->texture();
1998 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
1999 LevelInfo level0(
2000 GL_TEXTURE_2D, GL_RGBA, 4, 4, 1, 0, GL_UNSIGNED_BYTE, true);
2001 SetLevelInfo(texture_ref_.get(), 0, level0);
2002 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get()));
2003 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
2004 LevelInfo level1 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1);
2005 LevelInfo level2 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2);
2006 Texture* produced_texture = Produce(texture_ref_.get());
2007 EXPECT_EQ(produced_texture, texture);
2008
2009 // Make this texture bigger with more levels, and make sure they get
2010 // clobbered correctly during Consume().
2011 manager_->SetTarget(texture2_.get(), GL_TEXTURE_2D);
2012 SetLevelInfo(
2013 texture2_.get(),
2014 0,
2015 LevelInfo(GL_TEXTURE_2D, GL_RGBA, 16, 16, 1, 0, GL_UNSIGNED_BYTE, false));
2016 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture2_.get()));
2017 texture = texture2_->texture();
2018 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
2019 EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture->estimated_size());
2020
2021 GLuint client_id = texture2_->client_id();
2022 manager_->RemoveTexture(client_id);
2023 Consume(client_id, produced_texture);
2024 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
2025 EXPECT_EQ(produced_texture, restored_texture->texture());
2026 EXPECT_EQ(level0, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 0));
2027 EXPECT_EQ(level1, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 1));
2028 EXPECT_EQ(level2, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 2));
2029 texture = restored_texture->texture();
2030 EXPECT_EQ(64U + 16U + 4U, texture->estimated_size());
2031 GLint w, h;
2032 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h));
2033
2034 // However the old texture ref still exists if it was referenced somewhere.
2035 EXPECT_EQ(1024U + 256U + 64U + 16U + 4U,
2036 texture2_->texture()->estimated_size());
2037 }
2038
2039 TEST_F(ProduceConsumeTextureTest, ProduceConsumeClearRectangle) {
2040 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_RECTANGLE_ARB);
2041 Texture* texture = texture_ref_->texture();
2042 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), texture->target());
2043 LevelInfo level0(
2044 GL_TEXTURE_RECTANGLE_ARB, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false);
2045 SetLevelInfo(texture_ref_.get(), 0, level0);
2046 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
2047 Texture* produced_texture = Produce(texture_ref_.get());
2048 EXPECT_EQ(produced_texture, texture);
2049 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB),
2050 produced_texture->target());
2051
2052 GLuint client_id = texture2_->client_id();
2053 manager_->RemoveTexture(client_id);
2054 Consume(client_id, produced_texture);
2055 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
2056 EXPECT_EQ(produced_texture, restored_texture->texture());
2057
2058 // See if we can clear the previously uncleared level now.
2059 EXPECT_EQ(level0,
2060 GetLevelInfo(restored_texture.get(), GL_TEXTURE_RECTANGLE_ARB, 0));
2061 EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _, _))
2062 .WillRepeatedly(Return(true));
2063 EXPECT_TRUE(manager_->ClearTextureLevel(
2064 decoder_.get(), restored_texture.get(), GL_TEXTURE_RECTANGLE_ARB, 0));
2065 }
2066
2067 TEST_F(ProduceConsumeTextureTest, ProduceConsumeExternal) {
2068 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES);
2069 Texture* texture = texture_ref_->texture();
2070 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
2071 LevelInfo level0(
2072 GL_TEXTURE_EXTERNAL_OES, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false);
2073 SetLevelInfo(texture_ref_.get(), 0, level0);
2074 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
2075 Texture* produced_texture = Produce(texture_ref_.get());
2076 EXPECT_EQ(produced_texture, texture);
2077
2078 GLuint client_id = texture2_->client_id();
2079 manager_->RemoveTexture(client_id);
2080 Consume(client_id, produced_texture);
2081 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
2082 EXPECT_EQ(produced_texture, restored_texture->texture());
2083 EXPECT_EQ(level0,
2084 GetLevelInfo(restored_texture.get(), GL_TEXTURE_EXTERNAL_OES, 0));
2085 }
2086
2087 TEST_P(ProduceConsumeTextureTest, ProduceConsumeTextureWithImage) {
2088 GLenum target = GetParam();
2089 manager_->SetTarget(texture_ref_.get(), target);
2090 Texture* texture = texture_ref_->texture();
2091 EXPECT_EQ(static_cast<GLenum>(target), texture->target());
2092 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
2093 manager_->SetLevelInfo(texture_ref_.get(),
2094 target,
2095 0,
2096 GL_RGBA,
2097 0,
2098 0,
2099 1,
2100 0,
2101 GL_RGBA,
2102 GL_UNSIGNED_BYTE,
2103 true);
2104 manager_->SetLevelImage(texture_ref_.get(), target, 0, image.get());
2105 GLuint service_id = texture->service_id();
2106 Texture* produced_texture = Produce(texture_ref_.get());
2107
2108 GLuint client_id = texture2_->client_id();
2109 manager_->RemoveTexture(client_id);
2110 Consume(client_id, produced_texture);
2111 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
2112 EXPECT_EQ(produced_texture, restored_texture->texture());
2113 EXPECT_EQ(service_id, restored_texture->service_id());
2114 EXPECT_EQ(image.get(), restored_texture->texture()->GetLevelImage(target, 0));
2115 }
2116
2117 static const GLenum kTextureTargets[] = {GL_TEXTURE_2D, GL_TEXTURE_EXTERNAL_OES,
2118 GL_TEXTURE_RECTANGLE_ARB, };
2119
2120 INSTANTIATE_TEST_CASE_P(Target,
2121 ProduceConsumeTextureTest,
2122 ::testing::ValuesIn(kTextureTargets));
2123
2124 TEST_F(ProduceConsumeTextureTest, ProduceConsumeCube) {
2125 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_CUBE_MAP);
2126 Texture* texture = texture_ref_->texture();
2127 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
2128 LevelInfo face0(GL_TEXTURE_CUBE_MAP_POSITIVE_X,
2129 GL_RGBA,
2130 1,
2131 1,
2132 1,
2133 0,
2134 GL_UNSIGNED_BYTE,
2135 true);
2136 LevelInfo face5(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
2137 GL_RGBA,
2138 3,
2139 3,
2140 1,
2141 0,
2142 GL_UNSIGNED_BYTE,
2143 true);
2144 SetLevelInfo(texture_ref_.get(), 0, face0);
2145 SetLevelInfo(texture_ref_.get(), 0, face5);
2146 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
2147 Texture* produced_texture = Produce(texture_ref_.get());
2148 EXPECT_EQ(produced_texture, texture);
2149
2150 GLuint client_id = texture2_->client_id();
2151 manager_->RemoveTexture(client_id);
2152 Consume(client_id, produced_texture);
2153 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
2154 EXPECT_EQ(produced_texture, restored_texture->texture());
2155 EXPECT_EQ(
2156 face0,
2157 GetLevelInfo(restored_texture.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0));
2158 EXPECT_EQ(
2159 face5,
2160 GetLevelInfo(restored_texture.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0));
2161 }
2162
2163 class CountingMemoryTracker : public MemoryTracker {
2164 public:
2165 CountingMemoryTracker() {
2166 current_size_[0] = 0;
2167 current_size_[1] = 0;
2168 }
2169
2170 virtual void TrackMemoryAllocatedChange(size_t old_size,
2171 size_t new_size,
2172 Pool pool) OVERRIDE {
2173 DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
2174 current_size_[pool] += new_size - old_size;
2175 }
2176
2177 virtual bool EnsureGPUMemoryAvailable(size_t size_needed) OVERRIDE {
2178 return true;
2179 }
2180
2181 size_t GetSize(Pool pool) {
2182 DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
2183 return current_size_[pool];
2184 }
2185
2186 private:
2187 virtual ~CountingMemoryTracker() {}
2188
2189 size_t current_size_[2];
2190 DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker);
2191 };
2192
2193 class SharedTextureTest : public GpuServiceTest {
2194 public:
2195 static const bool kUseDefaultTextures = false;
2196
2197 SharedTextureTest() : feature_info_(new FeatureInfo()) {}
2198
2199 virtual ~SharedTextureTest() {
2200 }
2201
2202 virtual void SetUp() {
2203 GpuServiceTest::SetUp();
2204 memory_tracker1_ = new CountingMemoryTracker;
2205 texture_manager1_.reset(
2206 new TextureManager(memory_tracker1_.get(),
2207 feature_info_.get(),
2208 TextureManagerTest::kMaxTextureSize,
2209 TextureManagerTest::kMaxCubeMapTextureSize,
2210 kUseDefaultTextures));
2211 memory_tracker2_ = new CountingMemoryTracker;
2212 texture_manager2_.reset(
2213 new TextureManager(memory_tracker2_.get(),
2214 feature_info_.get(),
2215 TextureManagerTest::kMaxTextureSize,
2216 TextureManagerTest::kMaxCubeMapTextureSize,
2217 kUseDefaultTextures));
2218 TestHelper::SetupTextureManagerInitExpectations(
2219 gl_.get(), "", kUseDefaultTextures);
2220 texture_manager1_->Initialize();
2221 TestHelper::SetupTextureManagerInitExpectations(
2222 gl_.get(), "", kUseDefaultTextures);
2223 texture_manager2_->Initialize();
2224 }
2225
2226 virtual void TearDown() {
2227 texture_manager2_->Destroy(false);
2228 texture_manager2_.reset();
2229 texture_manager1_->Destroy(false);
2230 texture_manager1_.reset();
2231 GpuServiceTest::TearDown();
2232 }
2233
2234 protected:
2235 scoped_refptr<FeatureInfo> feature_info_;
2236 scoped_refptr<CountingMemoryTracker> memory_tracker1_;
2237 scoped_ptr<TextureManager> texture_manager1_;
2238 scoped_refptr<CountingMemoryTracker> memory_tracker2_;
2239 scoped_ptr<TextureManager> texture_manager2_;
2240 };
2241
2242 TEST_F(SharedTextureTest, DeleteTextures) {
2243 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
2244 scoped_refptr<TextureRef> ref2 =
2245 texture_manager2_->Consume(20, ref1->texture());
2246 EXPECT_CALL(*gl_, DeleteTextures(1, _))
2247 .Times(0);
2248 ref1 = NULL;
2249 texture_manager1_->RemoveTexture(10);
2250 testing::Mock::VerifyAndClearExpectations(gl_.get());
2251
2252 EXPECT_CALL(*gl_, DeleteTextures(1, _))
2253 .Times(1)
2254 .RetiresOnSaturation();
2255 ref2 = NULL;
2256 texture_manager2_->RemoveTexture(20);
2257 testing::Mock::VerifyAndClearExpectations(gl_.get());
2258 }
2259
2260 TEST_F(SharedTextureTest, TextureSafetyAccounting) {
2261 EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
2262 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
2263 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
2264 EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
2265 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
2266 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
2267
2268 // Newly created texture is renderable.
2269 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
2270 EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
2271 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
2272 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
2273
2274 // Associate new texture ref to other texture manager, should account for it
2275 // too.
2276 scoped_refptr<TextureRef> ref2 =
2277 texture_manager2_->Consume(20, ref1->texture());
2278 EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
2279 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
2280 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
2281
2282 // Make texture renderable but uncleared on one texture manager, should affect
2283 // other one.
2284 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
2285 EXPECT_TRUE(texture_manager1_->HaveUnrenderableTextures());
2286 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
2287 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
2288 EXPECT_TRUE(texture_manager2_->HaveUnrenderableTextures());
2289 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
2290 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
2291
2292 texture_manager1_->SetLevelInfo(ref1.get(),
2293 GL_TEXTURE_2D,
2294 0,
2295 GL_RGBA,
2296 1,
2297 1,
2298 1,
2299 0,
2300 GL_RGBA,
2301 GL_UNSIGNED_BYTE,
2302 false);
2303 EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
2304 EXPECT_TRUE(texture_manager1_->HaveUnsafeTextures());
2305 EXPECT_TRUE(texture_manager1_->HaveUnclearedMips());
2306 EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
2307 EXPECT_TRUE(texture_manager2_->HaveUnsafeTextures());
2308 EXPECT_TRUE(texture_manager2_->HaveUnclearedMips());
2309
2310 // Make texture cleared on one texture manager, should affect other one.
2311 texture_manager1_->SetLevelCleared(ref1.get(), GL_TEXTURE_2D, 0, true);
2312 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
2313 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
2314 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
2315 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
2316
2317 EXPECT_CALL(*gl_, DeleteTextures(1, _))
2318 .Times(1)
2319 .RetiresOnSaturation();
2320 texture_manager1_->RemoveTexture(10);
2321 texture_manager2_->RemoveTexture(20);
2322 }
2323
2324 TEST_F(SharedTextureTest, FBOCompletenessCheck) {
2325 const GLenum kCompleteValue = GL_FRAMEBUFFER_COMPLETE;
2326 FramebufferManager framebuffer_manager1(1, 1);
2327 texture_manager1_->set_framebuffer_manager(&framebuffer_manager1);
2328 FramebufferManager framebuffer_manager2(1, 1);
2329 texture_manager2_->set_framebuffer_manager(&framebuffer_manager2);
2330
2331 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
2332 framebuffer_manager1.CreateFramebuffer(10, 10);
2333 scoped_refptr<Framebuffer> framebuffer1 =
2334 framebuffer_manager1.GetFramebuffer(10);
2335 framebuffer1->AttachTexture(
2336 GL_COLOR_ATTACHMENT0, ref1.get(), GL_TEXTURE_2D, 0, 0);
2337 EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1.get()));
2338 EXPECT_NE(kCompleteValue, framebuffer1->IsPossiblyComplete());
2339
2340 // Make FBO complete in manager 1.
2341 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
2342 texture_manager1_->SetLevelInfo(ref1.get(),
2343 GL_TEXTURE_2D,
2344 0,
2345 GL_RGBA,
2346 1,
2347 1,
2348 1,
2349 0,
2350 GL_RGBA,
2351 GL_UNSIGNED_BYTE,
2352 true);
2353 EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
2354 framebuffer_manager1.MarkAsComplete(framebuffer1.get());
2355 EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1.get()));
2356
2357 // Share texture with manager 2.
2358 scoped_refptr<TextureRef> ref2 =
2359 texture_manager2_->Consume(20, ref1->texture());
2360 framebuffer_manager2.CreateFramebuffer(20, 20);
2361 scoped_refptr<Framebuffer> framebuffer2 =
2362 framebuffer_manager2.GetFramebuffer(20);
2363 framebuffer2->AttachTexture(
2364 GL_COLOR_ATTACHMENT0, ref2.get(), GL_TEXTURE_2D, 0, 0);
2365 EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2.get()));
2366 EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
2367 framebuffer_manager2.MarkAsComplete(framebuffer2.get());
2368 EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2.get()));
2369
2370 // Change level for texture, both FBOs should be marked incomplete
2371 texture_manager1_->SetLevelInfo(ref1.get(),
2372 GL_TEXTURE_2D,
2373 0,
2374 GL_RGBA,
2375 1,
2376 1,
2377 1,
2378 0,
2379 GL_RGBA,
2380 GL_UNSIGNED_BYTE,
2381 true);
2382 EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1.get()));
2383 EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
2384 framebuffer_manager1.MarkAsComplete(framebuffer1.get());
2385 EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1.get()));
2386 EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2.get()));
2387 EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
2388 framebuffer_manager2.MarkAsComplete(framebuffer2.get());
2389 EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2.get()));
2390
2391 EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _))
2392 .Times(2)
2393 .RetiresOnSaturation();
2394 framebuffer_manager1.RemoveFramebuffer(10);
2395 framebuffer_manager2.RemoveFramebuffer(20);
2396 EXPECT_CALL(*gl_, DeleteTextures(1, _))
2397 .Times(1)
2398 .RetiresOnSaturation();
2399 texture_manager1_->RemoveTexture(10);
2400 texture_manager2_->RemoveTexture(20);
2401 }
2402
2403 TEST_F(SharedTextureTest, Memory) {
2404 size_t initial_memory1 = memory_tracker1_->GetSize(MemoryTracker::kUnmanaged);
2405 size_t initial_memory2 = memory_tracker2_->GetSize(MemoryTracker::kUnmanaged);
2406
2407 // Newly created texture is unrenderable.
2408 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
2409 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
2410 texture_manager1_->SetLevelInfo(ref1.get(),
2411 GL_TEXTURE_2D,
2412 0,
2413 GL_RGBA,
2414 10,
2415 10,
2416 1,
2417 0,
2418 GL_RGBA,
2419 GL_UNSIGNED_BYTE,
2420 false);
2421
2422 EXPECT_LT(0u, ref1->texture()->estimated_size());
2423 EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
2424 memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
2425
2426 // Associate new texture ref to other texture manager, it doesn't account for
2427 // the texture memory, the first memory tracker still has it.
2428 scoped_refptr<TextureRef> ref2 =
2429 texture_manager2_->Consume(20, ref1->texture());
2430 EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
2431 memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
2432 EXPECT_EQ(initial_memory2,
2433 memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
2434
2435 // Delete the texture, memory should go to the remaining tracker.
2436 texture_manager1_->RemoveTexture(10);
2437 ref1 = NULL;
2438 EXPECT_EQ(initial_memory1,
2439 memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
2440 EXPECT_EQ(initial_memory2 + ref2->texture()->estimated_size(),
2441 memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
2442
2443 EXPECT_CALL(*gl_, DeleteTextures(1, _))
2444 .Times(1)
2445 .RetiresOnSaturation();
2446 ref2 = NULL;
2447 texture_manager2_->RemoveTexture(20);
2448 EXPECT_EQ(initial_memory2,
2449 memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
2450 }
2451
2452 TEST_F(SharedTextureTest, Images) {
2453 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
2454 scoped_refptr<TextureRef> ref2 =
2455 texture_manager2_->Consume(20, ref1->texture());
2456
2457 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D);
2458 texture_manager1_->SetLevelInfo(ref1.get(),
2459 GL_TEXTURE_2D,
2460 1,
2461 GL_RGBA,
2462 2,
2463 2,
2464 1,
2465 0,
2466 GL_RGBA,
2467 GL_UNSIGNED_BYTE,
2468 true);
2469 EXPECT_FALSE(ref1->texture()->HasImages());
2470 EXPECT_FALSE(ref2->texture()->HasImages());
2471 EXPECT_FALSE(texture_manager1_->HaveImages());
2472 EXPECT_FALSE(texture_manager2_->HaveImages());
2473 scoped_refptr<gfx::GLImage> image1(new gfx::GLImageStub);
2474 texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image1.get());
2475 EXPECT_TRUE(ref1->texture()->HasImages());
2476 EXPECT_TRUE(ref2->texture()->HasImages());
2477 EXPECT_TRUE(texture_manager1_->HaveImages());
2478 EXPECT_TRUE(texture_manager2_->HaveImages());
2479 scoped_refptr<gfx::GLImage> image2(new gfx::GLImageStub);
2480 texture_manager1_->SetLevelImage(ref1.get(), GL_TEXTURE_2D, 1, image2.get());
2481 EXPECT_TRUE(ref1->texture()->HasImages());
2482 EXPECT_TRUE(ref2->texture()->HasImages());
2483 EXPECT_TRUE(texture_manager1_->HaveImages());
2484 EXPECT_TRUE(texture_manager2_->HaveImages());
2485 texture_manager1_->SetLevelInfo(ref1.get(),
2486 GL_TEXTURE_2D,
2487 1,
2488 GL_RGBA,
2489 2,
2490 2,
2491 1,
2492 0,
2493 GL_RGBA,
2494 GL_UNSIGNED_BYTE,
2495 true);
2496 EXPECT_FALSE(ref1->texture()->HasImages());
2497 EXPECT_FALSE(ref2->texture()->HasImages());
2498 EXPECT_FALSE(texture_manager1_->HaveImages());
2499 EXPECT_FALSE(texture_manager1_->HaveImages());
2500
2501 EXPECT_CALL(*gl_, DeleteTextures(1, _))
2502 .Times(1)
2503 .RetiresOnSaturation();
2504 texture_manager1_->RemoveTexture(10);
2505 texture_manager2_->RemoveTexture(20);
2506 }
2507
2508 } // namespace gles2
2509 } // namespace gpu