WIP - Add EME

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_controller.h"
+#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/limits.h"
 #include "media/base/media_util.h"
 #include "media/base/video_decoder_config.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 17 matching lines @@
       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) {}
+      : 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, base::Unretained(this)));
+          base::Bind(&FakeRemoter::StartFailed, weak_factory_.GetWeakPtr()));
     } else {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&FakeRemoter::Started, base::Unretained(this)));
+          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, base::Unretained(this), reason));
+        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); }
 
-  mojom::RemotingSourcePtr source_;
+  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);
 };
 
-std::unique_ptr<RemotingController> CreateRemotingController(
-    mojom::RemoterFactory* remoter_factory) {
+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));
-  std::unique_ptr<RemotingController> remoting_controller =
-      base::MakeUnique<RemotingController>(std::move(remoting_source_request),
-                                           std::move(remoter));
-  return remoting_controller;
+  return new RemotingSourceImpl(std::move(remoting_source_request),
+                                std::move(remoter));
 }
 
 }  // namespace
 
-class RemotingControllerTest : public ::testing::Test {
+class RemotingRendererControllerTest : public ::testing::Test {
  public:
-  RemotingControllerTest()
-      : remoting_controller_(
-            CreateRemotingController(new FakeRemoterFactory(false))),
-        is_remoting_(false) {
-    remoting_controller_->SetSwitchRendererCallback(base::Bind(
-        &RemotingControllerTest::ToggleRenderer, base::Unretained(this)));
-  }
-  ~RemotingControllerTest() override {}
+  RemotingRendererControllerTest() : is_remoting_(false) {}
+  ~RemotingRendererControllerTest() override {}
 
   void TearDown() final { RunUntilIdle(); }
 
   static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }
 
-  void ToggleRenderer() { is_remoting_ = remoting_controller_->is_remoting(); }
+  void ToggleRenderer() { is_remoting_ = remoting_controller_->IsRemoting(); }
 
   base::MessageLoop message_loop_;
 
  protected:
-  std::unique_ptr<RemotingController> remoting_controller_;
+  std::unique_ptr<RemotingRendererController> remoting_controller_;
   bool is_remoting_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(RemotingControllerTest);
+  DISALLOW_COPY_AND_ASSIGN(RemotingRendererControllerTest);
 };
 
-TEST_F(RemotingControllerTest, ToggleRenderer) {
+TEST_F(RemotingRendererControllerTest, ToggleRenderer) {
   EXPECT_FALSE(is_remoting_);
-  remoting_controller_->OnSinkAvailable();
+  scoped_refptr<RemotingSourceImpl> remoting_source_impl =
+      CreateRemotingSourceImpl(false);
+  remoting_controller_ =
+      base::MakeUnique<RemotingRendererController>(remoting_source_impl);
+  remoting_controller_->SetSwitchRendererCallback(base::Bind(
+      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
+  remoting_source_impl->OnSinkAvailable();

[miu, 2016/10/25 04:21:26]

You should add a call to RunUntilIdle() and EXPECT_FALSE(...) after each of the
method calls. While we know RemotingSourceImpl won't post any tasks, the test
shouldn't know this. In other words, this test code should give
RemotingSourceImpl a chance to do the wrong thing. ;)

  remoting_controller_->SetSwitchRendererCallback(base::Bind(
      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
  RunUntilIdle();
  EXPECT_FALSE(is_remoting_);
  remoting_source_impl->OnSinkAvailable();
  RunUntilIdle();
  EXPECT_FALSE(is_remoting_);
  remoting_controller_->OnEnteredFullscreen();
  RunUntilIdle();
  EXPECT_FALSE(is_remoting_);
  remoting_controller_->OnMetadataChanged(defaultMetadata());
  RunUntilIdle();
  EXPECT_TRUE(is_remoting_);

...and the same thing in the StartFailed test.

[xjz, 2016/10/26 22:00:26]

Done.

   remoting_controller_->OnEnteredFullscreen();
   EXPECT_FALSE(is_remoting_);
   remoting_controller_->OnMetadataChanged(defaultMetadata());
   RunUntilIdle();
   EXPECT_TRUE(is_remoting_);
   remoting_controller_->OnExitedFullscreen();
   RunUntilIdle();
   EXPECT_FALSE(is_remoting_);
 }
 
-TEST_F(RemotingControllerTest, StartFailed) {
+TEST_F(RemotingRendererControllerTest, StartFailed) {
   EXPECT_FALSE(is_remoting_);
-  remoting_controller_ = CreateRemotingController(new FakeRemoterFactory(true));
+  scoped_refptr<RemotingSourceImpl> remoting_source_impl =
+      CreateRemotingSourceImpl(true);
+  remoting_controller_ =
+      base::MakeUnique<RemotingRendererController>(remoting_source_impl);
   remoting_controller_->SetSwitchRendererCallback(base::Bind(
-      &RemotingControllerTest::ToggleRenderer, base::Unretained(this)));
-  remoting_controller_->OnSinkAvailable();
+      &RemotingRendererControllerTest::ToggleRenderer, base::Unretained(this)));
+  remoting_source_impl->OnSinkAvailable();
   remoting_controller_->OnEnteredFullscreen();
   remoting_controller_->OnMetadataChanged(defaultMetadata());
   RunUntilIdle();
   EXPECT_FALSE(is_remoting_);
 }
 
 }  // namespace media