Send hardware video frames with mailboxes.

media/base/video_frame_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 "media/base/video_frame.h"
 
+#include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/buffers.h"
 #include "media/base/yuv_convert.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 using base::MD5DigestToBase16;
@@ skipping 185 matching lines @@
   // and the expected hash of all planes if filled with kFillByte (defined in
   // ExpectFrameExtents).
   ExpectFrameExtents(
       VideoFrame::RGB32,  1, 4, "de6d3d567e282f6a38d478f04fc81fb0");
   ExpectFrameExtents(
       VideoFrame::YV12,   3, 1, "71113bdfd4c0de6cf62f48fb74f7a0b1");
   ExpectFrameExtents(
       VideoFrame::YV16,   3, 1, "9bb99ac3ff350644ebff4d28dc01b461");
 }
 
+static void TextureCallback(uint32* called_sync_point, uint32 sync_point) {
+  *called_sync_point = sync_point;
+}
+
+// Verify the TextureNoLongerNeededCallback is called when VideoFrame is
+// destroyed with the original sync point.
+TEST(VideoFrame, TextureNoLongerNeededCallbackIsCalled) {
+  uint32 sync_point = 7;
+  uint32 called_sync_point = 0;
+
+  {
+    scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
+        gpu::Mailbox(),
+        sync_point,
+        5,  // texture_target
+        gfx::Size(10, 10),  // coded_size
+        gfx::Rect(10, 10),  // visible_rect
+        gfx::Size(10, 10),  // natural_size
+        base::TimeDelta(),  // timestamp
+        base::Callback<void(const SkBitmap&)>(),  // read_pixels_cb
+        base::Bind(&TextureCallback, &called_sync_point),
+        base::Closure());  // no_longer_needed_cb
+
+    EXPECT_EQ(0u, called_sync_point);
+  }
+  EXPECT_EQ(sync_point, called_sync_point);
+}
+
+// Verify the TextureNoLongerNeededCallback is called when VideoFrame is
+// destroyed with the new sync point, when the mailbox is taken by a caller.
+TEST(VideoFrame, TextureNoLongerNeededCallbackAfterTakingAndReleasingMailbox) {
+  uint32 called_sync_point = 0;
+
+  gpu::Mailbox mailbox;
+  mailbox.name[0] = 50;
+  uint32 sync_point = 7;
+  uint32 target = 9;
+
+  {
+    scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
+        mailbox,
+        sync_point,
+        target,
+        gfx::Size(10, 10),  // coded_size
+        gfx::Rect(10, 10),  // visible_rect
+        gfx::Size(10, 10),  // natural_size
+        base::TimeDelta(),  // timestamp
+        base::Callback<void(const SkBitmap&)>(),  // read_pixels_cb
+        base::Bind(&TextureCallback, &called_sync_point),
+        base::Closure());  // no_longer_needed_cb
+
+    {
+      scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder =
+          frame->texture_mailbox();
+
+      EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]);
+      EXPECT_EQ(sync_point, mailbox_holder->sync_point());
+      EXPECT_EQ(target, frame->texture_target());
+
+      // Misuse the callback.
+      sync_point = 12;
+      mailbox_holder->Return(sync_point);
+      EXPECT_EQ(0u, called_sync_point);
+
+      // Finish using the mailbox_holder and drop our reference.
+      sync_point = 10;
+      mailbox_holder->Return(sync_point);
+    }
+    EXPECT_EQ(0u, called_sync_point);
+  }
+  EXPECT_EQ(sync_point, called_sync_point);
+}
+
+// If a caller has taken ownership of the texture mailbox, it should
+// not be released when the VideoFrame is destroyed, but should when
+// the TextureNoLongerNeededCallback is called.
+TEST(VideoFrame,
+     TextureNoLongerNeededCallbackAfterTakingMailboxWithDestroyedFrame) {
+  uint32 called_sync_point = 0;
+
+  gpu::Mailbox mailbox;
+  mailbox.name[0] = 50;
+  uint32 sync_point = 7;
+  uint32 target = 9;
+
+  {
+    scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder;
+
+    {
+      scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
+          mailbox,
+          sync_point,
+          target,
+          gfx::Size(10, 10),  // coded_size
+          gfx::Rect(10, 10),  // visible_rect
+          gfx::Size(10, 10),  // natural_size
+          base::TimeDelta(),  // timestamp
+          base::Callback<void(const SkBitmap&)>(),  // read_pixels_cb
+          base::Bind(&TextureCallback, &called_sync_point),
+          base::Closure());  // no_longer_needed_cb
+
+      mailbox_holder = frame->texture_mailbox();
+
+      EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]);
+      EXPECT_EQ(sync_point, mailbox_holder->sync_point());
+      EXPECT_EQ(target, frame->texture_target());
+
+      // Keep a ref on the mailbox_holder after the VideoFrame is dropped.
+    }
+    EXPECT_EQ(0u, called_sync_point);
+
+    // Misuse the callback.
+    sync_point = 12;
+    mailbox_holder->Return(sync_point);
+    EXPECT_EQ(0u, called_sync_point);
+
+    // Finish using the mailbox_holder and drop our ref.
+    sync_point = 10;
+    mailbox_holder->Return(sync_point);
+  }
+  EXPECT_EQ(sync_point, called_sync_point);
+}
+
+// If a caller has taken ownership of the texture mailbox, but does
+// not call the callback, it should still happen with the original
+// sync point.
+TEST(VideoFrame,
+     TextureNoLongerNeededCallbackWhenNotCallingAndFrameDestroyed) {
+  uint32 called_sync_point = 0;
+
+  gpu::Mailbox mailbox;
+  mailbox.name[0] = 50;
+  uint32 sync_point = 7;
+  uint32 target = 9;
+
+  {
+    scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder;
+
+    {
+      scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
+          mailbox,
+          sync_point,
+          target,
+          gfx::Size(10, 10),  // coded_size
+          gfx::Rect(10, 10),  // visible_rect
+          gfx::Size(10, 10),  // natural_size
+          base::TimeDelta(),  // timestamp
+          base::Callback<void(const SkBitmap&)>(),  // read_pixels_cb
+          base::Bind(&TextureCallback, &called_sync_point),
+          base::Closure());  // no_longer_needed_cb
+
+      mailbox_holder = frame->texture_mailbox();
+
+      EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]);
+      EXPECT_EQ(sync_point, mailbox_holder->sync_point());
+      EXPECT_EQ(target, frame->texture_target());
+
+      // Destroy the video frame.
+    }
+    EXPECT_EQ(0u, called_sync_point);
+
+    // Drop the reference on the mailbox without using it at all.
+  }
+  EXPECT_EQ(sync_point, called_sync_point);
+}
+
+// If a caller has taken ownership of the texture mailbox, but does
+// not call the callback, it should still happen with the original
+// sync point.
+TEST(VideoFrame,
+     TextureNoLongerNeededCallbackAfterTakingMailboxAndNotCalling) {
+  uint32 called_sync_point = 0;
+
+  gpu::Mailbox mailbox;
+  mailbox.name[0] = 50;
+  uint32 sync_point = 7;
+  uint32 target = 9;
+
+  {
+    scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
+        mailbox,
+        sync_point,
+        target,
+        gfx::Size(10, 10),  // coded_size
+        gfx::Rect(10, 10),  // visible_rect
+        gfx::Size(10, 10),  // natural_size
+        base::TimeDelta(),  // timestamp
+        base::Callback<void(const SkBitmap&)>(),  // read_pixels_cb
+        base::Bind(&TextureCallback, &called_sync_point),
+        base::Closure());  // no_longer_needed_cb
+
+    scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder =
+        frame->texture_mailbox();
+
+    EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]);
+    EXPECT_EQ(sync_point, mailbox_holder->sync_point());
+    EXPECT_EQ(target, frame->texture_target());
+
+    EXPECT_EQ(0u, called_sync_point);
+
+    // Don't use the mailbox at all and drop our ref on it.
+  }
+  // The VideoFrame is destroyed, it should call the callback.
+  EXPECT_EQ(sync_point, called_sync_point);
+}
+
 }  // namespace media