Add end-to-end H.264 packetization test.

Also correctly wires up H.264 packetization in the new Call api.

R=pbos@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/20079004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6835 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/video/end_to_end_tests.cc

diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 8b64f14..44c41b1 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -209,6 +209,57 @@
   DestroyStreams();
 }
 
+TEST_F(EndToEndTest, SendsAndReceivesH264) {
+  class H264Observer : public test::EndToEndTest, public VideoRenderer {
+   public:
+    H264Observer()
+        : EndToEndTest(2 * kDefaultTimeoutMs),
+          fake_encoder_(Clock::GetRealTimeClock()),
+          frame_counter_(0) {}
+
+    virtual void PerformTest() OVERRIDE {
+      EXPECT_EQ(kEventSignaled, Wait())
+          << "Timed out while waiting for enough frames to be decoded.";
+    }
+
+    virtual void ModifyConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoStream>* video_streams) {
+      send_config->encoder_settings.encoder = &fake_encoder_;
+      send_config->encoder_settings.payload_name = "H264";
+      send_config->encoder_settings.payload_type = kFakeSendPayloadType;
+      (*video_streams)[0].min_bitrate_bps = 50000;
+      (*video_streams)[0].target_bitrate_bps =
+          (*video_streams)[0].max_bitrate_bps = 2000000;
+
+      (*receive_configs)[0].renderer = this;
+      VideoCodec codec =
+          test::CreateDecoderVideoCodec(send_config->encoder_settings);
+      (*receive_configs)[0].codecs.resize(1);
+      (*receive_configs)[0].codecs[0] = codec;
+      (*receive_configs)[0].external_decoders.resize(1);
+      (*receive_configs)[0].external_decoders[0].payload_type =
+          send_config->encoder_settings.payload_type;
+      (*receive_configs)[0].external_decoders[0].decoder = &fake_decoder_;
+    }
+
+    virtual void RenderFrame(const I420VideoFrame& video_frame,
+                             int time_to_render_ms) OVERRIDE {
+      const int kRequiredFrames = 500;
+      if (++frame_counter_ == kRequiredFrames)
+        observation_complete_->Set();
+    }
+
+   private:
+    test::FakeH264Decoder fake_decoder_;
+    test::FakeH264Encoder fake_encoder_;
+    int frame_counter_;
+  } test;
+
+  RunBaseTest(&test);
+}
+
 TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
   class SyncRtcpObserver : public test::EndToEndTest {
    public:

webrtc/video/video_send_stream.cc

diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 4e6b2ba..6597029 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -304,9 +304,13 @@
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
-  video_codec.codecType =
-      (config_.encoder_settings.payload_name == "VP8" ? kVideoCodecVP8
-                                                      : kVideoCodecGeneric);
+  if (config_.encoder_settings.payload_name == "VP8") {
+    video_codec.codecType = kVideoCodecVP8;
+  } else if (config_.encoder_settings.payload_name == "H264") {
+    video_codec.codecType = kVideoCodecH264;
+  } else {
+    video_codec.codecType = kVideoCodecGeneric;
+  }
 
   if (video_codec.codecType == kVideoCodecVP8) {
     video_codec.codecSpecific.VP8.resilience = kResilientStream;
@@ -316,6 +320,10 @@
     video_codec.codecSpecific.VP8.automaticResizeOn = false;
     video_codec.codecSpecific.VP8.frameDroppingOn = true;
     video_codec.codecSpecific.VP8.keyFrameInterval = 3000;
+  } else if (video_codec.codecType == kVideoCodecH264) {
+    video_codec.codecSpecific.H264.profile = kProfileBase;
+    video_codec.codecSpecific.H264.frameDroppingOn = true;
+    video_codec.codecSpecific.H264.keyFrameInterval = 3000;
   }
 
   if (video_codec.codecType == kVideoCodecVP8) {