Media Remoting: Don't report remote renderer init error to pipeline.

media/remoting/courier_renderer_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/courier_renderer.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 115 matching lines @@
  public:
   CourierRendererTest()
       : receiver_renderer_handle_(10),
         receiver_audio_demuxer_callback_handle_(11),
         receiver_video_demuxer_callback_handle_(12),
         sender_client_handle_(RpcBroker::kInvalidHandle),
         sender_renderer_callback_handle_(RpcBroker::kInvalidHandle),
         sender_audio_demuxer_handle_(RpcBroker::kInvalidHandle),
         sender_video_demuxer_handle_(RpcBroker::kInvalidHandle),
         received_audio_ds_init_cb_(false),
-        received_video_ds_init_cb_(false),
-        renderer_initialized_(false) {}
+        received_video_ds_init_cb_(false) {}
   ~CourierRendererTest() override = default;
 
   // Use this function to mimic receiver to handle RPC message for renderer
   // initialization,
   void RpcMessageResponseBot(std::unique_ptr<std::vector<uint8_t>> message) {
     std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage());
     ASSERT_TRUE(rpc->ParseFromArray(message->data(), message->size()));
     switch (rpc->proc()) {
       case pb::RpcMessage::RPC_ACQUIRE_RENDERER: {
         // Issues RPC_ACQUIRE_RENDERER_DONE RPC message.
@@ skipping 40 matching lines @@
 
         // Issues RPC_R_INITIALIZE_CALLBACK RPC message when receiving
         // RPC_DS_INITIALIZE_CALLBACK on available streams.
         if (received_audio_ds_init_cb_ ==
                 (sender_audio_demuxer_handle_ != RpcBroker::kInvalidHandle) &&
             received_video_ds_init_cb_ ==
                 (sender_video_demuxer_handle_ != RpcBroker::kInvalidHandle)) {
           std::unique_ptr<pb::RpcMessage> init_cb(new pb::RpcMessage());
           init_cb->set_handle(sender_renderer_callback_handle_);
           init_cb->set_proc(pb::RpcMessage::RPC_R_INITIALIZE_CALLBACK);
-          init_cb->set_boolean_value(true);
+          init_cb->set_boolean_value(is_successfully_initialized_);
           controller_->GetRpcBroker()->ProcessMessageFromRemote(
               std::move(init_cb));
-          renderer_initialized_ = true;
         }
 
       } break;
       case pb::RpcMessage::RPC_R_FLUSHUNTIL: {
         // Issues RPC_R_FLUSHUNTIL_CALLBACK RPC message.
         std::unique_ptr<pb::RpcMessage> flush_cb(new pb::RpcMessage());
         flush_cb->set_handle(rpc->renderer_flushuntil_rpc().callback_handle());
         flush_cb->set_proc(pb::RpcMessage::RPC_R_FLUSHUNTIL_CALLBACK);
         controller_->GetRpcBroker()->ProcessMessageFromRemote(
             std::move(flush_cb));
@@ skipping 127 matching lines @@
 
   // RPC handles.
   const int receiver_renderer_handle_;
   const int receiver_audio_demuxer_callback_handle_;
   const int receiver_video_demuxer_callback_handle_;
   int sender_client_handle_;
   int sender_renderer_callback_handle_;
   int sender_audio_demuxer_handle_;
   int sender_video_demuxer_handle_;
 
-  // flag to indicate if RPC_DS_INITIALIZE_CALLBACK RPC messages are received.
+  // Indicate whether RPC_DS_INITIALIZE_CALLBACK RPC messages are received.
   bool received_audio_ds_init_cb_;
   bool received_video_ds_init_cb_;
 
-  // Check if |renderer_| is initialized successfully or not.
-  bool renderer_initialized_;
+  // Indicates whether the renderer on receiver side is successfully

[miu, 2017/02/02 22:37:58]

nit: To be clearer, let's say "...whether the test wants to simulate successful
initialization in the renderer on the receiver side."

[xjz, 2017/02/02 23:03:31]

Done.

+  // initialized.
+  bool is_successfully_initialized_ = true;
 
-  // vector to store received RPC message with proc value
+  // Stores RPC messages that are sending to remote sink.
   std::vector<std::unique_ptr<pb::RpcMessage>> received_rpc_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CourierRendererTest);
 };
 
 TEST_F(CourierRendererTest, Initialize) {
   InitializeRenderer();
   RunPendingTasks();
 
   ASSERT_TRUE(IsRendererInitialized());
   ASSERT_EQ(render_client_->status(), PIPELINE_OK);
 }
 
+TEST_F(CourierRendererTest, InitializeFailed) {

[miu, 2017/02/02 22:37:58]

Looks great! :)

+  is_successfully_initialized_ = false;
+  InitializeRenderer();
+  RunPendingTasks();
+  ASSERT_FALSE(IsRendererInitialized());
+  ASSERT_TRUE(DidEncounterFatalError());
+  // Don't report error to prevent breaking the pipeline.
+  ASSERT_EQ(render_client_->status(), PIPELINE_OK);
+
+  // The CourierRenderer should act as a no-op renderer from this point.
+
+  ResetReceivedRpcMessage();
+  EXPECT_CALL(*render_client_, OnFlushCallback()).Times(1);
+  renderer_->Flush(base::Bind(&RendererClientImpl::OnFlushCallback,
+                              base::Unretained(render_client_.get())));
+  RunPendingTasks();
+  ASSERT_EQ(0, ReceivedRpcMessageCount());
+
+  base::TimeDelta seek = base::TimeDelta::FromMicroseconds(100);
+  renderer_->StartPlayingFrom(seek);
+  RunPendingTasks();
+  ASSERT_EQ(0, ReceivedRpcMessageCount());
+
+  renderer_->SetVolume(3.0);
+  RunPendingTasks();
+  ASSERT_EQ(0, ReceivedRpcMessageCount());
+
+  renderer_->SetPlaybackRate(2.5);
+  RunPendingTasks();
+  ASSERT_EQ(0, ReceivedRpcMessageCount());
+}
+
 TEST_F(CourierRendererTest, Flush) {
   // Initialize Renderer.
   InitializeRenderer();
   RunPendingTasks();
   ASSERT_TRUE(IsRendererInitialized());
   ASSERT_EQ(render_client_->status(), PIPELINE_OK);
 
   // Flush Renderer.
   // Redirect RPC message for simulate receiver scenario
   controller_->GetRpcBroker()->SetMessageCallbackForTesting(base::Bind(
@@ skipping 44 matching lines @@
 }
 
 TEST_F(CourierRendererTest, SetPlaybackRate) {
   // Initialize Renderer because, as of this writing, the pipeline guarantees it
   // will not call SetPlaybackRate() until after the media::Renderer is
   // initialized.
   InitializeRenderer();
   RunPendingTasks();
   ASSERT_EQ(0, ReceivedRpcMessageCount());
 
-  controller_->GetRpcBroker()->SetMessageCallbackForTesting(base::Bind(
-      &CourierRendererTest::OnSendMessageToSink, base::Unretained(this)));
   renderer_->SetPlaybackRate(2.5);
   RunPendingTasks();
   ASSERT_EQ(1, ReceivedRpcMessageCount());
   // Checks if it sends out RPC message with correct value.
   const pb::RpcMessage* rpc =
       PeekRpcMessage(pb::RpcMessage::RPC_R_SETPLAYBACKRATE);
   ASSERT_TRUE(rpc);
   ASSERT_TRUE(rpc->double_value() == 2.5);
 }
 
@@ skipping 165 matching lines @@
     ASSERT_FALSE(DidEncounterFatalError());  // Not enough measurements.
     IssueStatisticsUpdateRpc();
     clock_->Advance(base::TimeDelta::FromSeconds(1));
     RunPendingTasks();
   }
   ASSERT_TRUE(DidEncounterFatalError());
 }
 
 }  // namespace remoting
 }  // namespace media