Fix odd size and visible rect issues in CanvasCaptureHandler

content/renderer/media/canvas_capture_handler.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/canvas_capture_handler.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 namespace {
 
+using media::VideoFrame;
+
 static void CopyAlphaChannelIntoVideoFrame(
-    const uint8_t* const source,
-    const scoped_refptr<media::VideoFrame>& dest_frame) {
-  const gfx::Size& size = dest_frame->coded_size();
-  const int stride = dest_frame->stride(media::VideoFrame::kAPlane);
-
-  if (stride == size.width()) {
-    for (int p = 0; p < size.GetArea(); ++p)
-      dest_frame->data(media::VideoFrame::kAPlane)[p] = source[p * 4 + 3];
+    const uint8_t* const source_data,
+    const gfx::Size& source_size,
+    const scoped_refptr<VideoFrame>& dest_frame) {
+  const int dest_stride = dest_frame->stride(VideoFrame::kAPlane);
+  if (dest_stride == source_size.width()) {
+    for (int p = 0; p < source_size.GetArea(); ++p) {
+      dest_frame->visible_data(VideoFrame::kAPlane)[p] = source_data[p * 4 + 3];
+    }
     return;
   }
 
-  // Copy apha values one-by-one if the destination stride != source width.
-  for (int h = 0; h < size.height(); ++h) {
-    const uint8_t* const src_ptr = &source[4 * h * size.width()];
+  // Copy alpha values one-by-one if the destination stride != source width.
+  for (int h = 0; h < source_size.height(); ++h) {
+    const uint8_t* const src_ptr = &source_data[4 * h * source_size.width()];
     uint8_t* dest_ptr =
-        &dest_frame->data(media::VideoFrame::kAPlane)[h * stride];
-    for (int pixel_index = 0; pixel_index < 4 * size.width(); pixel_index += 4)
-      *(dest_ptr++) = src_ptr[pixel_index + 3];
+        &dest_frame->visible_data(VideoFrame::kAPlane)[h * dest_stride];
+    for (int pixel = 0; pixel < 4 * source_size.width(); pixel += 4)
+      *(dest_ptr++) = src_ptr[pixel + 3];
   }
 }
 
 }  // namespace
 
 namespace content {
 
 // Implementation VideoCapturerSource that is owned by
 // MediaStreamVideoCapturerSource and delegates the Start/Stop calls to
 // CanvasCaptureHandler.
@@ skipping 186 matching lines @@
   }
 
   const bool isOpaque = image->isOpaque();
   const base::TimeTicks timestamp = base::TimeTicks::Now();
   scoped_refptr<media::VideoFrame> video_frame = frame_pool_.CreateFrame(
       isOpaque ? media::PIXEL_FORMAT_I420 : media::PIXEL_FORMAT_YV12A, size,
       gfx::Rect(size), size, timestamp - base::TimeTicks());
   DCHECK(video_frame);
 
   libyuv::ARGBToI420(temp_data_.data(), row_bytes_,
-                     video_frame->data(media::VideoFrame::kYPlane),
+                     video_frame->visible_data(media::VideoFrame::kYPlane),
                      video_frame->stride(media::VideoFrame::kYPlane),
-                     video_frame->data(media::VideoFrame::kUPlane),
+                     video_frame->visible_data(media::VideoFrame::kUPlane),
                      video_frame->stride(media::VideoFrame::kUPlane),
-                     video_frame->data(media::VideoFrame::kVPlane),
+                     video_frame->visible_data(media::VideoFrame::kVPlane),
                      video_frame->stride(media::VideoFrame::kVPlane),
                      size.width(), size.height());
   if (!isOpaque) {
     // TODO(emircan): Use https://code.google.com/p/libyuv/issues/detail?id=572
     // when it becomes available.
-    CopyAlphaChannelIntoVideoFrame(temp_data_.data(), video_frame);
+    CopyAlphaChannelIntoVideoFrame(temp_data_.data(), size, video_frame);
   }
 
   last_frame_ = video_frame;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CanvasCaptureHandler::CanvasCaptureHandlerDelegate::
                      SendNewFrameOnIOThread,
                  delegate_->GetWeakPtrForIOThread(), video_frame, timestamp));
 }
 
@@ skipping 13 matching lines @@
 
   web_track->initialize(webkit_source);
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   web_track->setExtraData(new MediaStreamVideoTrack(
       media_stream_source.release(), constraints,
       MediaStreamVideoSource::ConstraintsCallback(), true));
 }
 
 }  // namespace content