Change rtc::VideoSinkWants to have target and a max pixel count

webrtc/call/call_perf_tests.cc

 /*
  *  Copyright (c) 2013 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 472 matching lines @@
         test::FrameGeneratorCapturer* frame_generator_capturer) override {
       frame_generator_capturer->SetSinkWantsObserver(this);
     }
 
     // OnSinkWantsChanged is called when FrameGeneratorCapturer::AddOrUpdateSink
     // is called.
     void OnSinkWantsChanged(rtc::VideoSinkInterface<VideoFrame>* sink,
                             const rtc::VideoSinkWants& wants) override {
       // First expect CPU overuse. Then expect CPU underuse when the encoder
       // delay has been decreased.
-      if (wants.max_pixel_count) {
+      if (wants.target_pixel_count) {
+        // Target pixel count set indicates we want to move from a lower res
+        // to a higher.

[stefan-webrtc, 2017/02/06 13:39:49]

It's hard to understand why target_pixel_count means increase resolution. Should
it be named differently to make it clear that it can't be used to target a lower
resolution?

[nisse-webrtc, 2017/02/06 13:42:40]

As far as I understand, it could be used to target a lower resolution, but it
would be more advisory than using the max_pixel_count property.

[sprang_webrtc, 2017/02/06 13:49:53]

That's correct. I guess this is a more an integration test of how vie_encoder
requests new resolutions, rather than a test of the sink wants mechanism itself.

[stefan-webrtc, 2017/02/06 14:01:28]

Maybe update the comment to make that clear, i.e.,

"Lower resolution is requested by a VideoSendStream by setting..."

[sprang_webrtc, 2017/02/06 14:44:08]

Done.

+        EXPECT_FALSE(expect_lower_resolution_wants_);
+        observation_complete_.Set();
+      } else if (wants.max_pixel_count) {
+        // No target set, but max is applied indicates we are overusing and want
+        // a lower resolution.
         EXPECT_TRUE(expect_lower_resolution_wants_);
         expect_lower_resolution_wants_ = false;
         encoder_.SetDelay(2);
-      } else if (wants.max_pixel_count_step_up) {
-        EXPECT_FALSE(expect_lower_resolution_wants_);
-        observation_complete_.Set();
       }
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = &encoder_;
     }
 
@@ skipping 217 matching lines @@
     uint32_t last_set_bitrate_kbps_;
     VideoSendStream* send_stream_;
     test::FrameGeneratorCapturer* frame_generator_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc