[Cast] Clean-up: Merge AudioReceiverConfig+VideoReceiverConfig-->FrameReceiverConfig.

media/cast/video_receiver/video_receiver.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/video_receiver/video_receiver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/video_receiver/video_decoder.h"
 
 namespace {
 const int kMinSchedulingDelayMs = 1;
 }  // namespace
 
 namespace media {
 namespace cast {
 
 VideoReceiver::VideoReceiver(scoped_refptr<CastEnvironment> cast_environment,
-                             const VideoReceiverConfig& video_config,
+                             const FrameReceiverConfig& video_config,
                              transport::PacedPacketSender* const packet_sender)
     : RtpReceiver(cast_environment->Clock(), NULL, &video_config),
       cast_environment_(cast_environment),
       event_subscriber_(kReceiverRtcpEventHistorySize, VIDEO_EVENT),
-      codec_(video_config.codec),
+      codec_(video_config.codec.video),
       target_playout_delay_(
           base::TimeDelta::FromMilliseconds(video_config.rtp_max_delay_ms)),
       expected_frame_duration_(
           base::TimeDelta::FromSeconds(1) / video_config.max_frame_rate),
       reports_are_scheduled_(false),
       framer_(cast_environment->Clock(),
               this,
               video_config.incoming_ssrc,
-              video_config.decoder_faster_than_max_frame_rate,
+              true,
               video_config.rtp_max_delay_ms * video_config.max_frame_rate /
                   1000),
       rtcp_(cast_environment_,
             NULL,
             NULL,
             packet_sender,
             GetStatistics(),
             video_config.rtcp_mode,
             base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
             video_config.feedback_ssrc,
             video_config.incoming_ssrc,
             video_config.rtcp_c_name,
             false),
       is_waiting_for_consecutive_frame_(false),
       lip_sync_drift_(ClockDriftSmoother::GetDefaultTimeConstant()),
       weak_factory_(this) {
   DCHECK_GT(video_config.rtp_max_delay_ms, 0);
   DCHECK_GT(video_config.max_frame_rate, 0);
-  if (!video_config.use_external_decoder) {
-    video_decoder_.reset(new VideoDecoder(cast_environment, video_config));
-  }
+  video_decoder_.reset(new VideoDecoder(cast_environment, video_config));
   decryptor_.Initialize(video_config.aes_key, video_config.aes_iv_mask);
   rtcp_.SetTargetDelay(target_playout_delay_);
   cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_);
   memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
 }
 
 VideoReceiver::~VideoReceiver() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber_);
 }
@@ skipping 301 matching lines @@
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_.SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media