Media Remoting: Update remoting interstitial when status changes.

media/remoting/remoting_renderer_controller.h

 // 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.
 
 #ifndef MEDIA_REMOTING_REMOTING_RENDERER_CONTROLLER_H_
 #define MEDIA_REMOTING_REMOTING_RENDERER_CONTROLLER_H_
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/media_observer.h"
+#include "media/remoting/remoting_interstitial_ui.h"
 #include "media/remoting/remoting_source_impl.h"
 
 namespace media {
 
 namespace remoting {
 class RpcBroker;
 }
 
 // This class:
 // 1) Implements the RemotingSourceImpl::Client;
@@ skipping 18 matching lines @@
   void OnSetCdm(CdmContext* cdm_context) override;
   void OnMetadataChanged(const PipelineMetadata& metadata) override;
   void OnRemotePlaybackDisabled(bool disabled) override;
   void OnPlaying() override;
   void OnPaused() override;
 
   void SetSwitchRendererCallback(const base::Closure& cb);
   void SetRemoteSinkAvailableChangedCallback(
       const base::Callback<void(bool)>& cb);
 
+  using ShowInterstitialCallback = base::Callback<
+      void(const SkBitmap&, const gfx::Size&, RemotingInterstitialType type)>;
+  // Called by RemoteRendererImpl constructor to set the callback to draw and
+  // show remoting interstial.
+  void SetShowInterstitialCallback(const ShowInterstitialCallback& cb);
+
   base::WeakPtr<RemotingRendererController> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
   // Used by RemotingRendererFactory to query whether to create Media Remoting
   // Renderer.
   bool remote_rendering_started() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return remote_rendering_started_;
   }
 
   void StartDataPipe(
       std::unique_ptr<mojo::DataPipe> audio_data_pipe,
       std::unique_ptr<mojo::DataPipe> video_data_pipe,
       const RemotingSourceImpl::DataPipeStartCallback& done_callback);
 
   // Used by RemotingRendererImpl to query the session state.
   RemotingSourceImpl* remoting_source() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return remoting_source_.get();
   }
 
   base::WeakPtr<remoting::RpcBroker> GetRpcBroker() const;
 
-  PipelineMetadata pipeline_metadata() const {
-    DCHECK(thread_checker_.CalledOnValidThread());
-    return pipeline_metadata_;
-  }
-
  private:
   bool has_audio() const {
     return pipeline_metadata_.has_audio &&
            pipeline_metadata_.audio_decoder_config.IsValidConfig();
   }
 
   bool has_video() const {
     return pipeline_metadata_.has_video &&
            pipeline_metadata_.video_decoder_config.IsValidConfig();
   }
 
   bool IsVideoCodecSupported();
   bool IsAudioCodecSupported();
   bool IsRemoteSinkAvailable();
 
   // Helper to decide whether to enter or leave Remoting mode.
   bool ShouldBeRemoting();
 
   // Determines whether to enter or leave Remoting mode and switches if
   // necessary.
   void UpdateAndMaybeSwitch();
 
+  // Called when any of the following happens:
+  // 1. SetShowInterstitialCallback() is called (RemoteRendererImpl is
+  //    constructed);
+  // 2. The remoting session is shut down (to update the status message in the
+  //    interstitial).
+  // 3. The size of the canvas is changed (to update the background image and
+  //    the position of the status message).
+  // TODO(xjz): Call this when poster url is set/changed. Download poster image
+  // when available, and draw interstitial on it.
+  void UpdateInterstitial();
+
   // Indicates whether this media element or its ancestor is in full screen.
   bool is_fullscreen_ = false;
 
   // Indicates whether remoting is started.
   bool remote_rendering_started_ = false;
 
   // Indicates whether audio or video is encrypted.
   bool is_encrypted_ = false;
 
-  // Current audio/video config.
-  VideoDecoderConfig video_decoder_config_;
-  AudioDecoderConfig audio_decoder_config_;
-
   // Indicates whether remote playback is currently disabled. This starts out as
   // true, and should be updated at least once via a call to
   // OnRemotePlaybackDisabled() at some point in the future. A web page
   // typically sets/removes the disableRemotePlayback attribute on a
   // HTMLMediaElement to disable/enable remoting of its content. Please see the
   // Remote Playback API spec for more details:
   // https://w3c.github.io/remote-playback
   bool is_remote_playback_disabled_ = true;
 
   // Indicates whether video is the dominant visible content in the tab.
@@ skipping 11 matching lines @@
   // This is initially the RemotingSourceImpl passed to the ctor, and might be
   // replaced with a different instance later if OnSetCdm() is called.
   scoped_refptr<RemotingSourceImpl> remoting_source_;
 
   // This is used to check all the methods are called on the current thread in
   // debug builds.
   base::ThreadChecker thread_checker_;
 
   PipelineMetadata pipeline_metadata_;
 
+  // The callback to show remoting interstitial. It is set when entering the
+  // remoting mode (RemotingRendererImpl is constructed) by calling
+  // SetShowInterstitialCallback(), and is reset when leaving the remoting mode.
+  ShowInterstitialCallback show_interstitial_cb_;
+
   base::WeakPtrFactory<RemotingRendererController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RemotingRendererController);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_REMOTING_REMOTING_RENDERER_CONTROLLER_H_