Change WebMediaPlayerMS layers transparency dynamically

content/renderer/media/webmediaplayer_ms_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 <stddef.h>
 
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/renderer/media/webmediaplayer_ms.h"
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
+#include "third_party/WebKit/public/platform/WebLayer.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 
 namespace content {
 
 enum class FrameType {
   NORMAL_FRAME = 0,
   BROKEN_FRAME = -1,
   TEST_BRAKE = -2,  // Signal to pause message loop.
@@ skipping 422 matching lines @@
                void(blink::WebMediaPlayer::NetworkState));
   MOCK_METHOD1(DoReadyStateChanged, void(blink::WebMediaPlayer::ReadyState));
   MOCK_METHOD1(CheckSizeChanged, void(gfx::Size));
 
   base::MessageLoop message_loop_;
   MockRenderFactory* render_factory_;
   FakeWebMediaPlayerDelegate delegate_;
   std::unique_ptr<WebMediaPlayerMS> player_;
   WebMediaPlayerMSCompositor* compositor_;
   ReusableMessageLoopEvent message_loop_controller_;
+  blink::WebLayer* web_layer_;
 
  private:
   // Main function trying to ask WebMediaPlayerMS to submit a frame for
   // rendering.
   void RenderFrame();
 
   bool rendering_;
   bool background_rendering_;
 };
 
@@ skipping 33 matching lines @@
 }
 
 void WebMediaPlayerMSTest::readyStateChanged() {
   blink::WebMediaPlayer::ReadyState state = player_->getReadyState();
   DoReadyStateChanged(state);
   if (state == blink::WebMediaPlayer::ReadyState::ReadyStateHaveEnoughData)
     player_->play();
 }
 
 void WebMediaPlayerMSTest::setWebLayer(blink::WebLayer* layer) {
+  web_layer_ = layer;
   if (layer)
     compositor_->SetVideoFrameProviderClient(this);
   DoSetWebLayer(!!layer);
 }
 
 void WebMediaPlayerMSTest::StopUsingProvider() {
   if (rendering_)
     StopRendering();
 }
 
@@ skipping 222 matching lines @@
   const blink::WebSize& natural_size = player_->naturalSize();
   // Check that height and width are flipped.
   EXPECT_EQ(kStandardHeight, natural_size.width);
   EXPECT_EQ(kStandardWidth, natural_size.height);
   testing::Mock::VerifyAndClearExpectations(this);
 
   EXPECT_CALL(*this, DoSetWebLayer(false));
   EXPECT_CALL(*this, DoStopRendering());
 }
 
+// During this test, we check that web layer changes opacity according to the
+// given frames.
+TEST_F(WebMediaPlayerMSTest, OpacityChange) {
+  MockMediaStreamVideoRenderer* provider = LoadAndGetFrameProvider(true);
+
+  // Push one opaque frame.
+  const int kTestBrake = static_cast<int>(FrameType::TEST_BRAKE);
+  static int opaque_tokens[] = {0, kTestBrake};
+  std::vector<int> opaque_timestamps(
+      opaque_tokens, opaque_tokens + sizeof(opaque_tokens) / sizeof(int));
+  provider->QueueFrames(opaque_timestamps, true);
+  EXPECT_CALL(*this, DoSetWebLayer(true));
+  EXPECT_CALL(*this, DoStartRendering());
+  EXPECT_CALL(*this, DoReadyStateChanged(
+                         blink::WebMediaPlayer::ReadyStateHaveMetadata));
+  EXPECT_CALL(*this, DoReadyStateChanged(
+                         blink::WebMediaPlayer::ReadyStateHaveEnoughData));
+  EXPECT_CALL(*this,
+              CheckSizeChanged(gfx::Size(kStandardWidth, kStandardHeight)));
+  message_loop_controller_.RunAndWaitForStatus(
+      media::PipelineStatus::PIPELINE_OK);
+  CHECK(web_layer_);

[mcasas, 2016/09/20 00:35:14]

Don't use CHECK()s in unittests, since they
crash the executable and prevent continuing
with other test cases. Instead, use ASSERT().

[emircan, 2016/09/20 03:00:06]

Done.

+  EXPECT_TRUE(web_layer_->opaque());
+
+  // Push one transparent frame.
+  static int transparent_tokens[] = {33, kTestBrake};
+  std::vector<int> transparent_timestamps(
+      transparent_tokens,
+      transparent_tokens + sizeof(transparent_tokens) / sizeof(int));

[mcasas, 2016/09/20 00:35:14]

|transparent_tokens| is static, so we can use here
arraysize():
std::vector<int> transparent_timestamps(
    transparent_tokens,
    transparent_tokens + arraysize(transparent_tokens));

Also applies to l.764;

[emircan, 2016/09/20 03:00:06]

Done.

+  provider->QueueFrames(transparent_timestamps, false);
+  message_loop_controller_.RunAndWaitForStatus(
+      media::PipelineStatus::PIPELINE_OK);
+  EXPECT_FALSE(web_layer_->opaque());
+
+  // Push another opaque frame.
+  provider->QueueFrames(opaque_timestamps, true);

[mcasas, 2016/09/20 00:35:14]

|opaque_timestamps| has a single frame with a 
timestamp 0, does it mean the class under test
doesn't care about timestamps? If so, we don't
need |transparent_timestamps| and we can use
a dummy static int dummy_tokens{} = {...} etc.

[emircan, 2016/09/20 03:00:06]

We don't care about timestamps, except the TestBrake which helps us check status
between calls. I just wanted to be explicit with defining new frames, but I
agree that using default tokens would make it more clear.

+  message_loop_controller_.RunAndWaitForStatus(
+      media::PipelineStatus::PIPELINE_OK);
+  EXPECT_TRUE(web_layer_->opaque());
+
+  testing::Mock::VerifyAndClearExpectations(this);
+  EXPECT_CALL(*this, DoSetWebLayer(false));
+  EXPECT_CALL(*this, DoStopRendering());
+}
+
 TEST_F(WebMediaPlayerMSTest, BackgroundRendering) {
   // During this test, we will switch to background rendering mode, in which
   // WebMediaPlayerMS::pause does not get called, but
   // cc::VideoFrameProviderClient simply stops asking frames from
   // WebMediaPlayerMS without an explicit notification. We should expect that
   // WebMediaPlayerMS can digest old frames, rather than piling frames up and
   // explode.
   MockMediaStreamVideoRenderer* provider = LoadAndGetFrameProvider(true);
 
   const int kTestBrake = static_cast<int>(FrameType::TEST_BRAKE);
@@ skipping 110 matching lines @@
   // OnShown() should restart after a forced suspension.
   player_->OnShown();
   EXPECT_FALSE(player_->paused());
   EXPECT_CALL(*this, DoSetWebLayer(false));
 
   base::RunLoop().RunUntilIdle();
 }
 #endif
 
 }  // namespace content