Remove media::VideoFrame from media::VideoCaptureDevice::Client interface

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"
@@ skipping 117 matching lines @@
       const gfx::Size& natural_size,
       base::TimeDelta timestamp,
       const ReadPixelsCB& read_pixels_cb,
       const base::Closure& no_longer_needed_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 image data in a buffer backed by a base::SharedMemoryHandle 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|.  When the frame is
-  // destroyed |no_longer_needed_cb.Run()| will be called.
-  static scoped_refptr<VideoFrame> WrapExternalSharedMemory(
+  // 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
+  // backing allocation, if present, can be passed in with |handle|.  When the
+  // frame is destroyed, |no_longer_needed_cb.Run()| will be called.
+  static scoped_refptr<VideoFrame> WrapExternalPackedMemory(
       Format format,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       uint8* data,
       size_t data_size,
       base::SharedMemoryHandle handle,
       base::TimeDelta timestamp,
       const base::Closure& no_longer_needed_cb);
 
@@ skipping 33 matching lines @@
   // Allocates a hole frame.
   static scoped_refptr<VideoFrame> CreateHoleFrame(const gfx::Size& size);
 #endif
 
   static size_t NumPlanes(Format format);
 
   // Returns the required allocation size for a (tightly packed) frame of the
   // given coded size and format.
   static size_t AllocationSize(Format format, const gfx::Size& coded_size);
 
+  // Returns the required allocation size for a (tightly packed) plane of the
+  // given coded size and format.
+  static size_t PlaneAllocationSize(Format format,
+                                    size_t plane,

[Ami GONE FROM CHROMIUM, 2013/11/19 21:01:52]

size_t is a weird type to use for this.  Please name the k[ARGB]Plane enum type
at the top of this file and use that type here.

[sheu, 2013/11/19 21:30:27]

Everything else uses size_t for plane index.  Should I go through and convert
all similar definitions/callers?

[ncarter (slow), 2013/11/19 21:36:42]

I concur with sheu@; we should leave this as size_t. A common usage is to have a
for loop doing plane_index++; requiring an enum here makes that usage more
cumbersome. I'm not sure why size_t was used instead of int, but if we change
one spot we should change all of them, and that would be best done as a separate
change.

+                                    const gfx::Size& coded_size);
+
   Format format() const { return format_; }
 
   const gfx::Size& coded_size() const { return coded_size_; }
   const gfx::Rect& visible_rect() const { return visible_rect_; }
   const gfx::Size& natural_size() const { return natural_size_; }
 
   int stride(size_t plane) const;
 
   // Returns the number of bytes per row and number of rows for a given plane.
   //
@@ skipping 81 matching lines @@
   base::TimeDelta timestamp_;
 
   const bool end_of_stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_