Media Remoting: Don't auto suspend the media pipeline.

media/remoting/renderer_controller.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/renderer_controller.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
@@ skipping 14 matching lines @@
   session_->RemoveClient(this);
 }
 
 void RendererController::OnStarted(bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (success) {
     VLOG(1) << "Remoting started successively.";
     if (remote_rendering_started_) {
       metrics_recorder_.DidStartSession();
-      DCHECK(!switch_renderer_cb_.is_null());
-      switch_renderer_cb_.Run();
+      DCHECK(client_);
+      client_->SwitchRenderer(true);
     } else {
       session_->StopRemoting(this);
     }
   } else {
     VLOG(1) << "Failed to start remoting.";
     remote_rendering_started_ = false;
     metrics_recorder_.WillStopSession(START_RACE);
   }
 }
 
 void RendererController::OnSessionStateChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateFromSessionState(SINK_AVAILABLE, ROUTE_TERMINATED);
 }
 
 void RendererController::UpdateFromSessionState(StartTrigger start_trigger,
                                                 StopTrigger stop_trigger) {
   VLOG(1) << "UpdateFromSessionState: " << session_->state();
-  if (!sink_available_changed_cb_.is_null())
-    sink_available_changed_cb_.Run(IsRemoteSinkAvailable());
+  if (client_)
+    client_->ActivateViewportIntersectionMonitoring(IsRemoteSinkAvailable());
 
   UpdateInterstitial(base::nullopt);
   UpdateAndMaybeSwitch(start_trigger, stop_trigger);
 }
 
 bool RendererController::IsRemoteSinkAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (session_->state()) {
     case SharedSession::SESSION_CAN_START:
@@ skipping 77 matching lines @@
 
   if (poster_url != poster_url_) {
     poster_url_ = poster_url;
     if (poster_url_.is_empty())
       UpdateInterstitial(SkBitmap());
     else
       DownloadPosterImage();
   }
 }
 
-void RendererController::SetSwitchRendererCallback(const base::Closure& cb) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!cb.is_null());
-
-  switch_renderer_cb_ = cb;
-  // Note: Not calling UpdateAndMaybeSwitch() here since this method should be
-  // called during the initialization phase of this RendererController;
-  // and definitely before a whole lot of other things that are needed to
-  // trigger a switch.
-}
-
-void RendererController::SetRemoteSinkAvailableChangedCallback(
-    const base::Callback<void(bool)>& cb) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  sink_available_changed_cb_ = cb;
-  if (!sink_available_changed_cb_.is_null())
-    sink_available_changed_cb_.Run(IsRemoteSinkAvailable());
-}
-
 base::WeakPtr<RpcBroker> RendererController::GetRpcBroker() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return session_->rpc_broker()->GetWeakPtr();
 }
 
 void RendererController::StartDataPipe(
     std::unique_ptr<mojo::DataPipe> audio_data_pipe,
     std::unique_ptr<mojo::DataPipe> video_data_pipe,
     const SharedSession::DataPipeStartCallback& done_callback) {
@@ skipping 95 matching lines @@
 
 void RendererController::OnPaused() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_paused_ = true;
 }
 
 bool RendererController::ShouldBeRemoting() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (switch_renderer_cb_.is_null()) {
+  if (!client_) {
     DCHECK(!remote_rendering_started_);
     return false;  // No way to switch to the remoting renderer.
   }
 
   const SharedSession::SessionState state = session_->state();
   if (is_encrypted_) {
     // Due to technical limitations when playing encrypted content, once a
     // remoting session has been started, always return true here to indicate
     // that the CourierRenderer should continue to be used. In the stopped
     // states, CourierRenderer will display an interstitial to notify the user
@@ skipping 58 matching lines @@
   // created when video starts loading/playing, receiver will display a black
   // screen before video starts playing if switching to remoting when paused.
   // Thus, the user experience is improved by not starting remoting until
   // playback resumes.
   if (should_be_remoting && is_paused_)
     return;
 
   // Switch between local renderer and remoting renderer.
   remote_rendering_started_ = should_be_remoting;
 
+  DCHECK(client_);
   if (remote_rendering_started_) {
-    DCHECK(!switch_renderer_cb_.is_null());
     if (session_->state() == SharedSession::SESSION_PERMANENTLY_STOPPED) {
-      switch_renderer_cb_.Run();
+      client_->SwitchRenderer(true);
       return;
     }
     DCHECK_NE(start_trigger, UNKNOWN_START_TRIGGER);
     metrics_recorder_.WillStartSession(start_trigger);
-    // |switch_renderer_cb_.Run()| will be called after remoting is started
-    // successfully.
+    // |MediaObserverClient::SwitchRenderer()| will be called after remoting is
+    // started successfully.
     session_->StartRemoting(this);
   } else {
     // For encrypted content, it's only valid to switch to remoting renderer,
     // and never back to the local renderer. The RemotingCdmController will
     // force-stop the session when remoting has ended; so no need to call
     // StopRemoting() from here.
     DCHECK(!is_encrypted_);
     DCHECK_NE(stop_trigger, UNKNOWN_STOP_TRIGGER);
     metrics_recorder_.WillStopSession(stop_trigger);
     // Update the interstitial one last time before switching back to the local
     // Renderer.
     UpdateInterstitial(base::nullopt);
-    switch_renderer_cb_.Run();
+    client_->SwitchRenderer(false);
     session_->StopRemoting(this);
   }
 }
 
 void RendererController::SetShowInterstitialCallback(
     const ShowInterstitialCallback& cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   show_interstitial_cb_ = cb;
   UpdateInterstitial(SkBitmap());
   if (!poster_url_.is_empty())
@@ skipping 81 matching lines @@
 
   // Do not act on errors caused by things like Mojo pipes being closed during
   // shutdown.
   if (!remote_rendering_started_)
     return;
 
   encountered_renderer_fatal_error_ = true;
   UpdateAndMaybeSwitch(UNKNOWN_START_TRIGGER, stop_trigger);
 }
 
+void RendererController::SetClient(MediaObserverClient* client) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(client);
+  DCHECK(!client_);
+
+  client_ = client;
+  client_->ActivateViewportIntersectionMonitoring(IsRemoteSinkAvailable());
+}
+
 }  // namespace remoting
 }  // namespace media