Media Remoting: Remove old interstitial implementation.

media/remoting/courier_renderer.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_COURIER_RENDERER_H_
 #define MEDIA_REMOTING_COURIER_RENDERER_H_
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "base/synchronization/lock.h"
 #include "base/timer/timer.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/renderer.h"
 #include "media/mojo/interfaces/remoting.mojom.h"
-#include "media/remoting/interstitial.h"
 #include "media/remoting/metrics.h"
 #include "media/remoting/rpc_broker.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 
 namespace media {
 
 class RendererClient;
 class VideoRendererSink;
 
 namespace remoting {
 
 class DemuxerStreamAdapter;
 class RendererController;
 
 // A media::Renderer implementation that proxies all operations to a remote
 // renderer via RPCs. The CourierRenderer is instantiated by
 // AdaptiveRendererFactory when media remoting is meant to take place.
-//
-// While the media content is rendered remotely, the CourierRenderer emits
-// interstitial frames locally, to the VideoRendererSink, to indicate to the
-// user that remoting is taking place.
 class CourierRenderer : public Renderer {
  public:
   // The whole class except for constructor and GetMediaTime() runs on
   // |media_task_runner|. The constructor and GetMediaTime() run on render main
   // thread.
   CourierRenderer(scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
                   const base::WeakPtr<RendererController>& controller,
                   VideoRendererSink* video_renderer_sink);
   ~CourierRenderer() final;
 
@@ skipping 11 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<CourierRenderer> self,
       std::unique_ptr<pb::RpcMessage> message);
 
-  // Called to render the interstitial on the main thread. Then, trampoline to
-  // the media thread to have the CourierRenderer pass the resulting VideoFrame
-  // to the VideoRendererSink.
-  static void RenderInterstitialAndShow(
-      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-      base::WeakPtr<CourierRenderer> self,
-      const SkBitmap& background,
-      const gfx::Size& natural_size,
-      InterstitialType type);
-
  public:
   // media::Renderer implementation.
   void Initialize(MediaResource* media_resource,
                   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 32 matching lines @@
   void InitializeCallback(std::unique_ptr<pb::RpcMessage> message);
   void FlushUntilCallback();
   void SetCdmCallback(std::unique_ptr<pb::RpcMessage> message);
   void OnTimeUpdate(std::unique_ptr<pb::RpcMessage> message);
   void OnBufferingStateChange(std::unique_ptr<pb::RpcMessage> message);
   void OnVideoNaturalSizeChange(std::unique_ptr<pb::RpcMessage> message);
   void OnVideoOpacityChange(std::unique_ptr<pb::RpcMessage> message);
   void OnStatisticsUpdate(std::unique_ptr<pb::RpcMessage> message);
   void OnDurationChange(std::unique_ptr<pb::RpcMessage> message);
 
-  // Called to pass the newly-rendered interstitial VideoFrame to the
-  // VideoRendererSink.
-  void PaintInterstitial(scoped_refptr<VideoFrame> frame,
-                         InterstitialType type);
-
   // Called when |current_media_time_| is updated.
   void OnMediaTimeUpdated();
 
   // Called to update the |video_stats_queue_|.
   void UpdateVideoStatsQueue(int video_frames_decoded,
                              int video_frames_dropped);
 
   // Called to clear all recent measurements history and schedule resuming after
   // a stabilization period elapses.
   void ResetMeasurements();
@@ skipping 67 matching lines @@
 
   // Records events and measurements of interest.
   RendererMetricsRecorder metrics_recorder_;
 
   std::unique_ptr<base::TickClock> clock_;
 
   // A timer that polls the DemuxerStreamAdapters periodically to measure
   // the data flow rates for metrics.
   base::RepeatingTimer data_flow_poll_timer_;
 
-  // Current type of the interstitial frame.
-  InterstitialType interstitial_type_ = InterstitialType::BETWEEN_SESSIONS;
-
   base::WeakPtrFactory<CourierRenderer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CourierRenderer);
 };
 
 }  // namespace remoting
 }  // namespace media
 
 #endif  // MEDIA_REMOTING_COURIER_RENDERER_H_