Refactoring: Hide VideoCodec.codecSpecific as "private"

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

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 271 matching lines @@
         helper_->factory()->encoders()[stream_index]->codec();
     EXPECT_EQ(ref.codecType, target.codecType);
     EXPECT_EQ(0, strcmp(ref.plName, target.plName));
     EXPECT_EQ(ref.plType, target.plType);
     EXPECT_EQ(ref.width, target.width);
     EXPECT_EQ(ref.height, target.height);
     EXPECT_EQ(ref.startBitrate, target.startBitrate);
     EXPECT_EQ(ref.maxBitrate, target.maxBitrate);
     EXPECT_EQ(ref.minBitrate, target.minBitrate);
     EXPECT_EQ(ref.maxFramerate, target.maxFramerate);
-    EXPECT_EQ(ref.codecSpecific.VP8.pictureLossIndicationOn,
-              target.codecSpecific.VP8.pictureLossIndicationOn);
-    EXPECT_EQ(ref.codecSpecific.VP8.feedbackModeOn,
-              target.codecSpecific.VP8.feedbackModeOn);
-    EXPECT_EQ(ref.codecSpecific.VP8.complexity,
-              target.codecSpecific.VP8.complexity);
-    EXPECT_EQ(ref.codecSpecific.VP8.resilience,
-              target.codecSpecific.VP8.resilience);
-    EXPECT_EQ(ref.codecSpecific.VP8.numberOfTemporalLayers,
-              target.codecSpecific.VP8.numberOfTemporalLayers);
-    EXPECT_EQ(ref.codecSpecific.VP8.denoisingOn,
-              target.codecSpecific.VP8.denoisingOn);
-    EXPECT_EQ(ref.codecSpecific.VP8.errorConcealmentOn,
-              target.codecSpecific.VP8.errorConcealmentOn);
-    EXPECT_EQ(ref.codecSpecific.VP8.automaticResizeOn,
-              target.codecSpecific.VP8.automaticResizeOn);
-    EXPECT_EQ(ref.codecSpecific.VP8.frameDroppingOn,
-              target.codecSpecific.VP8.frameDroppingOn);
-    EXPECT_EQ(ref.codecSpecific.VP8.keyFrameInterval,
-              target.codecSpecific.VP8.keyFrameInterval);
-    EXPECT_EQ(ref.codecSpecific.VP8.tl_factory,
-              target.codecSpecific.VP8.tl_factory);
+    EXPECT_EQ(ref.VP8().pictureLossIndicationOn,
+              target.VP8().pictureLossIndicationOn);
+    EXPECT_EQ(ref.VP8().feedbackModeOn, target.VP8().feedbackModeOn);
+    EXPECT_EQ(ref.VP8().complexity, target.VP8().complexity);
+    EXPECT_EQ(ref.VP8().resilience, target.VP8().resilience);
+    EXPECT_EQ(ref.VP8().numberOfTemporalLayers,
+              target.VP8().numberOfTemporalLayers);
+    EXPECT_EQ(ref.VP8().denoisingOn, target.VP8().denoisingOn);
+    EXPECT_EQ(ref.VP8().errorConcealmentOn, target.VP8().errorConcealmentOn);
+    EXPECT_EQ(ref.VP8().automaticResizeOn, target.VP8().automaticResizeOn);
+    EXPECT_EQ(ref.VP8().frameDroppingOn, target.VP8().frameDroppingOn);
+    EXPECT_EQ(ref.VP8().keyFrameInterval, target.VP8().keyFrameInterval);
+    EXPECT_EQ(ref.VP8().tl_factory, target.VP8().tl_factory);
     EXPECT_EQ(ref.qpMax, target.qpMax);
     EXPECT_EQ(0, target.numberOfSimulcastStreams);
     EXPECT_EQ(ref.mode, target.mode);
 
     // No need to compare simulcastStream as numberOfSimulcastStreams should
     // always be 0.
   }
 
   void InitRefCodec(int stream_index, VideoCodec* ref_codec) {
     *ref_codec = codec_;
-    ref_codec->codecSpecific.VP8.numberOfTemporalLayers =
+    ref_codec->VP8()->numberOfTemporalLayers =
         kTestTemporalLayerProfile[stream_index];
     ref_codec->width = codec_.simulcastStream[stream_index].width;
     ref_codec->height = codec_.simulcastStream[stream_index].height;
     ref_codec->maxBitrate = codec_.simulcastStream[stream_index].maxBitrate;
     ref_codec->minBitrate = codec_.simulcastStream[stream_index].minBitrate;
     ref_codec->qpMax = codec_.simulcastStream[stream_index].qpMax;
   }
 
   void VerifyCodecSettings() {
     EXPECT_EQ(3u, helper_->factory()->encoders().size());
     VideoCodec ref_codec;
 
     // stream 0, the lowest resolution stream.
     InitRefCodec(0, &ref_codec);
     ref_codec.qpMax = 45;
-    ref_codec.codecSpecific.VP8.complexity = webrtc::kComplexityHigher;
-    ref_codec.codecSpecific.VP8.denoisingOn = false;
+    ref_codec.VP8()->complexity = webrtc::kComplexityHigher;
+    ref_codec.VP8()->denoisingOn = false;
     ref_codec.startBitrate = 100;  // Should equal to the target bitrate.
     VerifyCodec(ref_codec, 0);
 
     // stream 1
     InitRefCodec(1, &ref_codec);
-    ref_codec.codecSpecific.VP8.denoisingOn = false;
+    ref_codec.VP8()->denoisingOn = false;
     // The start bitrate (300kbit) minus what we have for the lower layers
     // (100kbit).
     ref_codec.startBitrate = 200;
     VerifyCodec(ref_codec, 1);
 
     // stream 2, the biggest resolution stream.
     InitRefCodec(2, &ref_codec);
     // We don't have enough bits to send this, so the adapter should have
     // configured it to use the min bitrate for this layer (600kbit) but turn
     // off sending.
@@ skipping 182 matching lines @@
       kDefaultWidth, kDefaultHeight, kDefaultWidth, half_width, half_width);
   input_buffer->InitializeData();
   VideoFrame input_frame(input_buffer, 0, 0, webrtc::kVideoRotation_0);
   std::vector<FrameType> frame_types(3, kVideoFrameKey);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE,
             adapter_->Encode(input_frame, nullptr, &frame_types));
 }
 
 }  // namespace testing
 }  // namespace webrtc