RTCStatsCollector: Utilize network thread to minimize thread hops.

webrtc/api/webrtcsession.h

 /*
  *  Copyright 2012 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 97 matching lines @@
 typedef std::map<std::string, cricket::TransportStats> TransportStatsMap;
 typedef std::map<std::string, std::string> ProxyTransportMap;
 
 // TODO(pthatcher): Think of a better name for this.  We already have
 // a TransportStats in transport.h.  Perhaps TransportsStats?
 struct SessionStats {
   ProxyTransportMap proxy_to_transport;
   TransportStatsMap transport_stats;
 };
 
+struct ChannelNamePair {
+  ChannelNamePair(
+      const std::string& content_name, const std::string& transport_name)
+      : content_name(content_name), transport_name(transport_name) {}
+  std::string content_name;
+  std::string transport_name;
+};
+
+struct ChannelNamePairs {
+  rtc::Optional<ChannelNamePair> voice;
+  rtc::Optional<ChannelNamePair> video;
+  rtc::Optional<ChannelNamePair> data;
+};
+
 // A WebRtcSession manages general session state. This includes negotiation
 // of both the application-level and network-level protocols:  the former
 // defines what will be sent and the latter defines how it will be sent.  Each
 // network-level protocol is represented by a Transport object.  Each Transport
 // participates in the network-level negotiation.  The individual streams of
 // packets are represented by TransportChannels.  The application-level protocol
 // is represented by SessionDecription objects.
 class WebRtcSession :
 
     public DtmfProviderInterface,
@@ skipping 59 matching lines @@
 
   virtual cricket::VoiceChannel* voice_channel() {
     return voice_channel_.get();
   }
   virtual cricket::VideoChannel* video_channel() {
     return video_channel_.get();
   }
   virtual cricket::DataChannel* data_channel() {
     return data_channel_.get();
   }
+  std::unique_ptr<ChannelNamePairs> GetChannelNamePairs();
 
   cricket::BaseChannel* GetChannel(const std::string& content_name);
 
   cricket::SecurePolicy SdesPolicy() const;
 
   // Get current ssl role from transport.
   bool GetSslRole(const std::string& transport_name, rtc::SSLRole* role);
 
   // Get current SSL role for this channel's transport.
   // If |transport| is null, returns false.
@@ skipping 47 matching lines @@
                 const rtc::CopyOnWriteBuffer& payload,
                 cricket::SendDataResult* result) override;
   bool ConnectDataChannel(DataChannel* webrtc_data_channel) override;
   void DisconnectDataChannel(DataChannel* webrtc_data_channel) override;
   void AddSctpDataStream(int sid) override;
   void RemoveSctpDataStream(int sid) override;
   bool ReadyToSendData() const override;
 
   // Returns stats for all channels of all transports.
   // This avoids exposing the internal structures used to track them.
-  virtual bool GetTransportStats(SessionStats* stats);
-
-  // Get stats for a specific channel
-  bool GetChannelTransportStats(cricket::BaseChannel* ch, SessionStats* stats);
+  // The parameterless version creates |ChannelNamePairs| from |voice_channel|,
+  // |video_channel| and |voice_channel| if available - this requires it to be
+  // called on the signaling thread - and invokes the other |GetStats|. The
+  // other |GetStats| can be invoked on any thread; if not invoked on the
+  // network thread a thread hop will happen.

[hta-webrtc, 2016/12/19 09:32:58]

Does this mean that the parameterless version should be named GetStats_s?

Function overloading is something we should do when it's important; it's got so
much potential for confusion, it's nice when we don't have to use it.

[hbos, 2016/12/19 12:37:40]

Done.

+  std::unique_ptr<SessionStats> GetStats();
+  virtual std::unique_ptr<SessionStats> GetStats(
+      const ChannelNamePairs& channel_name_pairs);
 
   // virtual so it can be mocked in unit tests
   virtual bool GetLocalCertificate(
       const std::string& transport_name,
       rtc::scoped_refptr<rtc::RTCCertificate>* certificate);
 
   // Caller owns returned certificate
   virtual std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
       const std::string& transport_name);
 
@@ skipping 130 matching lines @@
   bool CreateChannels(const cricket::SessionDescription* desc);
 
   // Helper methods to create media channels.
   bool CreateVoiceChannel(const cricket::ContentInfo* content,
                           const std::string* bundle_transport);
   bool CreateVideoChannel(const cricket::ContentInfo* content,
                           const std::string* bundle_transport);
   bool CreateDataChannel(const cricket::ContentInfo* content,
                          const std::string* bundle_transport);
 
+  std::unique_ptr<SessionStats> GetSessionStats_n(
+      const ChannelNamePairs& channel_name_pairs);
+
   // Listens to SCTP CONTROL messages on unused SIDs and process them as OPEN
   // messages.
   void OnDataChannelMessageReceived(cricket::DataChannel* channel,
                                     const cricket::ReceiveDataParams& params,
                                     const rtc::CopyOnWriteBuffer& payload);
 
   std::string BadStateErrMsg(State state);
   void SetIceConnectionState(PeerConnectionInterface::IceConnectionState state);
   void SetIceConnectionReceiving(bool receiving);
 
@@ skipping 54 matching lines @@
   rtc::Thread* const worker_thread_;
   rtc::Thread* const signaling_thread_;
 
   State state_ = STATE_INIT;
   Error error_ = ERROR_NONE;
   std::string error_desc_;
 
   const std::string sid_;
   bool initial_offerer_ = false;
 
-  std::unique_ptr<cricket::TransportController> transport_controller_;
+  const std::unique_ptr<cricket::TransportController> transport_controller_;
   MediaControllerInterface* media_controller_;
   std::unique_ptr<cricket::VoiceChannel> voice_channel_;
   std::unique_ptr<cricket::VideoChannel> video_channel_;
   std::unique_ptr<cricket::DataChannel> data_channel_;
   cricket::ChannelManager* channel_manager_;
   IceObserver* ice_observer_;
   PeerConnectionInterface::IceConnectionState ice_connection_state_;
   bool ice_connection_receiving_;
   std::unique_ptr<SessionDescriptionInterface> local_desc_;
   std::unique_ptr<SessionDescriptionInterface> remote_desc_;
@@ skipping 31 matching lines @@
 
 #ifdef HAVE_QUIC
   std::unique_ptr<QuicDataTransport> quic_data_transport_;
 #endif  // HAVE_QUIC
 
   RTC_DISALLOW_COPY_AND_ASSIGN(WebRtcSession);
 };
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_WEBRTCSESSION_H_