Add PeerConnectionInterface::UpdateCallBitrate.

webrtc/call/call.h

 /*
  *  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.
  */
 #ifndef WEBRTC_CALL_CALL_H_
@@ skipping 57 matching lines @@
     static const int kDefaultStartBitrateBps;
 
     // Bitrate config used until valid bitrate estimates are calculated. Also
     // used to cap total bitrate used.
     struct BitrateConfig {
       int min_bitrate_bps = 0;
       int start_bitrate_bps = kDefaultStartBitrateBps;
       int max_bitrate_bps = -1;
     } bitrate_config;
 
+    struct BitrateConfigMask {
+      rtc::Optional<int> min_bitrate_bps;
+      rtc::Optional<int> start_bitrate_bps;
+      rtc::Optional<int> max_bitrate_bps;
+    };

[Taylor Brandstetter, 2017/04/07 03:29:12]

Couldn't one struct be used by both PeerConnection and Call?

[Zach Stein, 2017/04/09 21:09:01]

I did it this way because I wasn't sure where that struct should go.

I am assuming that Call is an implementation detail of PeerConnection, so
PeerConnectionInterface should not depend on Call and Call should not depend on
PeerConnectionInterface. The struct could go in base instead, so that both could
depend on it, but that seemed like overkill to me (I'm not sure this struct is
generally useful enough to be in base). The high-level dependency structure is
still pretty fuzzy to me though, so let me know what you think!

[Taylor Brandstetter, 2017/04/10 04:59:51]

PeerConnectionInterface (being the "public interface") shouldn't depend on Call,
but Call can depend on things in the public interface. So I'd move BitrateConfig
to some header file in api/ (either peerconnectioninterface.h, or something else
that makes sense). Maybe it's overkill, but I prefer cutting down on duplicated
structures/classes; we already have a lot of them.

[stefan-webrtc, 2017/04/10 13:26:58]

But will we not want to have this also for ORTC at some point? In that case I
wouldn't expect ORTC to include peerconnectioninterface.h? 

Also, I think there are tests in other repositories that build on Call instead
of PeerConnection to be more light weight.

+
     // AudioState which is possibly shared between multiple calls.
     // TODO(solenberg): Change this to a shared_ptr once we can use C++11.
     rtc::scoped_refptr<AudioState> audio_state;
 
     // Audio Processing Module to be used in this call.
     // TODO(solenberg): Change this to a shared_ptr once we can use C++11.
     AudioProcessing* audio_processing = nullptr;
 
     // RtcEventLog to use for this call. Required.
     // Use webrtc::RtcEventLog::CreateNull() for a null implementation.
@@ skipping 49 matching lines @@
   virtual Stats GetStats() const = 0;
 
   // TODO(pbos): Like BitrateConfig above this is currently per-stream instead
   // of maximum for entire Call. This should be fixed along with the above.
   // Specifying a start bitrate (>0) will currently reset the current bitrate
   // estimate. This is due to how the 'x-google-start-bitrate' flag is currently
   // implemented.
   virtual void SetBitrateConfig(
       const Config::BitrateConfig& bitrate_config) = 0;
 
+  virtual void UpdateBitrateConfig(const Config::BitrateConfigMask& mask) = 0;
+
   // TODO(skvlad): When the unbundled case with multiple streams for the same
   // media type going over different networks is supported, track the state
   // for each stream separately. Right now it's global per media type.
   virtual void SignalChannelNetworkState(MediaType media,
                                          NetworkState state) = 0;
 
   virtual void OnTransportOverheadChanged(
       MediaType media,
       int transport_overhead_per_packet) = 0;
 
   virtual void OnNetworkRouteChanged(
       const std::string& transport_name,
       const rtc::NetworkRoute& network_route) = 0;
 
   virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
 
   virtual ~Call() {}
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_CALL_CALL_H_