Mojo Video Capture service in media/capture

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 395 matching lines @@
 
   // It uses |client| to insert a new sync point and potentially waits on a
   // older sync point. The final sync point will be used to release this
   // VideoFrame.
   // This method is thread safe. Both blink and compositor threads can call it.
   void UpdateReleaseSyncToken(SyncTokenClient* client);
 
   // Returns a human-readable string describing |*this|.
   std::string AsHumanReadableString();
 
+ protected:
+  friend class base::RefCountedThreadSafe<VideoFrame>;
+  virtual ~VideoFrame();
+
+  // Clients must use the static factory/wrapping methods to create a new frame.
+  VideoFrame(VideoPixelFormat format,
+             StorageType storage_type,
+             const gfx::Size& coded_size,
+             const gfx::Rect& visible_rect,
+             const gfx::Size& natural_size,
+             base::TimeDelta timestamp);
+
+  void set_data(size_t plane, uint8_t* ptr);

[magjed_chromium, 2016/03/03 14:20:58]

I don't like these changes to VideoFrame. Adding setters for the data pointers
and strides breaks encapsulation and ownership handling. Instead of letting
MojoVideoFrame inherit from VideoFrame, can't you use one of the WrapExternal
functions?

[mcasas, 2016/03/03 18:41:15]

Actually this is happening in //, see the description of 
this CL:
"Still depending on http://crrev.com/1704273002
that will introduce a MojoVideoFrame that'll make the
current one here unnecessary."

Please feel free to add comments in that CL.

+  void set_stride(size_t plane, int stride);
+
  private:
-  friend class base::RefCountedThreadSafe<VideoFrame>;
-
   static scoped_refptr<VideoFrame> WrapExternalStorage(
       VideoPixelFormat format,
       StorageType storage_type,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       uint8_t* data,
       size_t data_size,
       base::TimeDelta timestamp,
       base::SharedMemoryHandle handle,
       size_t data_offset);
 
-  // Clients must use the static factory/wrapping methods to create a new frame.
   VideoFrame(VideoPixelFormat format,
              StorageType storage_type,
              const gfx::Size& coded_size,
-             const gfx::Rect& visible_rect,
-             const gfx::Size& natural_size,
-             base::TimeDelta timestamp);
-  VideoFrame(VideoPixelFormat format,
-             StorageType storage_type,
-             const gfx::Size& coded_size,
              const gfx::Rect& visible_rect,
              const gfx::Size& natural_size,
              base::TimeDelta timestamp,
              base::SharedMemoryHandle handle,
              size_t shared_memory_offset);
   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();
 
   static scoped_refptr<VideoFrame> CreateFrameInternal(
       VideoPixelFormat format,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp,
       bool zero_initialize_memory);
 
   void AllocateYUV(bool zero_initialize_memory);
@@ skipping 60 matching lines @@
   gpu::SyncToken release_sync_token_;
 
   VideoFrameMetadata metadata_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_