Refactoring: CastTransport InitializeAudio/InitializeVideo.

media/cast/net/cast_transport.h

 // Copyright 2014 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.
 
 // This is the main interface for the cast transport sender.  It accepts encoded
 // frames (both audio and video), encrypts their encoded data, packetizes them
 // and feeds them into a transport (e.g., UDP).
 
 // Construction of the Cast Sender and the Cast Transport should be done
 // in the following order:
@@ skipping 67 matching lines @@
 // The application should only trigger this class from the transport thread.
 class CastTransport : public base::NonThreadSafe {
  public:
   // Interface used for receiving status updates, raw events, and RTP packets
   // from CastTransport.
   class Client {
    public:
     virtual ~Client(){};
 
     // Audio and Video transport status change is reported on this callback.
     virtual void OnStatusChanged(CastTransportStatus status) = 0;

[miu, 2016/07/14 22:00:41]

Just noticed this: I think you need to add a "ssrc" argument here. The impl of
this interface should be able to tell which stream is reporting on its status.
For example, if both audio and video streams are added, one of them could call
back with an INITIALIZED result while the other could call back with some other
error code.

[xjz, 2016/07/14 22:43:39]

It makes sense to add a "ssrc" argument for
TRANSPORT_STREAM_INITIALIZED/UNINITIALIZED status, but not for
TRANSPORT_SOCKET_ERROR status. Do you think it is good to still using the
original TRANSPORT_AUDIO/VIDEO_INITIALIZED/UNINITIALIZED status? In that way, we
can separate the audio/video status, but not for multiple audio (or video)
streams.

 
     // Raw events will be invoked on this callback periodically, according to
     // the configured logging flush interval passed to
     // CastTransport::Create().
     virtual void OnLoggingEventsReceived(
         std::unique_ptr<std::vector<FrameEvent>> frame_events,
         std::unique_ptr<std::vector<PacketEvent>> packet_events) = 0;
 
     // Called to pass RTP packets to the Client.
     virtual void ProcessRtpPacket(std::unique_ptr<Packet> packet) = 0;
   };
 
   static std::unique_ptr<CastTransport> Create(
       base::TickClock* clock,  // Owned by the caller.
       base::TimeDelta logging_flush_interval,
       std::unique_ptr<Client> client,
       std::unique_ptr<PacketTransport> transport,
       const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner);
 
   virtual ~CastTransport() {}
 
   // Audio/Video initialization.
   // Encoded frames cannot be transmitted until the relevant initialize method
   // is called.
-  virtual void InitializeAudio(const CastTransportRtpConfig& config,
-                               std::unique_ptr<RtcpObserver> rtcp_observer) {}
-  virtual void InitializeVideo(const CastTransportRtpConfig& config,
-                               std::unique_ptr<RtcpObserver> rtcp_observer) {}
+  virtual void InitializeStream(const CastTransportRtpConfig& config,
+                                std::unique_ptr<RtcpObserver> rtcp_observer) {}
 
   // Encrypt, packetize and transmit |frame|. |ssrc| must refer to a
   // a channel already established with InitializeAudio / InitializeVideo.
   virtual void InsertFrame(uint32_t ssrc, const EncodedFrame& frame) = 0;
 
   // Sends a RTCP sender report to the receiver.
   // |ssrc| is the SSRC for this report.
   // |current_time| is the current time reported by a tick clock.
   // |current_time_as_rtp_timestamp| is the corresponding RTP timestamp.
   virtual void SendSenderReport(uint32_t ssrc,
@@ skipping 43 matching lines @@
   virtual void SendRtcpFromRtpReceiver() = 0;
 
   // Set options for the PacedSender and Wifi.
   virtual void SetOptions(const base::DictionaryValue& options) = 0;
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_NET_CAST_TRANSPORT_H_