src/gpu/command_buffer/service/texture_manager_unittest.cc

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