Media Remoting: Update remoting interstitial when status changes.

media/remoting/remote_renderer_impl.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_REMOTE_RENDERER_IMPL_H_
 #define MEDIA_REMOTING_REMOTE_RENDERER_IMPL_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 49 matching lines @@
       mojo::ScopedDataPipeProducerHandle video_handle);
 
   // Callback function when RPC message is received. The function is set to
   // static in order to post task to media thread in order to avoid threading
   // race condition.
   static void OnMessageReceivedOnMainThread(
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
       base::WeakPtr<RemoteRendererImpl> self,
       std::unique_ptr<remoting::pb::RpcMessage> message);
 
+  // Callback when remoting interstitial needs to be updated. Will post task to
+  // media thread to avoid threading race condition.
+  static void RequestUpdateInterstitialOnMainThread(
+      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+      base::WeakPtr<RemoteRendererImpl> remote_renderer_impl,
+      VideoRendererSink* video_renderer_sink,
+      const SkBitmap& background_image,
+      const gfx::Size& canvas_size,
+      RemotingInterstitialType interstitial_type);
+
  public:
   // media::Renderer implementation.
   void Initialize(DemuxerStreamProvider* demuxer_stream_provider,
                   media::RendererClient* client,
                   const PipelineStatusCB& init_cb) final;
   void SetCdm(CdmContext* cdm_context,
               const CdmAttachedCB& cdm_attached_cb) final;
   void Flush(const base::Closure& flush_cb) final;
   void StartPlayingFrom(base::TimeDelta time) final;
   void SetPlaybackRate(double playback_rate) final;
@@ skipping 34 matching lines @@
   void SetCdmCallback(std::unique_ptr<remoting::pb::RpcMessage> message);
   void OnTimeUpdate(std::unique_ptr<remoting::pb::RpcMessage> message);
   void OnBufferingStateChange(
       std::unique_ptr<remoting::pb::RpcMessage> message);
   void OnVideoNaturalSizeChange(
       std::unique_ptr<remoting::pb::RpcMessage> message);
   void OnVideoOpacityChange(std::unique_ptr<remoting::pb::RpcMessage> message);
   void OnStatisticsUpdate(std::unique_ptr<remoting::pb::RpcMessage> message);
   void OnDurationChange(std::unique_ptr<remoting::pb::RpcMessage> message);
 
+  // Called to update the remoting interstitial.
+  void UpdateInterstitial(VideoRendererSink* video_renderer_sink,
+                          const SkBitmap& background_image,
+                          const gfx::Size& canvas_size,
+                          RemotingInterstitialType interstitial_type);
+
   // Shut down remoting session.
   void OnFatalError(PipelineStatus status);
 
-  // Show interstial accordingly.
-  void UpdateInterstitial();
-
   State state_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
   // Current renderer playback time information.
   base::TimeDelta current_media_time_;
   base::TimeDelta current_max_time_;
   // Both |current_media_time_| and |current_max_time_| should be protected by
   // lock because it can be accessed from both media and render main thread.
   base::Lock time_lock_;
@@ skipping 13 matching lines @@
   const int rpc_handle_;
 
   // RPC handle value for render on receiver endpoint.
   int remote_renderer_handle_;
 
   // Callbacks.
   PipelineStatusCB init_workflow_done_callback_;
   CdmAttachedCB cdm_attached_cb_;
   base::Closure flush_cb_;
 
-  RemotingInterstitialUI interstitial_ui_;
-
   base::WeakPtrFactory<RemoteRendererImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteRendererImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_REMOTING_REMOTE_RENDERER_IMPL_H_