Add gpu::MailboxHolder to hold state for a gpu::Mailbox

cc/resources/resource_provider_unittest.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 using blink::WGC3Dbyte;
 using blink::WGC3Denum;
 using blink::WGC3Dint;
 using blink::WGC3Dsizei;
 using blink::WGC3Duint;
 using blink::WebGLId;
 
 namespace cc {
 namespace {
 
-static void EmptyReleaseCallback(unsigned sync_point, bool lost_resource) {}
+static void EmptyReleaseCallback(uint32 sync_point, bool lost_resource) {}
 
 static void SharedMemoryReleaseCallback(scoped_ptr<base::SharedMemory> memory,
-                                        unsigned sync_point,
+                                        uint32 sync_point,
                                         bool lost_resource) {}
 
-static void ReleaseTextureMailbox(unsigned* release_sync_point,
+static void ReleaseTextureMailbox(uint32* release_sync_point,
                                   bool* release_lost_resource,
-                                  unsigned sync_point,
+                                  uint32 sync_point,
                                   bool lost_resource) {
   *release_sync_point = sync_point;
   *release_lost_resource = lost_resource;
 }
 
 static void ReleaseSharedMemoryCallback(
     scoped_ptr<base::SharedMemory> shared_memory,
     bool* release_called,
-    unsigned* release_sync_point,
+    uint32* release_sync_point,
     bool* lost_resource_result,
-    unsigned sync_point,
+    uint32 sync_point,
     bool lost_resource) {
   *release_called = true;
   *release_sync_point = sync_point;
   *lost_resource_result = lost_resource;
 }
 
 static scoped_ptr<base::SharedMemory> CreateAndFillSharedMemory(
     gfx::Size size,
     uint32_t value) {
   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
   CHECK(shared_memory->CreateAndMapAnonymous(4 * size.GetArea()));
   uint32_t* pixels = reinterpret_cast<uint32_t*>(shared_memory->memory());
   CHECK(pixels);
   std::fill_n(pixels, size.GetArea(), value);
   return shared_memory.Pass();
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
   MOCK_METHOD3(texParameteri,
                void(WGC3Denum target, WGC3Denum pname, WGC3Dint param));
-  MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point));
-  MOCK_METHOD0(insertSyncPoint, unsigned(void));
+  MOCK_METHOD1(waitSyncPoint, void(uint32 sync_point));
+  MOCK_METHOD0(insertSyncPoint, uint32(void));
   MOCK_METHOD2(produceTextureCHROMIUM, void(WGC3Denum target,
                                             const WGC3Dbyte* mailbox));
   MOCK_METHOD2(consumeTextureCHROMIUM, void(WGC3Denum target,
                                             const WGC3Dbyte* mailbox));
 
   // Force all textures to be consecutive numbers starting at "1",
   // so we easily can test for them.
   virtual blink::WebGLId NextTextureId() OVERRIDE {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id++;
   }
   virtual void RetireTextureId(blink::WebGLId) OVERRIDE {
   }
 };
 
 // Shared data between multiple ResourceProviderContext. This contains mailbox
 // contents as well as information about sync points.
 class ContextSharedData {
  public:
   static scoped_ptr<ContextSharedData> Create() {
     return make_scoped_ptr(new ContextSharedData());
   }
 
-  unsigned InsertSyncPoint() { return next_sync_point_++; }
+  uint32 InsertSyncPoint() { return next_sync_point_++; }
 
   void GenMailbox(WGC3Dbyte* mailbox) {
     memset(mailbox, 0, sizeof(WGC3Dbyte[64]));
     memcpy(mailbox, &next_mailbox_, sizeof(next_mailbox_));
     ++next_mailbox_;
   }
 
   void ProduceTexture(const WGC3Dbyte* mailbox_name,
-                      unsigned sync_point,
+                      uint32 sync_point,
                       scoped_refptr<TestTexture> texture) {
     unsigned mailbox = 0;
     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
     ASSERT_TRUE(mailbox && mailbox < next_mailbox_);
     textures_[mailbox] = texture;
     ASSERT_LT(sync_point_for_mailbox_[mailbox], sync_point);
     sync_point_for_mailbox_[mailbox] = sync_point;
   }
 
   scoped_refptr<TestTexture> ConsumeTexture(const WGC3Dbyte* mailbox_name,
-                                            unsigned sync_point) {
+                                            uint32 sync_point) {
     unsigned mailbox = 0;
     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
     DCHECK(mailbox && mailbox < next_mailbox_);
 
     // If the latest sync point the context has waited on is before the sync
     // point for when the mailbox was set, pretend we never saw that
     // ProduceTexture.
     if (sync_point_for_mailbox_[mailbox] > sync_point) {
       NOTREACHED();
       return scoped_refptr<TestTexture>();
     }
     return textures_[mailbox];
   }
 
  private:
   ContextSharedData() : next_sync_point_(1), next_mailbox_(1) {}
 
-  unsigned next_sync_point_;
+  uint32 next_sync_point_;
   unsigned next_mailbox_;
   typedef base::hash_map<unsigned, scoped_refptr<TestTexture> > TextureMap;
   TextureMap textures_;
-  base::hash_map<unsigned, unsigned> sync_point_for_mailbox_;
+  base::hash_map<unsigned, uint32> sync_point_for_mailbox_;
 };
 
 class ResourceProviderContext : public TestWebGraphicsContext3D {
  public:
   static scoped_ptr<ResourceProviderContext> Create(
       ContextSharedData* shared_data) {
     return make_scoped_ptr(new ResourceProviderContext(shared_data));
   }
 
-  virtual unsigned insertSyncPoint() OVERRIDE {
-    unsigned sync_point = shared_data_->InsertSyncPoint();
+  virtual uint32 insertSyncPoint() OVERRIDE {
+    uint32 sync_point = shared_data_->InsertSyncPoint();
     // Commit the produceTextureCHROMIUM calls at this point, so that
     // they're associated with the sync point.
     for (PendingProduceTextureList::iterator it =
              pending_produce_textures_.begin();
          it != pending_produce_textures_.end();
          ++it) {
       shared_data_->ProduceTexture(
           (*it)->mailbox, sync_point, (*it)->texture);
     }
     pending_produce_textures_.clear();
     return sync_point;
   }
 
-  virtual void waitSyncPoint(unsigned sync_point) OVERRIDE {
+  virtual void waitSyncPoint(uint32 sync_point) OVERRIDE {
     last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
   }
 
   virtual void texStorage2DEXT(WGC3Denum target,
                                WGC3Dint levels,
                                WGC3Duint internalformat,
                                WGC3Dint width,
                                WGC3Dint height) OVERRIDE {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
@@ skipping 133 matching lines @@
       src += in_pitch;
     }
   }
 
   struct PendingProduceTexture {
     WGC3Dbyte mailbox[64];
     scoped_refptr<TestTexture> texture;
   };
   typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
   ContextSharedData* shared_data_;
-  unsigned last_waited_sync_point_;
+  uint32 last_waited_sync_point_;
   PendingProduceTextureList pending_produce_textures_;
 };
 
 void FreeSharedBitmap(SharedBitmap* shared_bitmap) {
   delete shared_bitmap->memory();
 }
 
 void IgnoreSharedBitmap(SharedBitmap* shared_bitmap) {}
 
 class TestSharedBitmapManager : public SharedBitmapManager {
@@ skipping 129 matching lines @@
 
   static void SetResourceFilter(ResourceProvider* resource_provider,
                                 ResourceProvider::ResourceId id,
                                 WGC3Denum filter) {
     ResourceProvider::ScopedSamplerGL sampler(
         resource_provider, id, GL_TEXTURE_2D, filter);
   }
 
   ResourceProviderContext* context() { return context3d_; }
 
-  ResourceProvider::ResourceId CreateChildMailbox(unsigned* release_sync_point,
+  ResourceProvider::ResourceId CreateChildMailbox(uint32* release_sync_point,
                                                   bool* lost_resource,
                                                   bool* release_called,
-                                                  unsigned* sync_point) {
+                                                  uint32* sync_point) {
     if (GetParam() == ResourceProvider::GLTexture) {
       unsigned texture = child_context_->createTexture();
       gpu::Mailbox gpu_mailbox;
       child_context_->bindTexture(GL_TEXTURE_2D, texture);
       child_context_->genMailboxCHROMIUM(gpu_mailbox.name);
       child_context_->produceTextureCHROMIUM(GL_TEXTURE_2D, gpu_mailbox.name);
       *sync_point = child_context_->insertSyncPoint();
       EXPECT_LT(0u, *sync_point);
 
       scoped_ptr<base::SharedMemory> shared_memory;
       scoped_ptr<SingleReleaseCallback> callback =
           SingleReleaseCallback::Create(base::Bind(ReleaseSharedMemoryCallback,
                                                    base::Passed(&shared_memory),
                                                    release_called,
                                                    release_sync_point,
                                                    lost_resource));
       return child_resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(gpu_mailbox, *sync_point), callback.Pass());
+          TextureMailbox(gpu_mailbox, GL_TEXTURE_2D, *sync_point),
+          callback.Pass());
     } else {
       gfx::Size size(64, 64);
       scoped_ptr<base::SharedMemory> shared_memory(
           CreateAndFillSharedMemory(size, 0));
 
       base::SharedMemory* shared_memory_ptr = shared_memory.get();
       scoped_ptr<SingleReleaseCallback> callback =
           SingleReleaseCallback::Create(base::Bind(ReleaseSharedMemoryCallback,
                                                    base::Passed(&shared_memory),
                                                    release_called,
@@ skipping 139 matching lines @@
   uint8_t data2[4] = { 5, 5, 5, 5 };
   child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
 
   WebGLId external_texture_id = child_context_->createExternalTexture();
   child_context_->bindTexture(GL_TEXTURE_EXTERNAL_OES, external_texture_id);
 
   gpu::Mailbox external_mailbox;
   child_context_->genMailboxCHROMIUM(external_mailbox.name);
   child_context_->produceTextureCHROMIUM(GL_TEXTURE_EXTERNAL_OES,
                                          external_mailbox.name);
-  const unsigned external_sync_point = child_context_->insertSyncPoint();
+  const uint32 external_sync_point = child_context_->insertSyncPoint();
   ResourceProvider::ResourceId id3 =
       child_resource_provider_->CreateResourceFromTextureMailbox(
           TextureMailbox(
               external_mailbox, GL_TEXTURE_EXTERNAL_OES, external_sync_point),
           SingleReleaseCallback::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
@@ skipping 913 matching lines @@
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   uint8_t data[4] = { 1, 2, 3, 4 };
   context()->texImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
-  unsigned sync_point = context()->insertSyncPoint();
+  uint32 sync_point = context()->insertSyncPoint();
 
   // All the logic below assumes that the sync points are all positive.
   EXPECT_LT(0u, sync_point);
 
-  unsigned release_sync_point = 0;
+  uint32 release_sync_point = 0;
   bool lost_resource = false;
   ReleaseCallback callback =
       base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
   ResourceProvider::ResourceId resource =
       resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(mailbox, sync_point),
+          TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
           SingleReleaseCallback::Create(callback));
   EXPECT_EQ(1u, context()->NumTextures());
   EXPECT_EQ(0u, release_sync_point);
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
@@ skipping 27 matching lines @@
     EXPECT_LE(list[0].sync_point, release_sync_point);
     EXPECT_FALSE(lost_resource);
   }
 
   // We're going to do the same thing as above, but testing the case where we
   // delete the resource before we receive it back.
   sync_point = release_sync_point;
   EXPECT_LT(0u, sync_point);
   release_sync_point = 0;
   resource = resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, sync_point),
+      TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
       SingleReleaseCallback::Create(callback));
   EXPECT_EQ(1u, context()->NumTextures());
   EXPECT_EQ(0u, release_sync_point);
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
@@ skipping 158 matching lines @@
   }
 
   // The resource should be lost.
   EXPECT_TRUE(child_resource_provider_->IsLost(resource));
 
   // Lost resources stay in use in the parent forever.
   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(resource));
 }
 
 TEST_P(ResourceProviderTest, LostMailboxInParent) {
-  unsigned release_sync_point = 0;
+  uint32 release_sync_point = 0;
   bool lost_resource = false;
   bool release_called = false;
-  unsigned sync_point = 0;
+  uint32 sync_point = 0;
   ResourceProvider::ResourceId resource = CreateChildMailbox(
       &release_sync_point, &lost_resource, &release_called, &sync_point);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
@@ skipping 26 matching lines @@
     returned_to_child.clear();
   }
 
   // Delete the resource in the child. Expect the resource to be lost if it's
   // a GL texture.
   child_resource_provider_->DeleteResource(resource);
   EXPECT_EQ(lost_resource, GetParam() == ResourceProvider::GLTexture);
 }
 
 TEST_P(ResourceProviderTest, LostMailboxInGrandParent) {
-  unsigned release_sync_point = 0;
+  uint32 release_sync_point = 0;
   bool lost_resource = false;
   bool release_called = false;
-  unsigned sync_point = 0;
+  uint32 sync_point = 0;
   ResourceProvider::ResourceId resource = CreateChildMailbox(
       &release_sync_point, &lost_resource, &release_called, &sync_point);
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
@@ skipping 44 matching lines @@
     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
     returned_to_child.clear();
   }
 
   // Delete the resource in the child. Expect the resource to be lost.
   child_resource_provider_->DeleteResource(resource);
   EXPECT_TRUE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, Shutdown) {
-  unsigned release_sync_point = 0;
+  uint32 release_sync_point = 0;
   bool lost_resource = false;
   bool release_called = false;
-  unsigned sync_point = 0;
+  uint32 sync_point = 0;
   CreateChildMailbox(
       &release_sync_point, &lost_resource, &release_called, &sync_point);
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
   child_resource_provider_.reset();
 
   if (GetParam() == ResourceProvider::GLTexture) {
     EXPECT_LE(sync_point, release_sync_point);
   }
   EXPECT_TRUE(release_called);
   EXPECT_FALSE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, ShutdownWithExportedResource) {
-  unsigned release_sync_point = 0;
+  uint32 release_sync_point = 0;
   bool lost_resource = false;
   bool release_called = false;
-  unsigned sync_point = 0;
+  uint32 sync_point = 0;
   ResourceProvider::ResourceId resource = CreateChildMailbox(
       &release_sync_point, &lost_resource, &release_called, &sync_point);
 
   // Transfer the resource, so we can't release it properly on shutdown.
   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
   resource_ids_to_transfer.push_back(resource);
   TransferableResourceArray list;
   child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                 &list);
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
   child_resource_provider_.reset();
 
   // Since the resource is in the parent, the child considers it lost.
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_TRUE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, LostContext) {
   // TextureMailbox callbacks only exist for GL textures for now.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
-  unsigned sync_point = context()->insertSyncPoint();
+  uint32 sync_point = context()->insertSyncPoint();
 
   EXPECT_LT(0u, sync_point);
 
-  unsigned release_sync_point = 0;
+  uint32 release_sync_point = 0;
   bool lost_resource = false;
   scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
       base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource));
   resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, sync_point),
-      callback.Pass());
+      TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point), callback.Pass());
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
   resource_provider_->DidLoseOutputSurface();
   resource_provider_.reset();
 
   EXPECT_LE(sync_point, release_sync_point);
   EXPECT_TRUE(lost_resource);
 }
@@ skipping 228 matching lines @@
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   unsigned texture_id = 1;
-  unsigned sync_point = 30;
+  uint32 sync_point = 30;
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
   scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
       base::Bind(&EmptyReleaseCallback));
 
-  TextureMailbox mailbox(gpu_mailbox, sync_point);
+  TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
   ResourceProvider::ResourceId id =
       resource_provider->CreateResourceFromTextureMailbox(
           mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
     // Using the texture does a consume of the mailbox.
@@ skipping 29 matching lines @@
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), NULL, 0, false, 1));
 
   unsigned texture_id = 1;
-  unsigned sync_point = 30;
+  uint32 sync_point = 30;
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
@@ skipping 737 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc