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

media/base/video_frame.h

 // 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.
 
 #ifndef MEDIA_BASE_VIDEO_FRAME_H_
 #define MEDIA_BASE_VIDEO_FRAME_H_
 
-#include <vector>
-
 #include "base/callback.h"
 #include "base/md5.h"
 #include "base/memory/shared_memory.h"
 #include "base/synchronization/lock.h"
 #include "media/base/buffers.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 class SkBitmap;
 
@@ skipping 59 matching lines @@
   static bool IsValidConfig(Format format, const gfx::Size& coded_size,
                             const gfx::Rect& visible_rect,
                             const gfx::Size& natural_size);
 
   // CB to write pixels from the texture backing this frame into the
   // |const SkBitmap&| parameter.
   typedef base::Callback<void(const SkBitmap&)> ReadPixelsCB;
 
   // CB to be called on the mailbox backing this frame when the frame is
   // destroyed.
-  typedef base::Callback<void(const std::vector<uint32>&)> ReleaseMailboxCB;
+  typedef base::Callback<void(uint32)> ReleaseMailboxCB;
 
   // Wraps a native texture of the given parameters with a VideoFrame.  The
   // backing of the VideoFrame is held in the mailbox held by |mailbox_holder|,
   // and |mailbox_holder_release_cb| will be called with |mailbox_holder| as the
   // argument when the VideoFrame is to be destroyed.
   // |read_pixels_cb| may be used to do (slow!) readbacks from the
   // texture to main memory.
   static scoped_refptr<VideoFrame> WrapNativeTexture(
       scoped_ptr<gpu::MailboxHolder> mailbox_holder,
       const ReleaseMailboxCB& mailbox_holder_release_cb,
@@ skipping 147 matching lines @@
   // Returns true if this VideoFrame represents the end of the stream.
   bool end_of_stream() const { return end_of_stream_; }
 
   base::TimeDelta timestamp() const {
     return timestamp_;
   }
   void set_timestamp(const base::TimeDelta& timestamp) {
     timestamp_ = timestamp;
   }
 
-  // Append |sync_point| into |release_sync_points_| which will be passed to
+  class SyncPointProvider {

[dshwang, 2014/06/19 10:28:17]

I'm not good at naming. If you have better name, please let me know.

[danakj, 2014/06/19 15:56:26]

Mmmh SyncPointClient if you like that better? This is fine too.

[dshwang, 2014/06/23 18:33:20]

I choose SyncPointClient :)

+   public:
+    SyncPointProvider() {}
+    virtual uint32 InsertSyncPoint() = 0;
+    virtual void WaitSyncPoint(uint32 sync_point) = 0;
+
+   protected:
+    virtual ~SyncPointProvider() {}
+
+    DISALLOW_COPY_AND_ASSIGN(SyncPointProvider);
+  };
+  // Set a new sync point to |release_sync_point_| which will be passed to
   // the video decoder when |mailbox_holder_release_cb_| is called so that
-  // the video decoder waits for the sync points before reusing the mailbox.
-  // Multiple clients can append multiple sync points on one frame.
+  // the video decoder waits for the sync point before reusing the mailbox.
+  // A client should provide a SyncPointProvider implementation to insert or
+  // wait a sync point.
   // This method is thread safe. Both blink and compositor threads can call it.
-  void AppendReleaseSyncPoint(uint32 sync_point);
+  void UpdateReleaseSyncPoint(SyncPointProvider&);

[danakj, 2014/06/19 15:56:26]

this is a non-const ref which is not allowed. make this a pointer, and give it a
variable name here please for chromium style

[dshwang, 2014/06/23 18:33:20]

Done.

 
   // Used to keep a running hash of seen frames.  Expects an initialized MD5
   // context.  Calls MD5Update with the context and the contents of the frame.
   void HashFrameForTesting(base::MD5Context* context);
 
  private:
   friend class base::RefCountedThreadSafe<VideoFrame>;
   // Clients must use the static CreateFrame() method to create a new frame.
   VideoFrame(Format format,
              const gfx::Size& coded_size,
@@ skipping 48 matching lines @@
   // Dmabufs for each plane, if this frame is wrapping memory
   // acquired via dmabuf.
   base::ScopedFD dmabuf_fds_[kMaxPlanes];
 #endif
 
   base::Closure no_longer_needed_cb_;
 
   base::TimeDelta timestamp_;
 
   base::Lock release_sync_point_lock_;
-  std::vector<uint32> release_sync_points_;
+  uint32 release_sync_point_;
 
   const bool end_of_stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_