Media Remoting: Update remoting interstitial when status changes.

media/remoting/remote_renderer_impl.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/remote_renderer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 18 matching lines @@
     VideoRendererSink* video_renderer_sink)
     : state_(STATE_UNINITIALIZED),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       media_task_runner_(std::move(media_task_runner)),
       demuxer_stream_provider_(nullptr),
       client_(nullptr),
       remoting_renderer_controller_(remoting_renderer_controller),
       rpc_broker_(remoting_renderer_controller_->GetRpcBroker()),
       rpc_handle_(remoting::RpcBroker::GetUniqueHandle()),
       remote_renderer_handle_(remoting::kInvalidHandle),
-      interstitial_ui_(video_renderer_sink,
-                       remoting_renderer_controller->pipeline_metadata()),
+      remoting_interstitial_ui_(video_renderer_sink),
       weak_factory_(this) {
   VLOG(2) << __FUNCTION__;
   // The constructor is running on the main thread.
-  DCHECK(remoting_renderer_controller);
-
-  UpdateInterstitial();
+  DCHECK(remoting_renderer_controller_);
+  remoting_renderer_controller_->SetShowInterstitialCallback(
+      base::Bind(&RemotingInterstitialUI::ShowInterstitialOnSink,

[miu, 2016/12/13 22:39:09]

As discussed face-to-face, consider:

base::Bind(&base::SingleThreadTaskRunner::PostTask, media_task_runner_,
FROM_HERE,
    base::Bind(&RemoteRendererImpl::ShowInterstitialOnSink,
               weak_factory_.GetWeakPtr(), video_renderer_sink));

[xjz, 2016/12/14 00:29:50]

Done. Use static function instead, as this doesn't work.

+                 remoting_interstitial_ui_.GetWeakPtr()));
 
   const remoting::RpcBroker::ReceiveMessageCallback receive_callback =
       base::Bind(&RemoteRendererImpl::OnMessageReceivedOnMainThread,
                  media_task_runner_, weak_factory_.GetWeakPtr());
   rpc_broker_->RegisterMessageReceiverCallback(rpc_handle_, receive_callback);
 }
 
 RemoteRendererImpl::~RemoteRendererImpl() {
   VLOG(2) << __FUNCTION__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
@@ skipping 491 matching lines @@
 }
 
 void RemoteRendererImpl::OnFatalError(PipelineStatus error) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
   // An error has already been delivered.
   if (state_ == STATE_ERROR)
     return;
 
-  main_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&RemoteRendererImpl::UpdateInterstitial,
-                            weak_factory_.GetWeakPtr()));
-
   const State old_state = state_;
   state_ = STATE_ERROR;
 
   if (!init_workflow_done_callback_.is_null()) {
     DCHECK(old_state == STATE_CREATE_PIPE || old_state == STATE_ACQUIRING ||
            old_state == STATE_INITIALIZING);
     base::ResetAndReturn(&init_workflow_done_callback_).Run(error);
     return;
   }
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 
   // After OnError() returns, the pipeline may destroy |this|.
   client_->OnError(error);
 }
 
-void RemoteRendererImpl::UpdateInterstitial() {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-
-  interstitial_ui_.ShowInterstitial(
-      remoting_renderer_controller_->remoting_source()->state() ==
-      RemotingSessionState::SESSION_STARTED);
-}
-
 }  // namespace media