HW Video: Make media::VideoFrame handle the sync point of the compositor as well as webgl

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;
 
 namespace gpu {
 struct MailboxHolder;
 }  // namespace gpu
 
@@ skipping 53 matching lines @@
 
   // Call prior to CreateFrame to ensure validity of frame configuration. Called
   // automatically by VideoDecoderConfig::IsValidConfig().
   // TODO(scherkus): VideoDecoderConfig shouldn't call this method
   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;
+  typedef base::Callback<
+      void(const scoped_refptr<VideoFrame>&, const SkBitmap&)> ReadPixelsCB;
 
   // CB to be called on the mailbox backing this frame when the frame is
   // destroyed.
-  typedef base::Callback<void(scoped_ptr<gpu::MailboxHolder>)> ReleaseMailboxCB;
+  typedef base::Callback<void(scoped_ptr<gpu::MailboxHolder>,
+                              const std::vector<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.
   // |coded_size| is the width and height of the frame data in pixels.
   // |visible_rect| is the visible portion of |coded_size|, after cropping (if
   // any) is applied.
   // |natural_size| is the width and height of the frame when the frame's aspect
   // ratio is applied to |visible_rect|.
@@ skipping 116 matching lines @@
   // Returns true if this VideoFrame represents the end of the stream.
   bool end_of_stream() const { return end_of_stream_; }
 
   base::TimeDelta GetTimestamp() const {
     return timestamp_;
   }
   void SetTimestamp(const base::TimeDelta& timestamp) {
     timestamp_ = timestamp;
   }
 
+  // Append |sync_point| into |release_sync_points_| 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 in one frame.
+  // This method is thread safe. Both blink and compositor threads can call it.
+  void AppendReleaseSyncPoint(uint32 sync_point);
+
   // 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,
              const gfx::Rect& visible_rect,
@@ skipping 23 matching lines @@
   // Array of strides for each plane, typically greater or equal to the width
   // of the surface divided by the horizontal sampling period.  Note that
   // strides can be negative.
   int32 strides_[kMaxPlanes];
 
   // Array of data pointers to each plane.
   uint8* data_[kMaxPlanes];
 
   // Native texture mailbox, if this is a NATIVE_TEXTURE frame.
   scoped_ptr<gpu::MailboxHolder> mailbox_holder_;
+#ifndef NDEBUG
+  uint32 debug_initial_sync_point_;
+#endif
   ReleaseMailboxCB mailbox_holder_release_cb_;
   ReadPixelsCB read_pixels_cb_;
 
   // Shared memory handle, if this frame was allocated from shared memory.
   base::SharedMemoryHandle shared_memory_handle_;
 
   base::Closure no_longer_needed_cb_;
 
   base::TimeDelta timestamp_;
 
+  base::Lock release_sync_point_lock_;
+  std::vector<uint32> release_sync_points_;
+
   const bool end_of_stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_