First, you have to separate bandwidth estimation, from bandwidth usage policy, and actual bandwidth usage.
Let's say you are using a simple encoder (non simulcast, non-svc),
let's say you are using only one track per stream, per peerconnection,
First you need to evaluate how much bandwidth you have. It's the role of the Bandwidth Estimation algorithms, usually based on the RTCP reports. In the code right now you have sender-side BWE, receiver-side BWE, Google-CC, and BBR. By default you should be using Google-CC. It gives you a "Bandwidth budget". This is what you are looking at right now.
This pipe into a bitrate_allocator_observer, which is going to .. well .. observe the values given by the BWE at certain times, and provide that value to the internal::VideoSendStream. This class is a high level class to aggregate all the other needed classes: bitrate allocator, transport, FEC, .... It also proxies message from each module, for example, it can ask the video source to reduce spatial resolution or drop frames, as part of the adaptation. RTP headers take some bandwidth, but this value is constant, while FEC take some bandwidth dynamically. There is a FEC_Controller attached which is going to provide in real time the bandwidth used by FEC message to be subtracted from the Bandwidth budget to have the actual usable bandwidth for the RTP packet. RTP headers are then taken into account, and the bandwidth for the payload (the codec output) is computed and given to the encoder.
Everything related to encoder is pushed down to VideoSendStreamImpl then to VideoStreamEncoder. This last class use the provided VideoEncoderFactory to create a VideoEncoder of the proper type (say VP8), and pass the bitrate constraints to it.
It's slightly oversimplified, but it should help you go directly to the right classes.
Hope this helps.