Revert of gpu: Add base class for gpu service tests

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 <algorithm>
 
 #include "base/memory/scoped_ptr.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_service_test.h"
 #include "gpu/command_buffer/service/mocks.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"
 
+using ::gfx::MockGLInterface;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
+using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 const uint32 kMaxVaryingVectors = 8;
 
 void ShaderCacheCb(const std::string& key, const std::string& shader) {}
 }  // namespace anonymous
 
-class ProgramManagerTest : public GpuServiceTest {
+class ProgramManagerTest : public testing::Test {
  public:
   ProgramManagerTest() : manager_(NULL, kMaxVaryingVectors) { }
   virtual ~ProgramManagerTest() {
     manager_.Destroy(false);
   }
 
  protected:
+  virtual void SetUp() {
+    gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
+    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+  }
+
+  virtual void TearDown() {
+    ::gfx::MockGLInterface::SetGLInterface(NULL);
+    gl_.reset();
+  }
+
+  // Use StrictMock to make 100% sure we know how GL will be called.
+  scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   ProgramManager manager_;
 };
 
 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);
   // Check program got created.
@@ skipping 57 matching lines @@
       kClient1Id, kService1Id);
   ASSERT_TRUE(program1);
   EXPECT_EQ(kService1Id, program1->service_id());
   EXPECT_FALSE(program1->InUse());
   EXPECT_FALSE(program1->IsValid());
   EXPECT_FALSE(program1->IsDeleted());
   EXPECT_FALSE(program1->CanLink());
   EXPECT_TRUE(program1->log_info() == NULL);
 }
 
-class ProgramManagerWithShaderTest : public GpuServiceTest {
+class ProgramManagerWithShaderTest : public testing::Test {
  public:
   ProgramManagerWithShaderTest()
       :  manager_(NULL, kMaxVaryingVectors), program_(NULL) {
   }
 
   virtual ~ProgramManagerWithShaderTest() {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
@@ skipping 69 matching lines @@
   typedef struct {
     int type;
     int size;
     int precision;
     int static_use;
     std::string name;
     VarCategory category;
   } VarInfo;
 
   virtual void SetUp() {
-    GpuServiceTest::SetUp();
+    gl_.reset(new StrictMock<gfx::MockGLInterface>());
+    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
 
     SetupDefaultShaderExpectations();
 
     Shader* vertex_shader = shader_manager_.CreateShader(
         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     Shader* fragment_shader =
         shader_manager_.CreateShader(
             kFragmentShaderClientId, kFragmentShaderServiceId,
             GL_FRAGMENT_SHADER);
     ASSERT_TRUE(vertex_shader != NULL);
@@ skipping 22 matching lines @@
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                 kServiceProgramId);
   }
 
   void SetupExpectationsForClearingUniforms(
       UniformInfo* uniforms, size_t num_uniforms) {
     TestHelper::SetupExpectationsForClearingUniforms(
         gl_.get(), uniforms, num_uniforms);
   }
 
+  virtual void TearDown() {
+    ::gfx::MockGLInterface::SetGLInterface(NULL);
+  }
+
   // Return true if link status matches expected_link_status
   bool LinkAsExpected(Program* program,
                       bool expected_link_status) {
     GLuint service_id = program->service_id();
     if (expected_link_status) {
       SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                   service_id);
     }
     program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
                   base::Bind(&ShaderCacheCb));
@@ skipping 102 matching lines @@
         manager_.CreateProgram(kClientProgramId, kServiceProgramId);
     EXPECT_TRUE(program != NULL);
     EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
     EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
     return program;
   }
 
   static AttribInfo kAttribs[];
   static UniformInfo kUniforms[];
 
+  scoped_ptr<StrictMock<gfx::MockGLInterface> > gl_;
+
   ProgramManager manager_;
   Program* program_;
   ShaderManager shader_manager_;
 };
 
 ProgramManagerWithShaderTest::AttribInfo
     ProgramManagerWithShaderTest::kAttribs[] = {
   { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
   { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
   { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
@@ skipping 1149 matching lines @@
                 base::Bind(&ShaderCacheCb));
 
   EXPECT_EQ(kUniform1DesiredLocation,
             program->GetUniformFakeLocation(kUniform1Name));
   EXPECT_EQ(kUniform3DesiredLocation,
             program->GetUniformFakeLocation(kUniform3BadName));
   EXPECT_EQ(kUniform3DesiredLocation,
             program->GetUniformFakeLocation(kUniform3GoodName));
 }
 
-class ProgramManagerWithCacheTest : public GpuServiceTest {
+class ProgramManagerWithCacheTest : public testing::Test {
  public:
   static const GLuint kClientProgramId = 1;
   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()),
         manager_(cache_.get(), kMaxVaryingVectors),
         vertex_shader_(NULL),
         fragment_shader_(NULL),
         program_(NULL) {
   }
   virtual ~ProgramManagerWithCacheTest() {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
  protected:
   virtual void SetUp() {
-    GpuServiceTest::SetUp();
+    gl_.reset(new StrictMock<gfx::MockGLInterface>());
+    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
 
     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);
     vertex_shader_->UpdateSource("lka asjf bjajsdfj");
     fragment_shader_->UpdateSource("lka asjf a   fasgag 3rdsf3 bjajsdfj");
 
     program_ = manager_.CreateProgram(
         kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_ != NULL);
 
     program_->AttachShader(&shader_manager_, vertex_shader_);
     program_->AttachShader(&shader_manager_, fragment_shader_);
   }
 
+  virtual void TearDown() {
+    ::gfx::MockGLInterface::SetGLInterface(NULL);
+  }
+
   void SetShadersCompiled() {
     vertex_shader_->SetStatus(true, NULL, NULL);
     fragment_shader_->SetStatus(true, NULL, NULL);
   }
 
   void SetProgramCached() {
     cache_->LinkedProgramCacheSuccess(
         vertex_shader_->source()->c_str(),
         NULL,
         fragment_shader_->source()->c_str(),
@@ skipping 121 matching lines @@
                 ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(1);
     EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(1);
     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
       .WillOnce(SetArgumentPointee<2>(GL_FALSE));
     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_INFO_LOG_LENGTH, _))
       .WillOnce(SetArgumentPointee<2>(0));
     EXPECT_CALL(*gl_.get(), GetShaderInfoLog(shader_id, 0, _, _))
       .Times(1);
   }
 
+  scoped_ptr<StrictMock<gfx::MockGLInterface> > gl_;
+
   scoped_ptr<MockProgramCache> cache_;
   ProgramManager manager_;
 
   Shader* vertex_shader_;
   Shader* fragment_shader_;
   Program* program_;
   ShaderManager shader_manager_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
@@ skipping 23 matching lines @@
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForNotCachingProgram();
   SetExpectationsForProgramLoadSuccess();
 
   EXPECT_TRUE(program_->Link(NULL, NULL, NULL,
       Program::kCountOnlyStaticallyUsed, base::Bind(&ShaderCacheCb)));
 }
 
 }  // namespace gles2
 }  // namespace gpu