Revert of gpu: Add base class for gpu service tests

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 "base/memory/scoped_ptr.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/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/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
 using ::testing::AtLeast;
 using ::testing::Pointee;
 using ::testing::Return;
@@ skipping 10 matching lines @@
     return texture->npot();
   }
   static bool IsTextureComplete(const Texture* texture) {
     return texture->texture_complete();
   }
   static bool IsCubeComplete(const Texture* texture) {
     return texture->cube_complete();
   }
 };
 
-class TextureManagerTest : public GpuServiceTest {
+class TextureManagerTest : public testing::Test {
  public:
   static const GLint kMaxTextureSize = 16;
   static const GLint kMaxCubeMapTextureSize = 8;
   static const GLint kMaxExternalTextureSize = 16;
   static const GLint kMax2dLevels = 5;
   static const GLint kMaxCubeMapLevels = 4;
   static const GLint kMaxExternalLevels = 1;
   static const bool kUseDefaultTextures = false;
 
   TextureManagerTest() : feature_info_(new FeatureInfo()) {}
 
   virtual ~TextureManagerTest() {
   }
 
  protected:
   virtual void SetUp() {
-    GpuServiceTest::SetUp();
+    gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
+    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+
     manager_.reset(new TextureManager(NULL,
                                       feature_info_.get(),
                                       kMaxTextureSize,
                                       kMaxCubeMapTextureSize,
                                       kUseDefaultTextures));
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), "", kUseDefaultTextures);
     manager_->Initialize();
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
   }
 
   virtual void TearDown() {
     manager_->Destroy(false);
     manager_.reset();
-    GpuServiceTest::TearDown();
+    ::gfx::MockGLInterface::SetGLInterface(NULL);
+    gl_.reset();
   }
 
   void SetParameter(
       TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
     TestHelper::SetTexParameteriWithExpectations(
         gl_.get(), error_state_.get(), manager_.get(),
         texture_ref, pname, value, error);
   }
 
+  // Use StrictMock to make 100% sure we know how GL will be called.
+  scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
   scoped_ptr<MockErrorState> error_state_;
 };
 
 // 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::kMaxExternalTextureSize;
@@ skipping 279 matching lines @@
   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);
 }
 
-class TextureTestBase : public GpuServiceTest {
+class TextureTestBase : public testing::Test {
  public:
   static const GLint kMaxTextureSize = 16;
   static const GLint kMaxCubeMapTextureSize = 8;
   static const GLint kMax2dLevels = 5;
   static const GLint kMaxCubeMapLevels = 4;
   static const GLuint kClient1Id = 1;
   static const GLuint kService1Id = 11;
   static const bool kUseDefaultTextures = false;
 
   TextureTestBase()
       : feature_info_(new FeatureInfo()) {
   }
   virtual ~TextureTestBase() {
     texture_ref_ = NULL;
   }
 
  protected:
   void SetUpBase(MemoryTracker* memory_tracker, std::string extensions) {
-    GpuServiceTest::SetUp();
+    gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
+    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+
     if (!extensions.empty()) {
       TestHelper::SetupFeatureInfoInitExpectations(gl_.get(),
                                                    extensions.c_str());
       feature_info_->Initialize();
     }
 
     manager_.reset(new TextureManager(memory_tracker,
                                       feature_info_.get(),
                                       kMaxTextureSize,
                                       kMaxCubeMapTextureSize,
@@ skipping 13 matching lines @@
         // Check that it gets deleted when the last reference is released.
         EXPECT_CALL(*gl_,
             DeleteTextures(1, ::testing::Pointee(texture_ref_->service_id())))
             .Times(1)
             .RetiresOnSaturation();
       }
       texture_ref_ = NULL;
     }
     manager_->Destroy(false);
     manager_.reset();
-    GpuServiceTest::TearDown();
+    ::gfx::MockGLInterface::SetGLInterface(NULL);
+    gl_.reset();
   }
 
   void SetParameter(
       TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
     TestHelper::SetTexParameteriWithExpectations(
         gl_.get(), error_state_.get(), manager_.get(),
         texture_ref, pname, value, error);
   }
 
   scoped_ptr<MockGLES2Decoder> decoder_;
   scoped_ptr<MockErrorState> error_state_;
+  // Use StrictMock to make 100% sure we know how GL will be called.
+  scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
   scoped_refptr<TextureRef> texture_ref_;
 };
 
 class TextureTest : public TextureTestBase {
  protected:
   virtual void SetUp() {
     SetUpBase(NULL, std::string());
   }
@@ skipping 1726 matching lines @@
     return current_size_[pool];
   }
 
  private:
   virtual ~CountingMemoryTracker() {}
 
   size_t current_size_[2];
   DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker);
 };
 
-class SharedTextureTest : public GpuServiceTest {
+class SharedTextureTest : public testing::Test {
  public:
   static const bool kUseDefaultTextures = false;
 
   SharedTextureTest() : feature_info_(new FeatureInfo()) {}
 
   virtual ~SharedTextureTest() {
   }
 
   virtual void SetUp() {
-    GpuServiceTest::SetUp();
+    gl_.reset(new ::gfx::MockGLInterface());
+    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+
     memory_tracker1_ = new CountingMemoryTracker;
     texture_manager1_.reset(
         new TextureManager(memory_tracker1_.get(),
                            feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
                            TextureManagerTest::kMaxCubeMapTextureSize,
                            kUseDefaultTextures));
     memory_tracker2_ = new CountingMemoryTracker;
     texture_manager2_.reset(
         new TextureManager(memory_tracker2_.get(),
                            feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
                            TextureManagerTest::kMaxCubeMapTextureSize,
                            kUseDefaultTextures));
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), "", kUseDefaultTextures);
     texture_manager1_->Initialize();
     TestHelper::SetupTextureManagerInitExpectations(
         gl_.get(), "", kUseDefaultTextures);
     texture_manager2_->Initialize();
   }
 
   virtual void TearDown() {
     texture_manager2_->Destroy(false);
     texture_manager2_.reset();
     texture_manager1_->Destroy(false);
     texture_manager1_.reset();
-    GpuServiceTest::TearDown();
+    ::gfx::MockGLInterface::SetGLInterface(NULL);
+    gl_.reset();
   }
 
  protected:
+  scoped_ptr< ::gfx::MockGLInterface > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_refptr<CountingMemoryTracker> memory_tracker1_;
   scoped_ptr<TextureManager> texture_manager1_;
   scoped_refptr<CountingMemoryTracker> memory_tracker2_;
   scoped_ptr<TextureManager> texture_manager2_;
 };
 
 TEST_F(SharedTextureTest, DeleteTextures) {
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   scoped_refptr<TextureRef> ref2 =
@@ skipping 259 matching lines @@
 
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(1)
       .RetiresOnSaturation();
   texture_manager1_->RemoveTexture(10);
   texture_manager2_->RemoveTexture(20);
 }
 
 }  // namespace gles2
 }  // namespace gpu