Handle Alpha channel in Canvas capture

content/renderer/media/media_stream_video_renderer_sink_unittest.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 "base/bind.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream_video_renderer_sink.h"
@@ skipping 21 matching lines @@
 static const std::string kTestStreamUrl = "stream_url";
 static const std::string kTestVideoTrackId = "video_track_id";
 
 class MediaStreamVideoRendererSinkTest : public testing::Test {
  public:
   MediaStreamVideoRendererSinkTest() {
     registry_.Init(kTestStreamUrl);
     registry_.AddVideoTrack(kTestVideoTrackId);
 
     // Extract the Blink Video Track for the MSVRSink.
-    blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
-    registry_.test_stream().videoTracks(video_tracks);
-    EXPECT_EQ(1u, video_tracks.size());
+    registry_.test_stream().videoTracks(video_tracks_);
+    EXPECT_EQ(1u, video_tracks_.size());
 
     media_stream_video_renderer_sink_ = new MediaStreamVideoRendererSink(
-        video_tracks[0],
+        video_tracks_[0],
         base::Bind(&MediaStreamVideoRendererSinkTest::ErrorCallback,
                    base::Unretained(this)),
         base::Bind(&MediaStreamVideoRendererSinkTest::RepaintCallback,
                    base::Unretained(this)),
         message_loop_.task_runner(), message_loop_.task_runner().get(),
         nullptr /* gpu_factories */);
 
     EXPECT_TRUE(IsInStoppedState());
   }
 
@@ skipping 26 matching lines @@
     media_stream_video_renderer_sink_->OnVideoFrame(frame,
                                                     base::TimeTicks::Now());
   }
 
   scoped_refptr<MediaStreamVideoRendererSink> media_stream_video_renderer_sink_;
 
   // A ChildProcess and a MessageLoopForUI are both needed to fool the Tracks
   // and Sources in |registry_| into believing they are on the right threads.
   base::MessageLoopForUI message_loop_;
   const ChildProcess child_process_;
+
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks_;
   MockMediaStreamRegistry registry_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MediaStreamVideoRendererSinkTest);
 };
 
 // Checks that the initialization-destruction sequence works fine.
 TEST_F(MediaStreamVideoRendererSinkTest, StartStop) {
   EXPECT_TRUE(IsInStoppedState());
 
@@ skipping 47 matching lines @@
   message_loop_.RunUntilIdle();
   ASSERT_EQ(1u, frame_ready_cbs_.size());
 
   EXPECT_CALL(*this, RepaintCallback(video_frame)).Times(1);
   frame_ready_cbs_[0].Run();
   message_loop_.RunUntilIdle();
 
   media_stream_video_renderer_sink_->Stop();
 }
 
+class MediaStreamVideoRendererSinkTransparencyTest
+    : public MediaStreamVideoRendererSinkTest {
+ public:
+  MediaStreamVideoRendererSinkTransparencyTest() {
+    media_stream_video_renderer_sink_ = new MediaStreamVideoRendererSink(
+        video_tracks_[0],
+        base::Bind(&MediaStreamVideoRendererSinkTest::ErrorCallback,
+                   base::Unretained(this)),
+        base::Bind(&MediaStreamVideoRendererSinkTransparencyTest::
+                       VerifyTransparentFrame,
+                   base::Unretained(this)),
+        message_loop_.task_runner(), message_loop_.task_runner().get(),
+        nullptr /* gpu_factories */);
+  }
+
+  void VerifyTransparentFrame(const scoped_refptr<media::VideoFrame>& frame) {
+    EXPECT_EQ(media::PIXEL_FORMAT_YV12A, frame->format());
+  }
+};
+
+TEST_F(MediaStreamVideoRendererSinkTransparencyTest,
+       SendTransparentFrame) {
+  media_stream_video_renderer_sink_->Start();
+
+  InSequence s;
+  const gfx::Size size(10, 10);
+  const base::TimeDelta kTimestamp = base::TimeDelta();
+  const scoped_refptr<media::VideoFrame> video_frame =
+      media::VideoFrame::CreateFrame(media::PIXEL_FORMAT_YV12A, size,
+                                     gfx::Rect(size), size, kTimestamp);
+  OnVideoFrame(video_frame);
+  message_loop_.RunUntilIdle();
+
+  media_stream_video_renderer_sink_->Stop();
+
+}
+
 }  // namespace content