Android: Fix up video to work with mailboxes.

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/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
@@ skipping 350 matching lines @@
   static const GLuint kService1Id = 11;
 
   TextureTestBase()
       : feature_info_(new FeatureInfo()) {
   }
   virtual ~TextureTestBase() {
     texture_ = NULL;
   }
 
  protected:
-  void SetUpBase(MemoryTracker* memory_tracker) {
+  void SetUpBase(MemoryTracker* memory_tracker, std::string extensions) {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
+
+    if (!extensions.empty()) {
+      TestHelper::SetupFeatureInfoInitExpectations(gl_.get(),
+                                                   extensions.c_str());
+      feature_info_->Initialize(NULL);
+    }
+
     manager_.reset(new TextureManager(
         memory_tracker, feature_info_.get(),
         kMaxTextureSize, kMaxCubeMapTextureSize));
     decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
     manager_->CreateTexture(kClient1Id, kService1Id);
     texture_ = manager_->GetTexture(kClient1Id);
     ASSERT_TRUE(texture_.get() != NULL);
   }
 
   virtual void TearDown() {
@@ skipping 27 matching lines @@
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
   scoped_ptr<MockGLES2Decoder> decoder_;
   scoped_refptr<Texture> texture_;
 };
 
 class TextureTest : public TextureTestBase {
  protected:
   virtual void SetUp() {
-    SetUpBase(NULL);
+    SetUpBase(NULL, std::string());
   }
 };
 
 class TextureMemoryTrackerTest : public TextureTestBase {
  protected:
   virtual void SetUp() {
     mock_memory_tracker_ = new StrictMock<MockMemoryTracker>();
-    SetUpBase(mock_memory_tracker_.get());
+    SetUpBase(mock_memory_tracker_.get(), std::string());
   }
 
   scoped_refptr<MockMemoryTracker> mock_memory_tracker_;
 };
 
 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \
     EXPECT_CALL(*mock_memory_tracker_, \
                 TrackMemoryAllocatedChange(old_size, new_size, pool)) \
         .Times(1) \
         .RetiresOnSaturation() \
@@ skipping 836 matching lines @@
   manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check the set was acutally getting different signatures.
   EXPECT_EQ(11u, string_set.size());
 }
 
 class SaveRestoreTextureTest : public TextureTest {
  public:
   virtual void SetUp() {
-    TextureTest::SetUp();
+    TextureTest::SetUpBase(NULL, "GL_OES_EGL_image_external");
     manager_->CreateTexture(kClient2Id, kService2Id);
     texture2_ = manager_->GetTexture(kClient2Id);
   }
 
   virtual void TearDown() {
     if (texture2_.get()) {
       GLuint client_id = 0;
       // If it's not in the manager then setting texture2_ to NULL will
       // delete the texture.
       if (!manager_->GetClientId(texture2_->service_id(), &client_id)) {
@@ skipping 76 matching lines @@
     EXPECT_TRUE(texture->GetLevelSize(target, level, &info.width,
                                       &info.height));
     EXPECT_TRUE(texture->GetLevelType(target, level, &info.type,
                                       &info.format));
     info.cleared = texture->IsLevelCleared(target, level);
     return info;
   }
 
   TextureDefinition* Save(Texture* texture) {
     EXPECT_CALL(*gl_, GenTextures(_, _))
-        .WillOnce(SetArgumentPointee<1>(kService2Id));
+        .WillOnce(SetArgumentPointee<1>(kEmptyTextureServiceId));
     TextureDefinition* definition = manager_->Save(texture);
     EXPECT_TRUE(definition != NULL);
     return definition;
   }
 
   void Restore(Texture* texture, TextureDefinition* definition) {
     EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(texture->service_id())))
         .Times(1).RetiresOnSaturation();
     EXPECT_CALL(*gl_,
                 BindTexture(definition->target(), definition->service_id()))
@@ skipping 68 matching lines @@
   Restore(texture2_, definition.release());
 
   // See if we can clear the previously uncleared level now.
   EXPECT_EQ(level0, GetLevelInfo(texture2_.get(), GL_TEXTURE_RECTANGLE_ARB, 0));
   EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _))
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(manager_->ClearTextureLevel(
       decoder_.get(), texture2_, GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
+TEST_F(SaveRestoreTextureTest, SaveRestoreStreamTexture) {
+  manager_->SetTarget(texture_, GL_TEXTURE_EXTERNAL_OES);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture_->target());
+  texture_->SetStreamTexture(true);
+  GLuint service_id = texture_->service_id();
+  scoped_ptr<TextureDefinition> definition(Save(texture_));
+  manager_->SetTarget(texture2_, GL_TEXTURE_EXTERNAL_OES);
+  Restore(texture2_, definition.release());
+  EXPECT_TRUE(texture2_->IsStreamTexture());
+  EXPECT_TRUE(texture2_->IsImmutable());
+  EXPECT_EQ(service_id, texture2_->service_id());
+}
+
 TEST_F(SaveRestoreTextureTest, SaveRestoreCube) {
   manager_->SetTarget(texture_, GL_TEXTURE_CUBE_MAP);
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture_->target());
   LevelInfo face0(GL_TEXTURE_CUBE_MAP_POSITIVE_X,
                   GL_RGBA,
                   1,
                   1,
                   1,
                   0,
                   GL_UNSIGNED_BYTE,
@@ skipping 18 matching lines @@
   EXPECT_EQ(face0,
             GetLevelInfo(texture2_.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0));
   EXPECT_EQ(face5,
             GetLevelInfo(texture2_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0));
 }
 
 }  // namespace gles2
 }  // namespace gpu