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

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 "base/callback.h"
 #include "base/md5.h"
 #include "base/memory/shared_memory.h"
-#include "gpu/command_buffer/common/mailbox.h"
 #include "media/base/buffers.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 class SkBitmap;
 
+namespace gpu {
+
+struct MailboxHolder;
+
+}  // namespace gpu
+
 namespace media {
 
 class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe<VideoFrame> {
  public:
   enum {
     kFrameSizeAlignment = 16,
     kFrameSizePadding = 16,
     kFrameAddressAlignment = 32
   };
 
@@ skipping 20 matching lines @@
     HOLE = 5,  // Hole frame.
 #endif  // defined(VIDEO_HOLE)
     NATIVE_TEXTURE = 6,  // Native texture.  Pixel-format agnostic.
     YV12J = 7,  // JPEG color range version of YV12
     HISTOGRAM_MAX,  // Must always be greatest.
   };
 
   // Returns the name of a Format as a string.
   static std::string FormatToString(Format format);
 
-  // This class calls the TextureNoLongerNeededCallback when this class is
-  // destroyed.  Users can query the current sync point associated with this
-  // mailbox with sync_point(), and should call Resync() with a new sync point
-  // to ensure the mailbox remains valid for the issued commands.
-  // valid for the issued commands.
-  class MEDIA_EXPORT MailboxHolder {
-   public:
-    typedef base::Callback<void(uint32 sync_point)>
-        TextureNoLongerNeededCallback;
-
-    MailboxHolder(const gpu::Mailbox& mailbox,
-                  unsigned sync_point,
-                  const TextureNoLongerNeededCallback& release_callback);
-    ~MailboxHolder();
-
-    const gpu::Mailbox& mailbox() const { return mailbox_; }
-    unsigned sync_point() const { return sync_point_; }
-
-    void Resync(unsigned sync_point) { sync_point_ = sync_point; }
-
-   private:
-
-    gpu::Mailbox mailbox_;
-    unsigned sync_point_;
-    TextureNoLongerNeededCallback release_callback_;
-  };
-
-
   // Creates a new frame in system memory with given parameters. Buffers for
   // the frame are allocated but not initialized.
   // |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|.
   static scoped_refptr<VideoFrame> CreateFrame(
       Format format,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp);
 
   // 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;
 
-  // Wraps a native texture of the given parameters with a VideoFrame.  When the
-  // frame is destroyed |no_longer_needed_cb.Run()| will be called.
+  // CB to be called on the mailbox backing this frame when the frame is
+  // destroyed.
+  typedef base::Callback<void(gpu::MailboxHolder*)> ReleaseMailboxCB;

[danakj, 2014/01/08 17:59:15]

what do you think of making it a const*?

+
+  // 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|.
 
   // |read_pixels_cb| may be used to do (slow!) readbacks from the
   // texture to main memory.
   static scoped_refptr<VideoFrame> WrapNativeTexture(
-      scoped_ptr<MailboxHolder> mailbox_holder,
-      uint32 texture_target,
+      scoped_ptr<gpu::MailboxHolder> mailbox_holder,
+      const ReleaseMailboxCB& mailbox_holder_release_cb,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp,
-      const ReadPixelsCB& read_pixels_cb,
-      const base::Closure& no_longer_needed_cb);
+      const ReadPixelsCB& read_pixels_cb);
 
   // Read pixels from the native texture backing |*this| and write
   // them to |pixels| as BGRA.  |pixels| must point to a buffer at
   // least as large as 4*visible_rect().width()*visible_rect().height().
   void ReadPixelsFromNativeTexture(const SkBitmap& pixels);
 
   // Wraps packed image data residing in a memory buffer with a VideoFrame.
   // The image data resides in |data| and is assumed to be packed tightly in a
   // buffer of logical dimensions |coded_size| with the appropriate bit depth
   // and plane count as given by |format|.  The shared memory handle of the
@@ skipping 77 matching lines @@
   //
   // As opposed to stride(), row_bytes() refers to the bytes representing
   // frame data scanlines (coded_size.width() pixels, without stride padding).
   int row_bytes(size_t plane) const;
   int rows(size_t plane) const;
 
   // Returns pointer to the buffer for a given plane. The memory is owned by
   // VideoFrame object and must not be freed by the caller.
   uint8* data(size_t plane) const;
 
-  // Returns the mailbox of the native texture wrapped by this frame. Only
-  // valid to call if this is a NATIVE_TEXTURE frame. Before using the
+  // Returns the mailbox holder of the native texture wrapped by this frame.
+  // Only valid to call if this is a NATIVE_TEXTURE frame. Before using the
   // mailbox, the caller must wait for the included sync point.
-  MailboxHolder* texture_mailbox() const;
-
-  // Returns the texture target. Only valid for NATIVE_TEXTURE frames.
-  uint32 texture_target() const;
+  gpu::MailboxHolder* mailbox_holder() const;
 
   // Returns the shared-memory handle, if present
   base::SharedMemoryHandle shared_memory_handle() const;
 
   // 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_;
   }
@@ skipping 36 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<MailboxHolder> texture_mailbox_holder_;
-  uint32 texture_target_;
+  scoped_ptr<gpu::MailboxHolder> mailbox_holder_;
+  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_;
 
   const bool end_of_stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_