Add VideoFrame::CreateZeroInitializedFrame

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"
@@ skipping 95 matching lines @@
   // must be YUV). Buffers for the frame are allocated but not initialized. The
   // caller most not make assumptions about the actual underlying size(s), but
   // check the returned VideoFrame instead.
   // TODO(mcasas): implement the RGB version of this factory method.
   static scoped_refptr<VideoFrame> CreateFrame(VideoPixelFormat format,
                                                const gfx::Size& coded_size,
                                                const gfx::Rect& visible_rect,
                                                const gfx::Size& natural_size,
                                                base::TimeDelta timestamp);
 
+  // Offers the same functionality as CreateFrame. When |zero_initialize_memory|
+  // is true, it zeroes out the initial allocated buffers.
+  static scoped_refptr<VideoFrame> CreateFrame(VideoPixelFormat format,

[miu, 2015/09/03 22:06:13]

nit: You could eliminate the boolean arg, and just name this function
CreateFrameWithInitializedMemory() rather than overload it.  Though, you'd then
need a common CreateFrameInternal() function inside video_frame.cc to share the
code.

Opinions?

[DaleCurtis, 2015/09/04 22:25:13]

I like CreateZeroInitializedFrame()

[emircan, 2015/09/04 23:59:22]

sgtm. Done.

[chcunningham, 2015/09/05 00:07:51]

+1

+                                               const gfx::Size& coded_size,
+                                               const gfx::Rect& visible_rect,
+                                               const gfx::Size& natural_size,
+                                               base::TimeDelta timestamp,
+                                               bool zero_initialize_memory);
+
   // 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
   // a syncpoint as the argument when the VideoFrame is to be destroyed.
   static scoped_refptr<VideoFrame> WrapNativeTexture(
       VideoPixelFormat format,
       const gpu::MailboxHolder& mailbox_holder,
       const ReleaseMailboxCB& mailbox_holder_release_cb,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
@@ skipping 282 matching lines @@
   VideoFrame(VideoPixelFormat format,
              StorageType storage_type,
              const gfx::Size& coded_size,
              const gfx::Rect& visible_rect,
              const gfx::Size& natural_size,
              const gpu::MailboxHolder(&mailbox_holders)[kMaxPlanes],
              const ReleaseMailboxCB& mailbox_holder_release_cb,
              base::TimeDelta timestamp);
   virtual ~VideoFrame();
 
-  void AllocateYUV();
+  void AllocateYUV(bool zero_initialize_memory);
 
   // Frame format.
   const VideoPixelFormat format_;
 
   // Storage type for the different planes.
   StorageType storage_type_;  // TODO(mcasas): make const
 
   // Width and height of the video frame, in pixels. This must include pixel
   // data for the whole image; i.e. for YUV formats with subsampled chroma
   // planes, in the case that the visible portion of the image does not line up
@@ skipping 47 matching lines @@
   uint32 release_sync_point_;
 
   VideoFrameMetadata metadata_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_