Media Remoting: Add remoting control logic for encrypted contents.

media/remoting/remoting_renderer_controller_unittest.cc

+// Copyright 2016 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 "media/remoting/remoting_renderer_controller.h"
+
+#include "base/callback.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/cdm_config.h"
+#include "media/base/limits.h"
+#include "media/base/media_util.h"
+#include "media/base/video_decoder_config.h"
+#include "media/remoting/remoting_cdm.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace {
+
+constexpr gfx::Size kCodedSize(320, 240);
+constexpr gfx::Rect kVisibleRect(320, 240);
+constexpr gfx::Size kNaturalSize(320, 240);
+
+PipelineMetadata DefaultMetadata() {
+  PipelineMetadata data;
+  data.has_audio = true;
+  data.has_video = true;
+  data.video_decoder_config = VideoDecoderConfig(
+      kCodecVP8, VP8PROFILE_ANY, VideoPixelFormat::PIXEL_FORMAT_I420,
+      ColorSpace::COLOR_SPACE_SD_REC601, kCodedSize, kVisibleRect, kNaturalSize,
+      EmptyExtraData(), Unencrypted());
+  data.audio_decoder_config = AudioDecoderConfig(
+      kCodecOpus, SampleFormat::kSampleFormatU8,
+      ChannelLayout::CHANNEL_LAYOUT_MONO, limits::kMinSampleRate,
+      EmptyExtraData(), Unencrypted());
+  return data;
+}
+
+PipelineMetadata EncryptedMetadata() {
+  PipelineMetadata data;
+  data.has_audio = true;
+  data.has_video = true;
+  data.video_decoder_config = VideoDecoderConfig(
+      kCodecVP8, VP8PROFILE_ANY, VideoPixelFormat::PIXEL_FORMAT_I420,
+      ColorSpace::COLOR_SPACE_SD_REC601, kCodedSize, kVisibleRect, kNaturalSize,
+      EmptyExtraData(), AesCtrEncryptionScheme());
+  data.audio_decoder_config = AudioDecoderConfig(
+      kCodecOpus, SampleFormat::kSampleFormatU8,
+      ChannelLayout::CHANNEL_LAYOUT_MONO, limits::kMinSampleRate,
+      EmptyExtraData(), Unencrypted());
+  return data;
+}
+
+class FakeRemoter final : public mojom::Remoter {
+ public:
+  // |start_will_fail| indicates whether starting remoting will fail.
+  FakeRemoter(mojom::RemotingSourcePtr source, bool start_will_fail)
+      : source_(std::move(source)),
+        start_will_fail_(start_will_fail),
+        weak_factory_(this) {}
+  ~FakeRemoter() override {}
+
+  // mojom::Remoter implementations.
+  void Start() override {
+    if (start_will_fail_) {
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&FakeRemoter::StartFailed, weak_factory_.GetWeakPtr()));
+    } else {
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&FakeRemoter::Started, weak_factory_.GetWeakPtr()));
+    }
+  }
+
+  void StartDataStreams(
+      mojo::ScopedDataPipeConsumerHandle audio_pipe,
+      mojo::ScopedDataPipeConsumerHandle video_pipe,
+      mojom::RemotingDataStreamSenderRequest audio_sender_request,
+      mojom::RemotingDataStreamSenderRequest video_sender_request) override {}
+
+  void Stop(mojom::RemotingStopReason reason) override {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(&FakeRemoter::Stopped, weak_factory_.GetWeakPtr(), reason));
+  }
+
+  void SendMessageToSink(const std::vector<uint8_t>& message) override {}
+
+ private:
+  void Started() { source_->OnStarted(); }
+  void StartFailed() {
+    source_->OnStartFailed(mojom::RemotingStartFailReason::ROUTE_TERMINATED);
+  }
+  void Stopped(mojom::RemotingStopReason reason) { source_->OnStopped(reason); }
+
+  const mojom::RemotingSourcePtr source_;
+  bool start_will_fail_;
+
+  base::WeakPtrFactory<FakeRemoter> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeRemoter);
+};
+
+class FakeRemoterFactory final : public mojom::RemoterFactory {
+ public:
+  // |start_will_fail| indicates whether starting remoting will fail.
+  explicit FakeRemoterFactory(bool start_will_fail)
+      : start_will_fail_(start_will_fail) {}
+  ~FakeRemoterFactory() override {}
+
+  void Create(mojom::RemotingSourcePtr source,
+              mojom::RemoterRequest request) override {
+    mojo::MakeStrongBinding(
+        base::MakeUnique<FakeRemoter>(std::move(source), start_will_fail_),
+        std::move(request));
+  }
+
+ private:
+  bool start_will_fail_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeRemoterFactory);
+};
+
+scoped_refptr<RemotingSourceImpl> CreateRemotingSourceImpl(
+    bool start_will_fail) {
+  mojom::RemotingSourcePtr remoting_source;
+  mojom::RemotingSourceRequest remoting_source_request =
+      mojo::GetProxy(&remoting_source);
+  mojom::RemoterPtr remoter;
+  std::unique_ptr<mojom::RemoterFactory> remoter_factory =
+      base::MakeUnique<FakeRemoterFactory>(start_will_fail);
+  remoter_factory->Create(std::move(remoting_source), mojo::GetProxy(&remoter));
+  return new RemotingSourceImpl(std::move(remoting_source_request),
+                                std::move(remoter));
+}
+
+}  // namespace
+
+class RemotingRendererControllerTest : public ::testing::Test {
+ public:
+  RemotingRendererControllerTest() {}
+  ~RemotingRendererControllerTest() override {}
+
+  void TearDown() final { RunUntilIdle(); }
+
+  static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }
+
+  void ToggleRenderer() {
+    is_mirroring_ = remoting_renderer_controller_->remote_rendering_started();
+  }
+
+  void CreateCdm(bool is_remoting) { is_remoting_cdm_ = is_remoting; }
+
+  base::MessageLoop message_loop_;
+
+ protected:
+  std::unique_ptr<RemotingRendererController> remoting_renderer_controller_;
+  bool is_mirroring_ = false;

[miu, 2016/10/29 02:22:16]

naming: The name you had before was much better: It was very accurate, and
"mirroring" is not accurate at all, IMHO.

[xjz, 2016/10/31 17:24:00]

Done.

+  bool is_remoting_cdm_ = false;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RemotingRendererControllerTest);
+};
+
+TEST_F(RemotingRendererControllerTest, ToggleRenderer) {
+  EXPECT_FALSE(is_mirroring_);
+  scoped_refptr<RemotingSourceImpl> remoting_source_impl =
+      CreateRemotingSourceImpl(false);
+  remoting_renderer_controller_ =
+      base::MakeUnique<RemotingRendererController>(remoting_source_impl);
+  remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind(
+      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_source_impl->OnSinkAvailable();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnEnteredFullscreen();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnMetadataChanged(DefaultMetadata());
+  RunUntilIdle();
+  EXPECT_TRUE(is_mirroring_);
+  remoting_renderer_controller_->OnExitedFullscreen();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+}
+
+TEST_F(RemotingRendererControllerTest, StartFailed) {
+  EXPECT_FALSE(is_mirroring_);
+  scoped_refptr<RemotingSourceImpl> remoting_source_impl =
+      CreateRemotingSourceImpl(true);
+  remoting_renderer_controller_ =
+      base::MakeUnique<RemotingRendererController>(remoting_source_impl);
+  remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind(
+      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_source_impl->OnSinkAvailable();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnEnteredFullscreen();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnMetadataChanged(DefaultMetadata());
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+}
+
+TEST_F(RemotingRendererControllerTest, EncryptedWithRemotingCdm) {
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_ = base::MakeUnique<RemotingRendererController>(
+      CreateRemotingSourceImpl(false));
+  remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind(
+      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnMetadataChanged(EncryptedMetadata());
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  scoped_refptr<RemotingSourceImpl> cdm_remoting_source_impl =
+      CreateRemotingSourceImpl(false);
+  std::unique_ptr<RemotingCdmController> remoting_cdm_controller =
+      base::MakeUnique<RemotingCdmController>(cdm_remoting_source_impl);
+  cdm_remoting_source_impl->OnSinkAvailable();
+  remoting_cdm_controller->ShouldCreateRemotingCdm(base::Bind(
+      &RemotingRendererControllerTest::CreateCdm, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  EXPECT_TRUE(is_remoting_cdm_);
+
+  // Create a RemotingCdm with |remoting_cdm_controller|.
+  CdmConfig cdm_config;
+  GURL gurl;
+  std::string empty_string;
+  scoped_refptr<RemotingCdm> remoting_cdm = new RemotingCdm(
+      empty_string, gurl, cdm_config, SessionMessageCB(), SessionClosedCB(),
+      SessionKeysChangeCB(), SessionExpirationUpdateCB(), CdmCreatedCB(),
+      std::move(remoting_cdm_controller));
+  remoting_renderer_controller_->OnSetCdm(remoting_cdm.get());
+  RunUntilIdle();
+  EXPECT_TRUE(is_mirroring_);
+
+  // For encrypted contents, entering/exiting full screen has no effect.
+  remoting_renderer_controller_->OnEnteredFullscreen();
+  RunUntilIdle();
+  EXPECT_TRUE(is_mirroring_);
+  remoting_renderer_controller_->OnExitedFullscreen();
+  RunUntilIdle();
+  EXPECT_TRUE(is_mirroring_);
+
+  EXPECT_NE(RemotingSessionState::SESSION_PERMANENTLY_STOPPED,
+            remoting_renderer_controller_->remoting_source()->state());
+  cdm_remoting_source_impl->OnSinkGone();
+  RunUntilIdle();
+  EXPECT_EQ(RemotingSessionState::SESSION_PERMANENTLY_STOPPED,
+            remoting_renderer_controller_->remoting_source()->state());
+  // Don't switch renderer in this case. Still in remoting.
+  EXPECT_TRUE(is_mirroring_);
+}
+
+TEST_F(RemotingRendererControllerTest, EncryptedWithLocalCdm) {
+  EXPECT_FALSE(is_mirroring_);
+  scoped_refptr<RemotingSourceImpl> renderer_remoting_source_impl =
+      CreateRemotingSourceImpl(false);
+  remoting_renderer_controller_ = base::MakeUnique<RemotingRendererController>(
+      renderer_remoting_source_impl);
+  remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind(
+      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  renderer_remoting_source_impl->OnSinkAvailable();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnEnteredFullscreen();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnMetadataChanged(EncryptedMetadata());
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+
+  scoped_refptr<RemotingSourceImpl> cdm_remoting_source_impl =
+      CreateRemotingSourceImpl(true);
+  std::unique_ptr<RemotingCdmController> remoting_cdm_controller =
+      base::MakeUnique<RemotingCdmController>(cdm_remoting_source_impl);
+  cdm_remoting_source_impl->OnSinkAvailable();
+  remoting_cdm_controller->ShouldCreateRemotingCdm(base::Bind(
+      &RemotingRendererControllerTest::CreateCdm, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  EXPECT_FALSE(is_remoting_cdm_);
+}
+
+TEST_F(RemotingRendererControllerTest, EncryptedWithFailedRemotingCdm) {
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_ = base::MakeUnique<RemotingRendererController>(
+      CreateRemotingSourceImpl(false));
+  remoting_renderer_controller_->SetSwitchRendererCallback(base::Bind(
+      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnEnteredFullscreen();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  remoting_renderer_controller_->OnMetadataChanged(EncryptedMetadata());
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+
+  scoped_refptr<RemotingSourceImpl> cdm_remoting_source_impl =
+      CreateRemotingSourceImpl(false);
+  std::unique_ptr<RemotingCdmController> remoting_cdm_controller =
+      base::MakeUnique<RemotingCdmController>(cdm_remoting_source_impl);
+  cdm_remoting_source_impl->OnSinkAvailable();
+  remoting_cdm_controller->ShouldCreateRemotingCdm(base::Bind(
+      &RemotingRendererControllerTest::CreateCdm, base::Unretained(this)));
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  EXPECT_TRUE(is_remoting_cdm_);
+
+  cdm_remoting_source_impl->OnSinkGone();
+  RunUntilIdle();
+  EXPECT_FALSE(is_mirroring_);
+  EXPECT_NE(RemotingSessionState::SESSION_PERMANENTLY_STOPPED,
+            remoting_renderer_controller_->remoting_source()->state());
+
+  CdmConfig cdm_config;
+  GURL gurl;
+  std::string empty_string;
+  scoped_refptr<RemotingCdm> remoting_cdm = new RemotingCdm(
+      empty_string, gurl, cdm_config, SessionMessageCB(), SessionClosedCB(),
+      SessionKeysChangeCB(), SessionExpirationUpdateCB(), CdmCreatedCB(),
+      std::move(remoting_cdm_controller));
+  remoting_renderer_controller_->OnSetCdm(remoting_cdm.get());
+  RunUntilIdle();
+  // Switch to remoting renderer even when the remoting CDM session was already
+  // terminated.
+  EXPECT_TRUE(is_mirroring_);
+  EXPECT_EQ(RemotingSessionState::SESSION_PERMANENTLY_STOPPED,
+            remoting_renderer_controller_->remoting_source()->state());
+}
+
+}  // namespace media