Media Remoting Clean-up: Less-redundant naming, style consistency, etc.

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_REMOTE_RENDERER_IMPL_H_
-#define MEDIA_REMOTING_REMOTE_RENDERER_IMPL_H_
+#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/buffering_state.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/renderer.h"
-#include "media/base/renderer_client.h"
 #include "media/mojo/interfaces/remoting.mojom.h"
+#include "media/remoting/interstitial.h"
 #include "media/remoting/metrics.h"
-#include "media/remoting/remoting_interstitial_ui.h"
-#include "media/remoting/rpc/rpc_broker.h"
+#include "media/remoting/rpc_broker.h"
 #include "mojo/public/cpp/system/data_pipe.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 
 namespace media {
 
-class RemotingRendererController;
-class Renderer;
+class RendererClient;
 
 namespace remoting {
-class RemoteDemuxerStreamAdapter;
-};
 
-// A media::Renderer implementation that use a media::Renderer to render
-// media streams.
-class RemoteRendererImpl : public Renderer {
+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.
-  RemoteRendererImpl(
-      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-      const base::WeakPtr<RemotingRendererController>&
-          remoting_renderer_controller,
-      VideoRendererSink* video_renderer_sink);
-  ~RemoteRendererImpl() final;
+  CourierRenderer(scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+                  const base::WeakPtr<RendererController>& controller,
+                  VideoRendererSink* video_renderer_sink);
+  ~CourierRenderer() final;
 
  private:
   // Callback when attempting to establish data pipe. The function is set to
   // static in order to post task to media thread in order to avoid threading
   // race condition.
   static void OnDataPipeCreatedOnMainThread(
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-      base::WeakPtr<RemoteRendererImpl> self,
-      base::WeakPtr<remoting::RpcBroker> rpc_broker,
+      base::WeakPtr<CourierRenderer> self,
+      base::WeakPtr<RpcBroker> rpc_broker,
       mojom::RemotingDataStreamSenderPtrInfo audio,
       mojom::RemotingDataStreamSenderPtrInfo video,
       mojo::ScopedDataPipeProducerHandle audio_handle,
       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);
+      base::WeakPtr<CourierRenderer> self,
+      std::unique_ptr<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,
+      base::WeakPtr<CourierRenderer> self,
       const base::Optional<SkBitmap>& background_image,
       const gfx::Size& canvas_size,
-      RemotingInterstitialType interstitial_type);
+      InterstitialType interstitial_type);
 
  public:
   // media::Renderer implementation.
   void Initialize(DemuxerStreamProvider* demuxer_stream_provider,
-                  media::RendererClient* client,
+                  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;
   void SetVolume(float volume) final;
   base::TimeDelta GetMediaTime() final;
 
  private:
-  friend class RemoteRendererImplTest;
+  friend class CourierRendererTest;
 
   enum State {
     STATE_UNINITIALIZED,
     STATE_CREATE_PIPE,
     STATE_ACQUIRING,
     STATE_INITIALIZING,
     STATE_FLUSHING,
     STATE_PLAYING,
     STATE_ERROR
   };
 
   // Callback when attempting to establish data pipe. Runs on media thread only.
   void OnDataPipeCreated(mojom::RemotingDataStreamSenderPtrInfo audio,
                          mojom::RemotingDataStreamSenderPtrInfo video,
                          mojo::ScopedDataPipeProducerHandle audio_handle,
                          mojo::ScopedDataPipeProducerHandle video_handle,
                          int audio_rpc_handle,
                          int video_rpc_handle);
 
   // Callback function when RPC message is received. Runs on media thread only.
-  void OnReceivedRpc(std::unique_ptr<remoting::pb::RpcMessage> message);
+  void OnReceivedRpc(std::unique_ptr<pb::RpcMessage> message);
 
   // Function to post task to main thread in order to send RPC message.
-  void SendRpcToRemote(std::unique_ptr<remoting::pb::RpcMessage> message);
+  void SendRpcToRemote(std::unique_ptr<pb::RpcMessage> message);
 
   // Functions when RPC message is received.
-  void AcquireRendererDone(std::unique_ptr<remoting::pb::RpcMessage> message);
-  void InitializeCallback(std::unique_ptr<remoting::pb::RpcMessage> message);
+  void AcquireRendererDone(std::unique_ptr<pb::RpcMessage> message);
+  void InitializeCallback(std::unique_ptr<pb::RpcMessage> message);
   void FlushUntilCallback();
-  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);
+  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 update the remoting interstitial. Update
   // |interstitial_background_| if |background_image| is set.
   void UpdateInterstitial(const base::Optional<SkBitmap>& background_image,
                           const gfx::Size& canvas_size,
-                          RemotingInterstitialType interstitial_type);
+                          InterstitialType interstitial_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();
 
   // Called when a fatal runtime error occurs. |stop_trigger| is the error code
-  // handed to the RemotingRendererController.
-  void OnFatalError(remoting::StopTrigger stop_trigger);
+  // handed to the RendererController.
+  void OnFatalError(StopTrigger stop_trigger);
 
   // Called periodically to measure the data flows from the
   // DemuxerStreamAdapters and record this information in the metrics.
   void MeasureAndRecordDataRates();
 
   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_;
 
   DemuxerStreamProvider* demuxer_stream_provider_;
-  media::RendererClient* client_;
-  std::unique_ptr<remoting::RemoteDemuxerStreamAdapter>
-      audio_demuxer_stream_adapter_;
-  std::unique_ptr<remoting::RemoteDemuxerStreamAdapter>
-      video_demuxer_stream_adapter_;
+  RendererClient* client_;
+  std::unique_ptr<DemuxerStreamAdapter> audio_demuxer_stream_adapter_;
+  std::unique_ptr<DemuxerStreamAdapter> video_demuxer_stream_adapter_;
 
   // Component to establish mojo remoting service on browser process.
-  const base::WeakPtr<RemotingRendererController> remoting_renderer_controller_;
+  const base::WeakPtr<RendererController> controller_;
   // Broker class to process incoming and outgoing RPC message.
-  const base::WeakPtr<remoting::RpcBroker> rpc_broker_;
-  // RPC handle value for RemoteRendererImpl component.
+  const base::WeakPtr<RpcBroker> rpc_broker_;
+  // RPC handle value for CourierRenderer component.
   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_;
 
@@ skipping 24 matching lines @@
   std::deque<std::tuple<base::TimeTicks, int, int>> video_stats_queue_;
 
   // The total number of frames decoded/dropped in the time window.
   int sum_video_frames_decoded_ = 0;
   int sum_video_frames_dropped_ = 0;
 
   // Records the number of consecutive times that remoting playback was delayed.
   int times_playback_delayed_ = 0;
 
   // Records events and measurements of interest.
-  remoting::RendererMetricsRecorder metrics_recorder_;
+  RendererMetricsRecorder metrics_recorder_;
 
-  // A timer that polls the RemoteDemuxerStreamAdapters periodically to measure
+  // A timer that polls the DemuxerStreamAdapters periodically to measure
   // the data flow rates for metrics.
   base::RepeatingTimer data_flow_poll_timer_;
 
-  base::WeakPtrFactory<RemoteRendererImpl> weak_factory_;
+  base::WeakPtrFactory<CourierRenderer> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(RemoteRendererImpl);
+  DISALLOW_COPY_AND_ASSIGN(CourierRenderer);
 };
 
+}  // namespace remoting
 }  // namespace media
 
-#endif  // MEDIA_REMOTING_REMOTE_RENDERER_IMPL_H_
+#endif  // MEDIA_REMOTING_COURIER_RENDERER_H_