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_
 #define WEBRTC_CALL_CALL_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "webrtc/api/rtcerror.h"
 #include "webrtc/base/networkroute.h"
 #include "webrtc/base/platform_file.h"
 #include "webrtc/base/socket.h"
 #include "webrtc/call/audio_receive_stream.h"
 #include "webrtc/call/audio_send_stream.h"
 #include "webrtc/call/audio_state.h"
 #include "webrtc/call/flexfec_receive_stream.h"
 #include "webrtc/call/rtp_transport_controller_send_interface.h"
 #include "webrtc/common_types.h"
 #include "webrtc/video_receive_stream.h"
@@ skipping 34 matching lines @@
 class Call {
  public:
   struct Config {
     explicit Config(RtcEventLog* event_log) : event_log(event_log) {
       RTC_DCHECK(event_log);
     }
 
     static const int kDefaultStartBitrateBps;
 
     // Bitrate config used until valid bitrate estimates are calculated. Also
-    // used to cap total bitrate used.
+    // used to cap total bitrate used. This comes from the remote connection.
     struct BitrateConfig {
       int min_bitrate_bps = 0;
       int start_bitrate_bps = kDefaultStartBitrateBps;
       int max_bitrate_bps = -1;
     } bitrate_config;
 
+    // The local client's bitrate preferences. The actual configuration used
+    // is a combination of this and |bitrate_config|. The combination is
+    // currently more complicated than a simple mask operation.
+    // Assumes that 0 <= min <= start <= max holds for set parameters.

[kwiberg-webrtc, 2017/05/24 08:27:55]

Would it make sense to document how they are combined?

Also, this comment suggests that the name is bad. Do you expect it to become
good due to future changes in how the two are combined, or should it be changed?

[Zach Stein, 2017/05/24 21:10:02]

The combination is described in SetBirateConfig/SetBitrateConfigMask - I will
add a reference to those methods here.

The name is a holdover from a previous iteration where the values in the mask
were preferred over the values in bitrate_config if they were set. So I agree
that the current name isn't great, but I can't think of a better one. Any
suggestions?

+    struct BitrateConfigMask {
+      rtc::Optional<int> min_bitrate_bps;
+      rtc::Optional<int> start_bitrate_bps;
+      rtc::Optional<int> max_bitrate_bps;
+    };
+
     // 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 46 matching lines @@
 
   // All received RTP and RTCP packets for the call should be inserted to this
   // PacketReceiver. The PacketReceiver pointer is valid as long as the
   // Call instance exists.
   virtual PacketReceiver* Receiver() = 0;
 
   // Returns the call statistics, such as estimated send and receive bandwidth,
   // pacing delay, etc.
   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
+  // The greater min and smaller max set by this and SetBitrateConfigMask will
+  // be used. The latest non-negative start value from either call will be used.
+  // Specifying a start bitrate (>0) will 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;
 
+  // The greater min and smaller max set by this and SetBitrateConfig will be
+  // used. The latest non-negative start value form either call will be used.
+  // Specifying a start bitrate will reset the current bitrate estimate.
+  // Assumes 0 <= min <= start <= max holds for set parameters.
+  virtual void SetBitrateConfigMask(
+      const Config::BitrateConfigMask& bitrate_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_