WIP: Option2: Android media: VideoFrame should not store so many sync points.

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/aligned_memory.h"
@@ skipping 222 matching lines @@
 
 // Ensure each frame is properly sized and allocated.  Will trigger OOB reads
 // and writes as well as incorrect frame hashes otherwise.
 TEST(VideoFrame, CheckFrameExtents) {
   // Each call consists of a VideoFrame::Format and the expected hash of all
   // planes if filled with kFillByte (defined in ExpectFrameExtents).
   ExpectFrameExtents(VideoFrame::YV12, "8e5d54cb23cd0edca111dd35ffb6ff05");
   ExpectFrameExtents(VideoFrame::YV16, "cce408a044b212db42a10dfec304b3ef");
 }
 
-static void TextureCallback(std::vector<uint32>* called_sync_point,
-                            const std::vector<uint32>& release_sync_points) {
-  called_sync_point->assign(release_sync_points.begin(),
-                            release_sync_points.end());
+static void TextureCallback(
+    std::map<std::string, uint32>* called_sync_point,
+    const std::map<std::string, uint32>& release_sync_points) {
+  called_sync_point->clear();
+  for (std::map<std::string, uint32>::const_iterator iter =
+           release_sync_points.begin();
+       iter != release_sync_points.end();
+       iter++) {
+    EXPECT_TRUE(called_sync_point->insert(std::make_pair(iter->first,
+                                                         iter->second)).second);
+  }
 }
 
 // Verify the gpu::MailboxHolder::ReleaseCallback is called when VideoFrame is
 // destroyed with the default release sync points.
 TEST(VideoFrame, TextureNoLongerNeededCallbackIsCalled) {
-  std::vector<uint32> called_sync_points;
-  called_sync_points.push_back(1);
+  std::map<std::string, uint32> called_sync_points;
+  called_sync_points["test1"] = 1;
 
   {
     scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
         make_scoped_ptr(
             new gpu::MailboxHolder(gpu::Mailbox(), 5, 0 /* sync_point */)),
         base::Bind(&TextureCallback, &called_sync_points),
         gfx::Size(10, 10),            // coded_size
         gfx::Rect(10, 10),            // visible_rect
         gfx::Size(10, 10),            // natural_size
         base::TimeDelta(),            // timestamp
         VideoFrame::ReadPixelsCB());  // read_pixels_cb
 
     EXPECT_EQ(1u, called_sync_points.size());
   }
   EXPECT_TRUE(called_sync_points.empty());
 }
 
 // Verify the gpu::MailboxHolder::ReleaseCallback is called when VideoFrame is
 // destroyed with the release sync points, which was updated by clients.
 // (i.e. the compositor, webgl).
 TEST(VideoFrame, TextureNoLongerNeededCallbackAfterTakingAndReleasingMailbox) {
-  std::vector<uint32> called_sync_points;
+  std::map<std::string, uint32> called_sync_points;
 
   gpu::Mailbox mailbox;
   mailbox.name[0] = 50;
   uint32 sync_point = 7;
   uint32 target = 9;
-  std::vector<uint32> release_sync_points;
-  release_sync_points.push_back(1);
-  release_sync_points.push_back(2);
-  release_sync_points.push_back(3);
+  std::map<std::string, uint32> release_sync_points;
+  release_sync_points["test1"] = 1;
+  release_sync_points["test2"] = 2;
+  release_sync_points["test3"] = 3;
 
   {
     scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture(
         make_scoped_ptr(new gpu::MailboxHolder(mailbox, target, sync_point)),
         base::Bind(&TextureCallback, &called_sync_points),
         gfx::Size(10, 10),            // coded_size
         gfx::Rect(10, 10),            // visible_rect
         gfx::Size(10, 10),            // natural_size
         base::TimeDelta(),            // timestamp
         VideoFrame::ReadPixelsCB());  // read_pixels_cb
     EXPECT_TRUE(called_sync_points.empty());
 
     const gpu::MailboxHolder* mailbox_holder = frame->mailbox_holder();
 
     EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox.name[0]);
     EXPECT_EQ(target, mailbox_holder->texture_target);
     EXPECT_EQ(sync_point, mailbox_holder->sync_point);
 
-    frame->AppendReleaseSyncPoint(release_sync_points[0]);
-    frame->AppendReleaseSyncPoint(release_sync_points[1]);
-    frame->AppendReleaseSyncPoint(release_sync_points[2]);
+    frame->AppendReleaseSyncPoint("test1", 100);
+    frame->AppendReleaseSyncPoint("test2", 101);
+    frame->AppendReleaseSyncPoint("test3", 102);
+    // Above sync points are overridden.
+    for (std::map<std::string, uint32>::const_iterator iter =
+             release_sync_points.begin();
+         iter != release_sync_points.end();
+         iter++) {
+      frame->AppendReleaseSyncPoint(iter->first, iter->second);
+    }
     EXPECT_EQ(sync_point, mailbox_holder->sync_point);
   }
   EXPECT_EQ(release_sync_points, called_sync_points);
 }
 
 }  // namespace media