Name SimulcastEncoderApdater on InitEncode.

Provides a better string (provides names of all implementations), but
also fixes a crash when accessing the ImplementationName() of
SimulcastEncoderAdapter where InitEncode has failed.

BUG=chromium:577932, webrtc:4897
R=stefan@webrtc.org

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

Cr-Commit-Position: refs/heads/master@{#11321}

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc

@@ -136,7 +136,9 @@ class AdapterEncodedImageCallback : public webrtc::EncodedImageCallback {
 namespace webrtc {
 
 SimulcastEncoderAdapter::SimulcastEncoderAdapter(VideoEncoderFactory* factory)
-    : factory_(factory), encoded_complete_callback_(NULL) {
+    : factory_(factory),
+      encoded_complete_callback_(NULL),
+      implementation_name_("SimulcastEncoderAdapter") {
   memset(&codec_, 0, sizeof(webrtc::VideoCodec));
 }
 
@@ -192,6 +194,7 @@ int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst,
     codec_.codecSpecific.VP8.tl_factory = screensharing_tl_factory_.get();
   }
 
+  std::string implementation_name;
   // Create |number_of_streams| of encoder instances and init them.
   for (int i = 0; i < number_of_streams; ++i) {
     VideoCodec stream_codec;
@@ -221,7 +224,12 @@ int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst,
     encoder->RegisterEncodeCompleteCallback(callback);
     streaminfos_.push_back(StreamInfo(encoder, callback, stream_codec.width,
                                       stream_codec.height, send_stream));
+    if (i != 0)
+      implementation_name += ", ";
+    implementation_name += streaminfos_[i].encoder->ImplementationName();
   }
+  implementation_name_ =
+      "SimulcastEncoderAdapter (" + implementation_name + ")";
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
@@ -494,10 +502,7 @@ bool SimulcastEncoderAdapter::SupportsNativeHandle() const {
 }
 
 const char* SimulcastEncoderAdapter::ImplementationName() const {
-  // We should not be calling this method before streaminfos_ are configured.
+  return implementation_name_.c_str();
-  RTC_DCHECK(!streaminfos_.empty());
-  // TODO(pbos): Support multiple implementation names for different encoders.
-  return streaminfos_[0].encoder->ImplementationName();
 }
 
 }  // namespace webrtc

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h

@@ -12,6 +12,7 @@
 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_ENCODER_ADAPTER_H_
 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_ENCODER_ADAPTER_H_
 
+#include <string>
 #include <vector>
 
 #include "webrtc/base/scoped_ptr.h"
@@ -114,6 +115,7 @@ class SimulcastEncoderAdapter : public VP8Encoder {
   VideoCodec codec_;
   std::vector<StreamInfo> streaminfos_;
   EncodedImageCallback* encoded_complete_callback_;
+  std::string implementation_name_;
 };
 
 }  // namespace webrtc

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc

@@ -152,6 +152,8 @@ class MockVideoEncoder : public VideoEncoder {
     supports_native_handle_ = enabled;
   }
 
+  MOCK_CONST_METHOD0(ImplementationName, const char*());
+
  private:
   bool supports_native_handle_ = false;
   VideoCodec codec_;
@@ -162,6 +164,10 @@ class MockVideoEncoderFactory : public VideoEncoderFactory {
  public:
   VideoEncoder* Create() override {
     MockVideoEncoder* encoder = new MockVideoEncoder();
+    const char* encoder_name = encoder_names_.empty()
+                                   ? "codec_implementation_name"
+                                   : encoder_names_[encoders_.size()];
+    ON_CALL(*encoder, ImplementationName()).WillByDefault(Return(encoder_name));
     encoders_.push_back(encoder);
     return encoder;
   }
@@ -171,9 +177,13 @@ class MockVideoEncoderFactory : public VideoEncoderFactory {
   virtual ~MockVideoEncoderFactory() {}
 
   const std::vector<MockVideoEncoder*>& encoders() const { return encoders_; }
+  void SetEncoderNames(const std::vector<const char*>& encoder_names) {
+    encoder_names_ = encoder_names;
+  }
 
  private:
   std::vector<MockVideoEncoder*> encoders_;
+  std::vector<const char*> encoder_names_;
 };
 
 class TestSimulcastEncoderAdapterFakeHelper {
@@ -397,6 +407,20 @@ TEST_F(TestSimulcastEncoderAdapterFake, SupportsNativeHandleForSingleStreams) {
   EXPECT_FALSE(adapter_->SupportsNativeHandle());
 }
 
+TEST_F(TestSimulcastEncoderAdapterFake, SupportsImplementationName) {
+  EXPECT_STREQ("SimulcastEncoderAdapter", adapter_->ImplementationName());
+  TestVp8Simulcast::DefaultSettings(
+      &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  std::vector<const char*> encoder_names;
+  encoder_names.push_back("codec1");
+  encoder_names.push_back("codec2");
+  encoder_names.push_back("codec3");
+  helper_->factory()->SetEncoderNames(encoder_names);
+  EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
+  EXPECT_STREQ("SimulcastEncoderAdapter (codec1, codec2, codec3)",
+               adapter_->ImplementationName());
+}
+
 TEST_F(TestSimulcastEncoderAdapterFake,
        SupportsNativeHandleDisabledForMultipleStreams) {
   // TODO(pbos): Implement actual test (verify that it works) when implemented