Ping watchdog thread during GpuChannel destruction

gpu/command_buffer/service/texture_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_stream_texture_image.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/mocks.h"
+#include "gpu/command_buffer/service/progress_reporter_stub.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_image_stub.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/gl_switches.h"
 
 using ::testing::AtLeast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SetArgPointee;
@@ skipping 40 matching lines @@
     command_line.AppendSwitch(switches::kEnableUnsafeES3APIs);
     GpuDriverBugWorkarounds gpu_driver_bug_workaround(&command_line);
     feature_info_ = new FeatureInfo(command_line, gpu_driver_bug_workaround);
   }
 
   ~TextureManagerTest() override {}
 
  protected:
   void SetUp() override {
     GpuServiceTest::SetUp();
-    manager_.reset(new TextureManager(NULL,
-                                      feature_info_.get(),
-                                      kMaxTextureSize,
-                                      kMaxCubeMapTextureSize,
-                                      kMaxRectangleTextureSize,
-                                      kMax3DTextureSize,
-                                      kMaxArrayTextureLayers,
-                                      kUseDefaultTextures));
+    manager_.reset(new TextureManager(
+        NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize,
+        kMaxRectangleTextureSize, kMax3DTextureSize, kMaxArrayTextureLayers,
+        kUseDefaultTextures, &progress_reporter_));
     SetupFeatureInfo("", "OpenGL ES 2.0", false);
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), false, false, false, "", kUseDefaultTextures);
     manager_->Initialize();
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
   }
 
   void TearDown() override {
     manager_->Destroy(false);
     manager_.reset();
@@ skipping 21 matching lines @@
       EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_DRAW_BUFFERS, _))
           .WillOnce(SetArgPointee<1>(8))
           .RetiresOnSaturation();
       feature_info_->EnableES3Validators();
     }
   }
 
   scoped_refptr<FeatureInfo> feature_info_;
   std::unique_ptr<TextureManager> manager_;
   std::unique_ptr<MockErrorState> error_state_;
+  ProgressReporterStub progress_reporter_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const GLint TextureManagerTest::kMaxTextureSize;
 const GLint TextureManagerTest::kMaxCubeMapTextureSize;
 const GLint TextureManagerTest::kMaxRectangleTextureSize;
 const GLint TextureManagerTest::kMaxExternalTextureSize;
 const GLint TextureManagerTest::kMax3DTextureSize;
 const GLint TextureManagerTest::kMaxArrayTextureLayers;
@@ skipping 98 matching lines @@
   EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
   SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE);
   SetParameter(texture_ref, GL_TEXTURE_IMMUTABLE_FORMAT, 0, GL_INVALID_ENUM);
   SetParameter(texture_ref, GL_TEXTURE_IMMUTABLE_LEVELS, 0, GL_INVALID_ENUM);
 }
 
 TEST_F(TextureManagerTest, UseDefaultTexturesTrue) {
   bool use_default_textures = true;
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
       false, false, false, "GL_ANGLE_texture_usage", use_default_textures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         use_default_textures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         use_default_textures, &progress_reporter_);
   manager.Initialize();
 
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) != NULL);
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) != NULL);
 
   // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB.
 
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, UseDefaultTexturesFalse) {
   bool use_default_textures = false;
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
       false, false, false, "GL_ANGLE_texture_usage", use_default_textures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         use_default_textures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         use_default_textures, &progress_reporter_);
   manager.Initialize();
 
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) == NULL);
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) == NULL);
 
   // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB.
 
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, UseDefaultTexturesTrueES3) {
   bool use_default_textures = true;
   SetupFeatureInfo("", "OpenGL ES 3.0", true);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
       true, true, false, "", use_default_textures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         use_default_textures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         use_default_textures, &progress_reporter_);
   manager.Initialize();
 
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_3D) != NULL);
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D_ARRAY) != NULL);
 
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, UseDefaultTexturesFalseES3) {
   bool use_default_textures = false;
   SetupFeatureInfo("", "OpenGL ES 3.0", true);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
       true, true, false, "", use_default_textures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         use_default_textures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         use_default_textures, &progress_reporter_);
   manager.Initialize();
 
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_3D) == NULL);
   EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D_ARRAY) == NULL);
 
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, TextureUsageExt) {
   TestHelper::SetupTextureManagerInitExpectations(
       gl_.get(), false, false, false, "GL_ANGLE_texture_usage",
       kUseDefaultTextures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.Initialize();
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create texture.
   manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE, GL_NO_ERROR);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE),
             texture_ref->texture()->usage());
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, Destroy) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   TestHelper::SetupTextureManagerInitExpectations(
       gl_.get(), false, false, false, "", kUseDefaultTextures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.Initialize();
   // Check we can create texture.
   manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
   TextureRef* texture = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture != NULL);
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
   TestHelper::SetupTextureManagerDestructionExpectations(
@@ skipping 131 matching lines @@
         (kMaxCubeMapTextureSize >> level) * 2,
         1));
   }
 }
 
 TEST_F(TextureManagerTest, ValidForTargetNPOT) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   // Check NPOT width on level 0
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1));
   // Check NPOT height on level 0
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1));
   // Check NPOT width on level 1
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1));
   // Check NPOT height on level 1
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1));
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, AlphaLuminanceCompatibilityProfile) {
   const GLuint kClientId = 1;
   const GLuint kServiceId = 11;
 
   SetupFeatureInfo("", "2.1", false);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(), false, false,
       false, "", kUseDefaultTextures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.Initialize();
 
   // Create a texture.
   manager.CreateTexture(kClientId, kServiceId);
   scoped_refptr<TextureRef> texture_ref(manager.GetTexture(kClientId));
   manager.SetTarget(texture_ref.get(), GL_TEXTURE_2D);
 
   Texture* texture = texture_ref->texture();
 
   // GL_ALPHA emulation
@@ skipping 17 matching lines @@
   manager.RemoveTexture(kClientId);
 }
 
 TEST_F(TextureManagerTest, AlphaLuminanceCoreProfileEmulation) {
   const GLuint kClientId = 1;
   const GLuint kServiceId = 11;
 
   SetupFeatureInfo("", "4.2", true);
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(), true, true, true,
       "", kUseDefaultTextures);
-  TextureManager manager(NULL,
-                         feature_info_.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info_.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.Initialize();
 
   // Create a texture.
   manager.CreateTexture(kClientId, kServiceId);
   scoped_refptr<TextureRef> texture_ref(manager.GetTexture(kClientId));
   manager.SetTarget(texture_ref.get(), GL_TEXTURE_2D);
 
   Texture* texture = texture_ref->texture();
 
   // GL_ALPHA emulation
@@ skipping 91 matching lines @@
   }
   ~TextureTestBase() override { texture_ref_ = NULL; }
 
  protected:
   void SetUpBase(MemoryTracker* memory_tracker, const std::string& extensions) {
     GpuServiceTest::SetUp();
     TestHelper::SetupFeatureInfoInitExpectations(gl_.get(),
                                                  extensions.c_str());
     feature_info_->InitializeForTesting();
 
-    manager_.reset(new TextureManager(memory_tracker,
-                                      feature_info_.get(),
-                                      kMaxTextureSize,
-                                      kMaxCubeMapTextureSize,
-                                      kMaxRectangleTextureSize,
-                                      kMax3DTextureSize,
-                                      kMaxArrayTextureLayers,
-                                      kUseDefaultTextures));
+    manager_.reset(new TextureManager(
+        memory_tracker, feature_info_.get(), kMaxTextureSize,
+        kMaxCubeMapTextureSize, kMaxRectangleTextureSize, kMax3DTextureSize,
+        kMaxArrayTextureLayers, kUseDefaultTextures, &progress_reporter_));
     decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
     manager_->CreateTexture(kClient1Id, kService1Id);
     texture_ref_ = manager_->GetTexture(kClient1Id);
     ASSERT_TRUE(texture_ref_.get() != NULL);
   }
 
   void TearDown() override {
     if (texture_ref_.get()) {
       // If it's not in the manager then setting texture_ref_ to NULL will
@@ skipping 17 matching lines @@
     TestHelper::SetTexParameteriWithExpectations(
         gl_.get(), error_state_.get(), manager_.get(),
         texture_ref, pname, value, error);
   }
 
   std::unique_ptr<MockGLES2Decoder> decoder_;
   std::unique_ptr<MockErrorState> error_state_;
   scoped_refptr<FeatureInfo> feature_info_;
   std::unique_ptr<TextureManager> manager_;
   scoped_refptr<TextureRef> texture_ref_;
+  ProgressReporterStub progress_reporter_;
 };
 
 class TextureTest : public TextureTestBase {
  protected:
   void SetUp() override { SetUpBase(NULL, std::string()); }
 };
 
 class TextureMemoryTrackerTest : public TextureTestBase {
  protected:
   void SetUp() override {
@@ skipping 241 matching lines @@
   EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
 }
 
 TEST_F(TextureTest, NPOT2DNPOTOK) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
 
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to NPOT
   manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0,
                        GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(4, 5));
@@ skipping 274 matching lines @@
   EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 1, 1, 1, 2, 3, 4));
   manager_->RemoveTexture(kClient1Id);
   EXPECT_TRUE(texture->ValidForTexture(GL_TEXTURE_2D, 1, 0, 0, 0, 4, 5, 6));
 }
 
 TEST_F(TextureTest, FloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
                        GL_RGBA, GL_FLOAT, gfx::Rect(1, 1));
   EXPECT_FALSE(manager.CanRender(texture_ref));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager,
       texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(manager.CanRender(texture_ref));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(manager.CanRender(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, FloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
                        GL_RGBA, GL_FLOAT, gfx::Rect(1, 1));
   EXPECT_TRUE(manager.CanRender(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, HalfFloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
                        GL_RGBA, GL_HALF_FLOAT_OES, gfx::Rect(1, 1));
   EXPECT_FALSE(manager.CanRender(texture_ref));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager,
       texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(manager.CanRender(texture_ref));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(manager.CanRender(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, HalfFloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
                        GL_RGBA, GL_HALF_FLOAT_OES, gfx::Rect(1, 1));
   EXPECT_TRUE(manager.CanRender(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, EGLImageExternal) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_EGL_image_external");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
   EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, DepthTexture) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_ANGLE_depth_texture");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->InitializeForTesting();
-  TextureManager manager(NULL,
-                         feature_info.get(),
-                         kMaxTextureSize,
-                         kMaxCubeMapTextureSize,
-                         kMaxRectangleTextureSize,
-                         kMax3DTextureSize,
-                         kMaxArrayTextureLayers,
-                         kUseDefaultTextures);
+  TextureManager manager(NULL, feature_info.get(), kMaxTextureSize,
+                         kMaxCubeMapTextureSize, kMaxRectangleTextureSize,
+                         kMax3DTextureSize, kMaxArrayTextureLayers,
+                         kUseDefaultTextures, &progress_reporter_);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   manager.SetLevelInfo(texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4,
                        1, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, gfx::Rect());
   EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
   manager.Destroy(false);
 }
 
@@ skipping 749 matching lines @@
   static const bool kUseDefaultTextures = false;
 
   SharedTextureTest() : feature_info_(new FeatureInfo()) {}
 
   ~SharedTextureTest() override {}
 
   void SetUp() override {
     GpuServiceTest::SetUp();
     memory_tracker1_ = new CountingMemoryTracker;
     texture_manager1_.reset(
-        new TextureManager(memory_tracker1_.get(),
-                           feature_info_.get(),
+        new TextureManager(memory_tracker1_.get(), feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
                            TextureManagerTest::kMaxCubeMapTextureSize,
                            TextureManagerTest::kMaxRectangleTextureSize,
                            TextureManagerTest::kMax3DTextureSize,
                            TextureManagerTest::kMaxArrayTextureLayers,
-                           kUseDefaultTextures));
+                           kUseDefaultTextures, &progress_reporter_));
     memory_tracker2_ = new CountingMemoryTracker;
     texture_manager2_.reset(
-        new TextureManager(memory_tracker2_.get(),
-                           feature_info_.get(),
+        new TextureManager(memory_tracker2_.get(), feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
                            TextureManagerTest::kMaxCubeMapTextureSize,
                            TextureManagerTest::kMaxRectangleTextureSize,
                            TextureManagerTest::kMax3DTextureSize,
                            TextureManagerTest::kMaxArrayTextureLayers,
-                           kUseDefaultTextures));
+                           kUseDefaultTextures, &progress_reporter_));
     SetupFeatureInfo("", "OpenGL ES 2.0", false);
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), false, false, false, "", kUseDefaultTextures);
     texture_manager1_->Initialize();
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), false, false, false, "", kUseDefaultTextures);
     texture_manager2_->Initialize();
   }
 
   void TearDown() override {
@@ skipping 21 matching lines @@
           .RetiresOnSaturation();
       feature_info_->EnableES3Validators();
     }
   }
 
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_refptr<CountingMemoryTracker> memory_tracker1_;
   std::unique_ptr<TextureManager> texture_manager1_;
   scoped_refptr<CountingMemoryTracker> memory_tracker2_;
   std::unique_ptr<TextureManager> texture_manager2_;
+  ProgressReporterStub progress_reporter_;
 };
 
 TEST_F(SharedTextureTest, DeleteTextures) {
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   scoped_refptr<TextureRef> ref2 =
       texture_manager2_->Consume(20, ref1->texture());
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(0);
   ref1 = NULL;
   texture_manager1_->RemoveTexture(10);
@@ skipping 462 matching lines @@
   ExpectValid(
       true, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH24_STENCIL8);
   ExpectValid(true, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
               GL_DEPTH32F_STENCIL8);
 
   ExpectInvalid(true, GL_RGB_INTEGER, GL_INT, GL_RGBA8);
 }
 
 }  // namespace gles2
 }  // namespace gpu