Add codec name to CodecSpecificInfo and get the codec name stats from there instead.

webrtc/video/video_encoder_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/video_encoder.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/include/video_error_codes.h"
 
 namespace webrtc {
 
 const int kWidth = 320;
 const int kHeight = 240;
 const size_t kMaxPayloadSize = 800;
 
 class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test {
  protected:
   VideoEncoderSoftwareFallbackWrapperTest()
       : fallback_wrapper_(kVideoCodecVP8, &fake_encoder_) {}
 
   class CountingFakeEncoder : public VideoEncoder {
    public:
     int32_t InitEncode(const VideoCodec* codec_settings,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       ++init_encode_count_;
       return init_encode_return_code_;
     }
     int32_t Encode(const VideoFrame& frame,
                    const CodecSpecificInfo* codec_specific_info,
                    const std::vector<FrameType>* frame_types) override {
       ++encode_count_;
+      if (encode_complete_callback_ &&
+          encode_return_code_ == WEBRTC_VIDEO_CODEC_OK) {
+        CodecSpecificInfo info;
+        info.codec_name = ImplementationName();
+        encode_complete_callback_->OnEncodedImage(EncodedImage(), &info,
+                                                  nullptr);
+      }
       return encode_return_code_;
     }
 
     int32_t RegisterEncodeCompleteCallback(
         EncodedImageCallback* callback) override {
       encode_complete_callback_ = callback;
       return WEBRTC_VIDEO_CODEC_OK;
     }
 
     int32_t Release() override {
@@ skipping 34 matching lines @@
     mutable int supports_native_handle_count_ = 0;
   };
 
   class FakeEncodedImageCallback : public EncodedImageCallback {
    public:
     Result OnEncodedImage(
         const EncodedImage& encoded_image,
         const CodecSpecificInfo* codec_specific_info,
         const RTPFragmentationHeader* fragmentation) override {
       ++callback_count_;
+      last_codec_name_ = codec_specific_info->codec_name;
       return Result(Result::OK, callback_count_);
     }
     int callback_count_ = 0;
+    std::string last_codec_name_;
   };
 
   void UtilizeFallbackEncoder();
   void FallbackFromEncodeRequest();
   void EncodeFrame();
+  void CheckLastEncoderName(const char* expected_name) {
+    EXPECT_STREQ(expected_name, callback_.last_codec_name_.c_str());
+  }
 
   FakeEncodedImageCallback callback_;
   CountingFakeEncoder fake_encoder_;
   VideoEncoderSoftwareFallbackWrapper fallback_wrapper_;
   VideoCodec codec_ = {};
   VideoFrame frame_;
 };
 
 void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame() {
   frame_.CreateEmptyFrame(kWidth, kHeight, kWidth, (kWidth + 1) / 2,
@@ skipping 147 matching lines @@
 }
 
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        SupportsNativeHandleNotForwardedDuringFallback) {
   UtilizeFallbackEncoder();
   fallback_wrapper_.SupportsNativeHandle();
   EXPECT_EQ(0, fake_encoder_.supports_native_handle_count_);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }
 
+TEST_F(VideoEncoderSoftwareFallbackWrapperTest, ReportsImplementationName) {
+  VideoCodec codec = {};
+  fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
+  fallback_wrapper_.InitEncode(&codec, 2, kMaxPayloadSize);
+  EncodeFrame();
+  CheckLastEncoderName("fake-encoder");
+}
+
 TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
        ReportsFallbackImplementationName) {
   UtilizeFallbackEncoder();
   // Hard coded expected value since libvpx is the software implementation name
   // for VP8. Change accordingly if the underlying implementation does.
-  EXPECT_STREQ("libvpx (fallback from: fake-encoder)",
-               fallback_wrapper_.ImplementationName());
+  CheckLastEncoderName("libvpx");
 }
 
 }  // namespace webrtc