gpu: Add base class for gpu service tests

gpu/command_buffer/service/memory_program_cache_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/memory_program_cache.h"
 
 #include "base/bind.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_utils.h"
+#include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_mock.h"
 
 using ::testing::_;
 using ::testing::ElementsAreArray;
 using ::testing::Invoke;
 using ::testing::SetArgPointee;
@@ skipping 38 matching lines @@
   GLsizei length() const { return length_; }
   GLenum format() const { return format_; }
   const char* binary() const { return binary_; }
 
  private:
   GLsizei length_;
   GLenum format_;
   const char* binary_;
 };
 
-class MemoryProgramCacheTest : public testing::Test {
+class MemoryProgramCacheTest : public GpuServiceTest {
  public:
   static const size_t kCacheSizeBytes = 1024;
   static const GLuint kVertexShaderClientId = 90;
   static const GLuint kVertexShaderServiceId = 100;
   static const GLuint kFragmentShaderClientId = 91;
   static const GLuint kFragmentShaderServiceId = 100;
 
   MemoryProgramCacheTest()
       : cache_(new MemoryProgramCache(kCacheSizeBytes)),
         vertex_shader_(NULL),
         fragment_shader_(NULL),
         shader_cache_count_(0) { }
   virtual ~MemoryProgramCacheTest() {
     shader_manager_.Destroy(false);
   }
 
   void ShaderCacheCb(const std::string& key, const std::string& shader) {
     shader_cache_count_++;
     shader_cache_shader_ = shader;
   }
 
   int32 shader_cache_count() { return shader_cache_count_; }
   const std::string& shader_cache_shader() { return shader_cache_shader_; }
 
  protected:
   virtual void SetUp() {
-    gl_.reset(new ::testing::StrictMock<gfx::MockGLInterface>());
-    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+    GpuServiceTest::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);
     ASSERT_TRUE(fragment_shader_ != NULL);
@@ skipping 23 matching lines @@
     fragment_shader_->set_uniform_map(vertex_uniform_map);
     fragment_shader_->set_varying_map(vertex_varying_map);
 
     vertex_shader_->UpdateSource("bbbalsldkdkdkd");
     fragment_shader_->UpdateSource("bbbal   sldkdkdkas 134 ad");
 
     vertex_shader_->SetStatus(true, NULL, NULL);
     fragment_shader_->SetStatus(true, NULL, NULL);
   }
 
-  virtual void TearDown() {
-    ::gfx::MockGLInterface::SetGLInterface(NULL);
-    gl_.reset();
-  }
-
   void SetExpectationsForSaveLinkedProgram(
       const GLint program_id,
       ProgramBinaryEmulator* emulator) const {
     EXPECT_CALL(*gl_.get(),
                 GetProgramiv(program_id, GL_PROGRAM_BINARY_LENGTH_OES, _))
         .WillOnce(SetArgPointee<2>(emulator->length()));
     EXPECT_CALL(*gl_.get(),
                 GetProgramBinary(program_id, emulator->length(), _, _, _))
         .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::GetProgramBinary));
   }
@@ skipping 19 matching lines @@
                 ProgramBinary(program_id,
                               emulator->format(),
                               _,
                               emulator->length()))
         .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::ProgramBinary));
     EXPECT_CALL(*gl_.get(),
                 GetProgramiv(program_id, GL_LINK_STATUS, _))
                 .WillOnce(SetArgPointee<2>(GL_FALSE));
   }
 
-  // Use StrictMock to make 100% sure we know how GL will be called.
-  scoped_ptr< ::testing::StrictMock<gfx::MockGLInterface> > gl_;
   scoped_ptr<MemoryProgramCache> cache_;
   ShaderManager shader_manager_;
   Shader* vertex_shader_;
   Shader* fragment_shader_;
   int32 shader_cache_count_;
   std::string shader_cache_shader_;
 };
 
 TEST_F(MemoryProgramCacheTest, CacheSave) {
   const GLenum kFormat = 1;
@@ skipping 440 matching lines @@
       NULL,
       fragment_shader_,
       NULL,
       NULL,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 }
 
 }  // namespace gles2
 }  // namespace gpu