[Cast] Cleanup: Remove TransportXXXXXSender, an unnecessary layer of indirection.

media/cast/cast_sender_impl.cc

 // Copyright 2013 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.
 #include "media/cast/cast_sender_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
@@ skipping 79 matching lines @@
   CHECK(cast_environment);
 }
 
 void CastSenderImpl::InitializeAudio(
     const AudioSenderConfig& audio_config,
     const CastInitializationCallback& cast_initialization_cb) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   CHECK(audio_config.use_external_encoder ||
         cast_environment_->HasAudioThread());
 
+  VLOG(1) << "CastSenderImpl@" << this << "::InitializeAudio()";
+
   audio_sender_.reset(
       new AudioSender(cast_environment_, audio_config, transport_sender_));
 
-  CastInitializationStatus status = audio_sender_->InitializationResult();
-
+  const CastInitializationStatus status = audio_sender_->InitializationResult();
   if (status == STATUS_AUDIO_INITIALIZED) {
     ssrc_of_audio_sender_ = audio_config.incoming_feedback_ssrc;
     audio_frame_input_ =
         new LocalAudioFrameInput(cast_environment_, audio_sender_->AsWeakPtr());
   }
   cast_initialization_cb.Run(status);
 }
 
 void CastSenderImpl::InitializeVideo(
     const VideoSenderConfig& video_config,
     const CastInitializationCallback& cast_initialization_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   CHECK(video_config.use_external_encoder ||
         cast_environment_->HasVideoThread());
-  VLOG(1) << "CastSender::ctor";
+
+  VLOG(1) << "CastSenderImpl@" << this << "::InitializeVideo()";
 
   video_sender_.reset(new VideoSender(cast_environment_,
                                       video_config,
                                       create_vea_cb,
                                       create_video_encode_mem_cb,
-                                      cast_initialization_cb,
                                       transport_sender_));
 
-  ssrc_of_video_sender_ = video_config.incoming_feedback_ssrc;
-  video_frame_input_ =
-      new LocalVideoFrameInput(cast_environment_, video_sender_->AsWeakPtr());
+  const CastInitializationStatus status = video_sender_->InitializationResult();
+  if (status == STATUS_VIDEO_INITIALIZED) {
+    ssrc_of_video_sender_ = video_config.incoming_feedback_ssrc;
+    video_frame_input_ =
+        new LocalVideoFrameInput(cast_environment_, video_sender_->AsWeakPtr());
+  }
+  cast_initialization_cb.Run(status);
 }
 
 CastSenderImpl::~CastSenderImpl() {
-  VLOG(1) << "CastSender::dtor";
+  VLOG(1) << "CastSenderImpl@" << this << "::~CastSenderImpl()";
 }
 
 // ReceivedPacket handle the incoming packets to the cast sender
 // it's only expected to receive RTCP feedback packets from the remote cast
 // receiver. The class verifies that that it is a RTCP packet and based on the
 // SSRC of the incoming packet route the packet to the correct sender; audio or
 // video.
 //
 // Definition of SSRC as defined in RFC 3550.
 // Synchronization source (SSRC): The source of a stream of RTP
@@ skipping 12 matching lines @@
 //    multimedia session; the binding of the SSRC identifiers is
 //    provided through RTCP (see Section 6.5.1).  If a participant
 //    generates multiple streams in one RTP session, for example from
 //    separate video cameras, each MUST be identified as a different
 //    SSRC.
 void CastSenderImpl::ReceivedPacket(scoped_ptr<Packet> packet) {
   DCHECK(cast_environment_);
   size_t length = packet->size();
   const uint8_t* data = &packet->front();
   if (!Rtcp::IsRtcpPacket(data, length)) {
-    // We should have no incoming RTP packets.
-    VLOG(1) << "Unexpectedly received a RTP packet in the cast sender";
+    VLOG(1) << "CastSenderImpl@" << this << "::ReceivedPacket() -- "
+            << "Received an invalid (non-RTCP?) packet in the cast sender.";
     return;
   }
   uint32 ssrc_of_sender = Rtcp::GetSsrcOfSender(data, length);
   if (ssrc_of_sender == ssrc_of_audio_sender_) {
     if (!audio_sender_) {
       NOTREACHED();
       return;
     }
     cast_environment_->PostTask(CastEnvironment::MAIN,
                                 FROM_HERE,
                                 base::Bind(&AudioSender::IncomingRtcpPacket,
                                            audio_sender_->AsWeakPtr(),
                                            base::Passed(&packet)));
   } else if (ssrc_of_sender == ssrc_of_video_sender_) {
     if (!video_sender_) {
       NOTREACHED();
       return;
     }
     cast_environment_->PostTask(CastEnvironment::MAIN,
                                 FROM_HERE,
                                 base::Bind(&VideoSender::IncomingRtcpPacket,
                                            video_sender_->AsWeakPtr(),
                                            base::Passed(&packet)));
   } else {
-    VLOG(1) << "Received a RTCP packet with a non matching sender SSRC "
+    VLOG(1) << "CastSenderImpl@" << this << "::ReceivedPacket() -- "
+            << "Received a RTCP packet with a non matching sender SSRC "
             << ssrc_of_sender;
   }
 }
 
 scoped_refptr<AudioFrameInput> CastSenderImpl::audio_frame_input() {
   return audio_frame_input_;
 }
 
 scoped_refptr<VideoFrameInput> CastSenderImpl::video_frame_input() {
   return video_frame_input_;
 }
 
 transport::PacketReceiverCallback CastSenderImpl::packet_receiver() {
   return base::Bind(&CastSenderImpl::ReceivedPacket,
                     weak_factory_.GetWeakPtr());
 }
 
 }  // namespace cast
 }  // namespace media