Remove default ViEEncoder encoder instance.

BUG=webrtc:1695
R=stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1341943003 .

Cr-Commit-Position: refs/heads/master@{#9940}
diff --git a/webrtc/video_engine/encoder_state_feedback_unittest.cc b/webrtc/video_engine/encoder_state_feedback_unittest.cc
index 4102367..9dc6c2f 100644
--- a/webrtc/video_engine/encoder_state_feedback_unittest.cc
+++ b/webrtc/video_engine/encoder_state_feedback_unittest.cc
@@ -31,7 +31,7 @@
 class MockVieEncoder : public ViEEncoder {
  public:
   explicit MockVieEncoder(ProcessThread* process_thread, PacedSender* pacer)
-      : ViEEncoder(1, 1, *process_thread, pacer, NULL, NULL, false) {}
+      : ViEEncoder(1, 1, *process_thread, pacer, NULL, NULL) {}
   ~MockVieEncoder() {}
 
   MOCK_METHOD1(OnReceivedIntraFrameRequest,
diff --git a/webrtc/video_engine/vie_channel_group.cc b/webrtc/video_engine/vie_channel_group.cc
index 25ef7dd..2eff0ca 100644
--- a/webrtc/video_engine/vie_channel_group.cc
+++ b/webrtc/video_engine/vie_channel_group.cc
@@ -190,19 +190,16 @@
                                      Transport* transport,
                                      int number_of_cores,
                                      const std::vector<uint32_t>& ssrcs) {
-  // TODO(pbos): Remove checks for empty ssrcs and add this check when there's
-  // no base channel.
-  // DCHECK(!ssrcs.empty());
+  DCHECK(!ssrcs.empty());
   rtc::scoped_ptr<ViEEncoder> vie_encoder(new ViEEncoder(
       channel_id, number_of_cores, *process_thread_, pacer_.get(),
-      bitrate_allocator_.get(), bitrate_controller_.get(), false));
+      bitrate_allocator_.get(), bitrate_controller_.get()));
   if (!vie_encoder->Init()) {
     return false;
   }
   ViEEncoder* encoder = vie_encoder.get();
   if (!CreateChannel(channel_id, engine_id, transport, number_of_cores,
-                     vie_encoder.release(), ssrcs.empty() ? 1 : ssrcs.size(),
-                     true)) {
+                     vie_encoder.release(), ssrcs.size(), true)) {
     return false;
   }
   ViEChannel* channel = channel_map_[channel_id];
@@ -210,11 +207,9 @@
   encoder->StartThreadsAndSetSharedMembers(channel->send_payload_router(),
                                            channel->vcm_protection_callback());
 
-  if (!ssrcs.empty()) {
-    encoder_state_feedback_->AddEncoder(ssrcs, encoder);
-    std::vector<uint32_t> first_ssrc(1, ssrcs[0]);
-    encoder->SetSsrcs(first_ssrc);
-  }
+  encoder_state_feedback_->AddEncoder(ssrcs, encoder);
+  std::vector<uint32_t> first_ssrc(1, ssrcs[0]);
+  encoder->SetSsrcs(first_ssrc);
   return true;
 }
 
diff --git a/webrtc/video_engine/vie_encoder.cc b/webrtc/video_engine/vie_encoder.cc
index 07efd18..df3a4d4 100644
--- a/webrtc/video_engine/vie_encoder.cc
+++ b/webrtc/video_engine/vie_encoder.cc
@@ -106,11 +106,9 @@
                        ProcessThread& module_process_thread,
                        PacedSender* pacer,
                        BitrateAllocator* bitrate_allocator,
-                       BitrateController* bitrate_controller,
-                       bool disable_default_encoder)
+                       BitrateController* bitrate_controller)
     : channel_id_(channel_id),
       number_of_cores_(number_of_cores),
-      disable_default_encoder_(disable_default_encoder),
       vpm_(VideoProcessingModule::Create(ViEModuleId(-1, channel_id))),
       qm_callback_(new QMVideoSettingsCallback(vpm_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
@@ -123,7 +121,7 @@
       bitrate_allocator_(bitrate_allocator),
       bitrate_controller_(bitrate_controller),
       time_of_last_frame_activity_ms_(0),
-      send_padding_(false),
+      simulcast_enabled_(false),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
@@ -151,27 +149,6 @@
   // Enable/disable content analysis: off by default for now.
   vpm_->EnableContentAnalysis(false);
 
-  if (!disable_default_encoder_) {
-#ifdef VIDEOCODEC_VP8
-    VideoCodecType codec_type = webrtc::kVideoCodecVP8;
-#else
-    VideoCodecType codec_type = webrtc::kVideoCodecI420;
-#endif
-    VideoCodec video_codec;
-    if (vcm_->Codec(codec_type, &video_codec) != VCM_OK) {
-      return false;
-    }
-    {
-      CriticalSectionScoped cs(data_cs_.get());
-      send_padding_ = video_codec.numberOfSimulcastStreams > 1;
-    }
-    if (vcm_->RegisterSendCodec(
-            &video_codec, number_of_cores_,
-            static_cast<uint32_t>(PayloadRouter::DefaultMaxPayloadLength())) !=
-        0) {
-      return false;
-    }
-  }
   if (vcm_->RegisterTransportCallback(this) != 0) {
     return false;
   }
@@ -271,45 +248,9 @@
 }
 
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
-  DCHECK(send_payload_router_ != NULL);
-  webrtc::VideoCodec current_send_codec;
-  if (vcm_->SendCodec(&current_send_codec) == VCM_OK) {
-    uint32_t current_bitrate_bps = 0;
-    if (vcm_->Bitrate(&current_bitrate_bps) != 0) {
-      LOG(LS_WARNING) << "Failed to get the current encoder target bitrate.";
-    }
-    current_send_codec.startBitrate = (current_bitrate_bps + 500) / 1000;
-  }
-
   if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
     return -1;
   }
-
-  if (disable_default_encoder_)
-    return 0;
-
-  // If the external encoder is the current send codec, use vcm internal
-  // encoder.
-  if (current_send_codec.plType == pl_type) {
-    {
-      CriticalSectionScoped cs(data_cs_.get());
-      send_padding_ = current_send_codec.numberOfSimulcastStreams > 1;
-    }
-    // TODO(mflodman): Unfortunately the VideoCodec that VCM has cached a
-    // raw pointer to an |extra_options| that's long gone.  Clearing it here is
-    // a hack to prevent the following code from crashing.  This should be fixed
-    // for realz.  https://code.google.com/p/chromium/issues/detail?id=348222
-    current_send_codec.extra_options = NULL;
-    size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
-    if (vcm_->RegisterSendCodec(
-            &current_send_codec, number_of_cores_,
-            static_cast<uint32_t>(max_data_payload_length)) != VCM_OK) {
-      LOG(LS_INFO) << "De-registered the currently used external encoder ("
-                   << static_cast<int>(pl_type) << ") and therefore tried to "
-                   << "register the corresponding internal encoder, but none "
-                   << "was supported.";
-    }
-  }
   return 0;
 }
 
@@ -323,7 +264,7 @@
 
   {
     CriticalSectionScoped cs(data_cs_.get());
-    send_padding_ = video_codec.numberOfSimulcastStreams > 1;
+    simulcast_enabled_ = video_codec.numberOfSimulcastStreams > 1;
   }
 
   // Add a bitrate observer to the allocator and update the start, max and
@@ -402,8 +343,8 @@
   int bitrate_bps;
   {
     CriticalSectionScoped cs(data_cs_.get());
-    bool send_padding =
-        send_padding_ || video_suspended_ || min_transmit_bitrate_kbps_ > 0;
+    bool send_padding = simulcast_enabled_ || video_suspended_ ||
+                        min_transmit_bitrate_kbps_ > 0;
     if (!send_padding)
       return 0;
     time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
diff --git a/webrtc/video_engine/vie_encoder.h b/webrtc/video_engine/vie_encoder.h
index e346f52..9edd5bf 100644
--- a/webrtc/video_engine/vie_encoder.h
+++ b/webrtc/video_engine/vie_encoder.h
@@ -76,8 +76,7 @@
              ProcessThread& module_process_thread,
              PacedSender* pacer,
              BitrateAllocator* bitrate_allocator,
-             BitrateController* bitrate_controller,
-             bool disable_default_encoder);
+             BitrateController* bitrate_controller);
   ~ViEEncoder();
 
   bool Init();
@@ -193,7 +192,6 @@
 
   const int channel_id_;
   const uint32_t number_of_cores_;
-  const bool disable_default_encoder_;
 
   const rtc::scoped_ptr<VideoProcessingModule> vpm_;
   const rtc::scoped_ptr<QMVideoSettingsCallback> qm_callback_;
@@ -212,7 +210,7 @@
   // track when video is stopped long enough that we also want to stop sending
   // padding.
   int64_t time_of_last_frame_activity_ms_ GUARDED_BY(data_cs_);
-  bool send_padding_ GUARDED_BY(data_cs_);
+  bool simulcast_enabled_ GUARDED_BY(data_cs_);
   int min_transmit_bitrate_kbps_ GUARDED_BY(data_cs_);
   uint32_t last_observed_bitrate_bps_ GUARDED_BY(data_cs_);
   int target_delay_ms_ GUARDED_BY(data_cs_);