Update WebRtcVideoFrameAdapter to new buffer interface

content/renderer/media/webrtc/webrtc_video_frame_adapter.cc

 // Copyright 2015 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.
 
 #include "content/renderer/media/webrtc/webrtc_video_frame_adapter.h"
 
 #include "base/logging.h"
 
 namespace {
 
+class I420Adapter : public webrtc::I420BufferInterface {
+ public:
+  explicit I420Adapter(const scoped_refptr<media::VideoFrame>& frame)
+      : frame_(frame) {}
+
+ private:
+  int width() const override { return frame_->visible_rect().width(); }
+  int height() const override { return frame_->visible_rect().height(); }
+
+  const uint8_t* DataY() const override {
+    return frame_->visible_data(media::VideoFrame::kYPlane);
+  }
+
+  const uint8_t* DataU() const override {
+    return frame_->visible_data(media::VideoFrame::kUPlane);
+  }
+
+  const uint8_t* DataV() const override {
+    return frame_->visible_data(media::VideoFrame::kVPlane);
+  }
+
+  int StrideY() const override {
+    return frame_->stride(media::VideoFrame::kYPlane);
+  }
+
+  int StrideU() const override {
+    return frame_->stride(media::VideoFrame::kUPlane);
+  }
+
+  int StrideV() const override {
+    return frame_->stride(media::VideoFrame::kVPlane);
+  }
+
+  scoped_refptr<media::VideoFrame> frame_;
+};
+
 void IsValidFrame(const scoped_refptr<media::VideoFrame>& frame) {
   // Paranoia checks.
   DCHECK(frame);
   DCHECK(media::VideoFrame::IsValidConfig(
       frame->format(), frame->storage_type(), frame->coded_size(),
       frame->visible_rect(), frame->natural_size()));
   DCHECK(media::PIXEL_FORMAT_I420 == frame->format() ||
          media::PIXEL_FORMAT_YV12 == frame->format());
   CHECK(reinterpret_cast<void*>(frame->data(media::VideoFrame::kYPlane)));
   CHECK(reinterpret_cast<void*>(frame->data(media::VideoFrame::kUPlane)));
   CHECK(reinterpret_cast<void*>(frame->data(media::VideoFrame::kVPlane)));
   CHECK(frame->stride(media::VideoFrame::kYPlane));
   CHECK(frame->stride(media::VideoFrame::kUPlane));
   CHECK(frame->stride(media::VideoFrame::kVPlane));
 }
 
 }  // anonymous namespace
 
 namespace content {
 
 WebRtcVideoFrameAdapter::WebRtcVideoFrameAdapter(
     const scoped_refptr<media::VideoFrame>& frame,
     const CopyTextureFrameCallback& copy_texture_callback)
     : frame_(frame), copy_texture_callback_(copy_texture_callback) {}
 
 WebRtcVideoFrameAdapter::~WebRtcVideoFrameAdapter() {
 }
 
+webrtc::VideoFrameBuffer::Type WebRtcVideoFrameAdapter::type() const {
+  return Type::kNative;
+}
+
 int WebRtcVideoFrameAdapter::width() const {
   return frame_->visible_rect().width();
 }
 
 int WebRtcVideoFrameAdapter::height() const {
   return frame_->visible_rect().height();
 }
 
 const uint8_t* WebRtcVideoFrameAdapter::DataY() const {
   return frame_->visible_data(media::VideoFrame::kYPlane);
@@ skipping 17 matching lines @@
 
 void* WebRtcVideoFrameAdapter::native_handle() const {
   // Keep native handle for shared memory backed frames, so that we can use
   // the existing handle to share for hw encode.
   if (frame_->HasTextures() ||
       frame_->storage_type() == media::VideoFrame::STORAGE_SHMEM)
     return frame_.get();
   return nullptr;
 }
 
-rtc::scoped_refptr<webrtc::VideoFrameBuffer>
-WebRtcVideoFrameAdapter::NativeToI420Buffer() {
-  if (frame_->storage_type() == media::VideoFrame::STORAGE_SHMEM) {
-    IsValidFrame(frame_);
-    return this;
-  }
-
+rtc::scoped_refptr<webrtc::I420BufferInterface>
+WebRtcVideoFrameAdapter::ToI420() {
   if (frame_->HasTextures()) {

[emircan, 2017/06/10 00:09:27]

DCHECK(media::VideoFrame::STORAGE_SHMEM == frame_->storage_type() ||
frame_->HasTextures());
This check would help if any unexpected type is ever used.

[magjed_chromium, 2017/06/10 15:45:00]

ToI420 is allowed to be called for any storage type, e.g. STORAGE_OWNED_MEMORY.
That's the reason I changed the implementation here. We only need to do
something in this function in the case of textures. IsValidFrame() should take
care of checking that it's a valid i420 frame after that, regardless of storage
type.

     if (copy_texture_callback_.is_null()) {
       DLOG(ERROR) << "Texture backed frame cannot be copied.";
       return nullptr;
     }
 
     scoped_refptr<media::VideoFrame> new_frame;
     copy_texture_callback_.Run(frame_, &new_frame);
     if (!new_frame)
       return nullptr;
     frame_ = new_frame;
-    IsValidFrame(frame_);
-    return this;
   }
 
-  NOTREACHED();
-  return nullptr;
+  IsValidFrame(frame_);
+  return new rtc::RefCountedObject<I420Adapter>(frame_);
 }
 
 }  // namespace content