Media Remoting: Add mojo interfaces between browser and extension.

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 100 matching lines @@
   // in OnEnteredFullscreen() and OnExitedFullscreen(), and changes to it here
   // are ignored while in fullscreen.
   if (is_fullscreen_)
     return;
 
   is_dominant_content_ = is_dominant;
   UpdateAndMaybeSwitch(BECAME_DOMINANT_CONTENT, BECAME_AUXILIARY_CONTENT);
 }
 
 void RendererController::OnSetCdm(CdmContext* cdm_context) {
+  VLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto* remoting_cdm_context = RemotingCdmContext::From(cdm_context);
   if (!remoting_cdm_context)
     return;
 
   session_->RemoveClient(this);
   session_ = remoting_cdm_context->GetSharedSession();
   session_->AddClient(this);
   UpdateFromSessionState(CDM_READY, DECRYPTION_ERROR);
 }
 
 void RendererController::OnRemotePlaybackDisabled(bool disabled) {
+  VLOG(2) << __func__ << ": disabled = " << disabled;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_remote_playback_disabled_ = disabled;
   metrics_recorder_.OnRemotePlaybackDisabled(disabled);
   UpdateAndMaybeSwitch(ENABLED_BY_PAGE, DISABLED_BY_PAGE);
 }
 
 base::WeakPtr<RpcBroker> RendererController::GetRpcBroker() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 139 matching lines @@
     case SharedSession::SESSION_PERMANENTLY_STOPPED:
       return false;  // Use local rendering after stopping remoting.
   }
 
   switch (session_->sink_capabilities()) {
     case mojom::RemotingSinkCapabilities::NONE:
       return false;
     case mojom::RemotingSinkCapabilities::RENDERING_ONLY:
     case mojom::RemotingSinkCapabilities::CONTENT_DECRYPTION_AND_RENDERING:
       break;  // The sink is capable of remote rendering.
+    default:
+      // TODO(xjz): Will be changed in a coming CL that passes the receiver's
+      // capabilities.
+      NOTREACHED();
   }
 
   if ((!has_audio() && !has_video()) ||
       (has_video() && !IsVideoCodecSupported()) ||
       (has_audio() && !IsAudioCodecSupported())) {
     return false;
   }
 
   if (is_remote_playback_disabled_)
     return false;
@@ skipping 42 matching lines @@
     // StopRemoting() from here.
     DCHECK(!is_encrypted_);
     DCHECK_NE(stop_trigger, UNKNOWN_STOP_TRIGGER);
     metrics_recorder_.WillStopSession(stop_trigger);
     client_->SwitchRenderer(false);
     session_->StopRemoting(this);
   }
 }
 
 void RendererController::OnRendererFatalError(StopTrigger stop_trigger) {
+  VLOG(2) << __func__ << ": stop_trigger= " << stop_trigger;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // 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