Ping watchdog thread during GpuChannel destruction

gpu/command_buffer/service/program_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/program_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mocks.h"
+#include "gpu/command_buffer/service/progress_reporter_stub.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/gl_version_info.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
@@ skipping 18 matching lines @@
 uint32_t ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8_t*>(position) -
          static_cast<const uint8_t*>(start);
 }
 
 }  // namespace anonymous
 
 class ProgramManagerTestBase : public GpuServiceTest {
  protected:
   virtual void SetupProgramManager() {
-    manager_.reset(new ProgramManager(nullptr, kMaxVaryingVectors,
-                                      kMaxDrawBuffers,
-                                      kMaxDualSourceDrawBuffers,
-                                      kMaxVertexAttribs,
-                                      gpu_preferences_,
-                                      feature_info_.get()));
+    manager_.reset(new ProgramManager(
+        nullptr, kMaxVaryingVectors, kMaxDrawBuffers, kMaxDualSourceDrawBuffers,
+        kMaxVertexAttribs, gpu_preferences_, feature_info_.get(),
+        &progress_reporter_));
   }
   void SetUpBase(const char* gl_version,
                  const char* gl_extensions,
                  FeatureInfo* feature_info = nullptr) {
     GpuServiceTest::SetUpWithGLVersion(gl_version, gl_extensions);
     if (!feature_info)
       feature_info = new FeatureInfo();
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), gl_extensions, "", gl_version, feature_info->context_type());
     feature_info->InitializeForTesting();
     feature_info_ = feature_info;
     SetupProgramManager();
   }
   void SetUp() override {
     // Parameters same as GpuServiceTest::SetUp
     SetUpBase("2.0", "GL_EXT_framebuffer_object");
   }
   void TearDown() override {
     manager_->Destroy(false);
     manager_.reset();
     feature_info_ = nullptr;
     GpuServiceTest::TearDown();
   }
 
   std::unique_ptr<ProgramManager> manager_;
   GpuPreferences gpu_preferences_;
   scoped_refptr<FeatureInfo> feature_info_;
+  ProgressReporterStub progress_reporter_;
 };
 
 class ProgramManagerTest : public ProgramManagerTestBase {};
 
 TEST_F(ProgramManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   // Check we can create program.
   manager_->CreateProgram(kClient1Id, kService1Id);
@@ skipping 19 matching lines @@
   EXPECT_CALL(*gl_, DeleteProgram(kService1Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_->Destroy(true);
   // Check the resources were released.
   program1 = manager_->GetProgram(kClient1Id);
   ASSERT_TRUE(program1 == NULL);
 }
 
 TEST_F(ProgramManagerTest, DeleteBug) {
-  ShaderManager shader_manager;
+  ShaderManager shader_manager(&progress_reporter_);
   const GLuint kClient1Id = 1;
   const GLuint kClient2Id = 2;
   const GLuint kService1Id = 11;
   const GLuint kService2Id = 12;
   // Check we can create program.
   scoped_refptr<Program> program1(
       manager_->CreateProgram(kClient1Id, kService1Id));
   scoped_refptr<Program> program2(
       manager_->CreateProgram(kClient2Id, kService2Id));
   // Check program got created.
@@ skipping 86 matching lines @@
   static const char* kOutputVariable1Name;
   static const GLint kOutputVariable1Size = 1;
   static const GLenum kOutputVariable1Precision = GL_MEDIUM_FLOAT;
   static const bool kOutputVariable1StaticUse = true;
   static const GLint kOutputVariable1Location = -1;
   static const GLenum kOutputVariable1Type = GL_FLOAT_VEC4;
 
   static const size_t kNumAttribs;
   static const size_t kNumUniforms;
 
+  ProgramManagerWithShaderTest() : shader_manager_(&progress_reporter_) {}
+
  protected:
   typedef TestHelper::AttribInfo AttribInfo;
   typedef TestHelper::UniformInfo UniformInfo;
 
   typedef enum {
     kVarUniform,
     kVarVarying,
     kVarAttribute,
     kVarOutput,
   } VarCategory;
@@ skipping 1808 matching lines @@
   static const GLuint kServiceProgramId = 10;
   static const GLuint kVertexShaderClientId = 2;
   static const GLuint kFragmentShaderClientId = 20;
   static const GLuint kVertexShaderServiceId = 3;
   static const GLuint kFragmentShaderServiceId = 30;
 
   ProgramManagerWithCacheTest()
       : cache_(new MockProgramCache()),
         vertex_shader_(NULL),
         fragment_shader_(NULL),
-        program_(NULL) {
-  }
+        program_(NULL),
+        shader_manager_(&progress_reporter_) {}
 
  protected:
   void SetupProgramManager() override {
-    manager_.reset(new ProgramManager(cache_.get(), kMaxVaryingVectors,
-                                      kMaxDrawBuffers,
-                                      kMaxDualSourceDrawBuffers,
-                                      kMaxVertexAttribs,
-                                      gpu_preferences_,
-                                      feature_info_.get()));
+    manager_.reset(new ProgramManager(
+        cache_.get(), kMaxVaryingVectors, kMaxDrawBuffers,
+        kMaxDualSourceDrawBuffers, kMaxVertexAttribs, gpu_preferences_,
+        feature_info_.get(), &progress_reporter_));
   }
 
   void SetUp() override {
     ProgramManagerTestBase::SetUp();
 
     vertex_shader_ = shader_manager_.CreateShader(
        kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     fragment_shader_ = shader_manager_.CreateShader(
        kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
     ASSERT_TRUE(vertex_shader_ != NULL);
@@ skipping 151 matching lines @@
     EXPECT_CALL(*gl_.get(), GetShaderInfoLog(shader_id, 0, _, _))
         .Times(1);
   }
 
   std::unique_ptr<MockProgramCache> cache_;
 
   Shader* vertex_shader_;
   Shader* fragment_shader_;
   Program* program_;
   ShaderManager shader_manager_;
+  ProgressReporterStub progress_reporter_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const GLuint ProgramManagerWithCacheTest::kClientProgramId;
 const GLuint ProgramManagerWithCacheTest::kServiceProgramId;
 const GLuint ProgramManagerWithCacheTest::kVertexShaderClientId;
 const GLuint ProgramManagerWithCacheTest::kFragmentShaderClientId;
 const GLuint ProgramManagerWithCacheTest::kVertexShaderServiceId;
 const GLuint ProgramManagerWithCacheTest::kFragmentShaderServiceId;
@@ skipping 260 matching lines @@
     ProgramManagerDualSourceBlendingES2Test,
     testing::Values(
         make_gl_ext_tuple("3.2",
                           "GL_ARB_draw_buffers GL_ARB_blend_func_extended "
                           "GL_ARB_program_interface_query"),
         make_gl_ext_tuple("opengl es 3.1",
                           "GL_EXT_draw_buffers GL_EXT_blend_func_extended")));
 
 }  // namespace gles2
 }  // namespace gpu