Refactoring: Hide VideoCodec.codecSpecific as "private"

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

 /*
  *  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 128 matching lines @@
  private:
   int decoded_frames_;
 };
 
 class SkipEncodingUnusedStreamsTest {
  public:
   std::vector<unsigned int> RunTest(VP8Encoder* encoder,
                                     VideoCodec* settings,
                                     uint32_t target_bitrate) {
     SpyingTemporalLayersFactory spy_factory;
-    settings->codecSpecific.VP8.tl_factory = &spy_factory;
+    settings->VP8()->tl_factory = &spy_factory;
     EXPECT_EQ(0, encoder->InitEncode(settings, 1, 1200));
 
     encoder->SetRates(target_bitrate, 30);
 
     std::vector<unsigned int> configured_bitrates;
     for (std::vector<TemporalLayers*>::const_iterator it =
              spy_factory.spying_layers_.begin();
          it != spy_factory.spying_layers_.end(); ++it) {
       configured_bitrates.push_back(
           static_cast<SpyingTemporalLayers*>(*it)->configured_bitrate_);
@@ skipping 114 matching lines @@
     ASSERT_EQ(3, kNumberOfSimulcastStreams);
     ConfigureStream(kDefaultWidth / 4, kDefaultHeight / 4, kMaxBitrates[0],
                     kMinBitrates[0], kTargetBitrates[0],
                     &settings->simulcastStream[0], temporal_layer_profile[0]);
     ConfigureStream(kDefaultWidth / 2, kDefaultHeight / 2, kMaxBitrates[1],
                     kMinBitrates[1], kTargetBitrates[1],
                     &settings->simulcastStream[1], temporal_layer_profile[1]);
     ConfigureStream(kDefaultWidth, kDefaultHeight, kMaxBitrates[2],
                     kMinBitrates[2], kTargetBitrates[2],
                     &settings->simulcastStream[2], temporal_layer_profile[2]);
-    settings->codecSpecific.VP8.resilience = kResilientStream;
-    settings->codecSpecific.VP8.denoisingOn = true;
-    settings->codecSpecific.VP8.errorConcealmentOn = false;
-    settings->codecSpecific.VP8.automaticResizeOn = false;
-    settings->codecSpecific.VP8.feedbackModeOn = false;
-    settings->codecSpecific.VP8.frameDroppingOn = true;
-    settings->codecSpecific.VP8.keyFrameInterval = 3000;
+    settings->VP8()->resilience = kResilientStream;
+    settings->VP8()->denoisingOn = true;
+    settings->VP8()->errorConcealmentOn = false;
+    settings->VP8()->automaticResizeOn = false;
+    settings->VP8()->feedbackModeOn = false;
+    settings->VP8()->frameDroppingOn = true;
+    settings->VP8()->keyFrameInterval = 3000;
   }
 
   static void ConfigureStream(int width,
                               int height,
                               int max_bitrate,
                               int min_bitrate,
                               int target_bitrate,
                               SimulcastStream* stream,
                               int num_temporal_layers) {
     assert(stream);
@@ skipping 247 matching lines @@
         kTargetBitrates[0] + kTargetBitrates[1] + kTargetBitrates[2], 30);
     // We get a key frame because a new stream is being enabled.
     ExpectStreams(kVideoFrameKey, 3);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void SwitchingToOneStream(int width, int height) {
     // Disable all streams except the last and set the bitrate of the last to
     // 100 kbps. This verifies the way GTP switches to screenshare mode.
-    settings_.codecSpecific.VP8.numberOfTemporalLayers = 1;
+    settings_.VP8()->numberOfTemporalLayers = 1;
     settings_.maxBitrate = 100;
     settings_.startBitrate = 100;
     settings_.width = width;
     settings_.height = height;
     for (int i = 0; i < settings_.numberOfSimulcastStreams - 1; ++i) {
       settings_.simulcastStream[i].maxBitrate = 0;
       settings_.simulcastStream[i].width = settings_.width;
       settings_.simulcastStream[i].height = settings_.height;
     }
     // Setting input image to new resolution.
@@ skipping 393 matching lines @@
   std::unique_ptr<VP8Decoder> decoder_;
   MockDecodedImageCallback decoder_callback_;
   VideoCodec settings_;
   VideoFrame input_frame_;
 };
 
 }  // namespace testing
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_