RTCStatsCollector: Utilize network thread to minimize thread hops.

webrtc/p2p/base/transportcontroller.h

 /*
  *  Copyright 2015 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 65 matching lines @@
 
   bool GetSslRole(const std::string& transport_name, rtc::SSLRole* role) const;
 
   // Specifies the identity to use in this session.
   // Can only be called once.
   bool SetLocalCertificate(
       const rtc::scoped_refptr<rtc::RTCCertificate>& certificate);
   bool GetLocalCertificate(
       const std::string& transport_name,
       rtc::scoped_refptr<rtc::RTCCertificate>* certificate) const;
+  bool GetLocalCertificate_n(
+      const std::string& transport_name,
+      rtc::scoped_refptr<rtc::RTCCertificate>* certificate) const;

[Taylor Brandstetter, 2016/12/13 19:47:07]

I'd prefer only leaving the non "_n" methods public. If you're concerned about
the overhead of Thread::Invoke, we can just do:

if (network_thread_->IsCurrent()) {
  DoThingDirectly();
} else {
  network_thread_->Invoke(...);
}

[pthatcher1, 2016/12/13 23:50:19]

I agree.

But I think it would be even better if you could do this:

auto transport = GetTransport(transport_name);
transport->GetCertificate();
transport->GetRemoteSslCertificate();
transport->GetStats();
...

In fact, you almost can except for the current distinction between Transport and
TransportChannel, and maybe between TransportChannel and DtlsTransportChannel. 
But we're currently working on cleaning that up.  And you can probably do close
to that right now.

[hbos, 2016/12/14 14:56:31]

Done : Removing unnecessary "_n" methods, allowing existing methods to be
invoked on any thread with the "if thread is current" logic.

See other comment about not wanting to do too much refactoring here (not doing
GetTransport).

   // Caller owns returned certificate. This method mainly exists for stats
   // reporting.
   std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
       const std::string& transport_name) const;
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate_n(
+      const std::string& transport_name) const;
   bool SetLocalTransportDescription(const std::string& transport_name,
                                     const TransportDescription& tdesc,
                                     ContentAction action,
                                     std::string* err);
   bool SetRemoteTransportDescription(const std::string& transport_name,
                                      const TransportDescription& tdesc,
                                      ContentAction action,
                                      std::string* err);
   // Start gathering candidates for any new transports, or transports doing an
   // ICE restart.
   void MaybeStartGathering();
   bool AddRemoteCandidates(const std::string& transport_name,
                            const Candidates& candidates,
                            std::string* err);
   bool RemoveRemoteCandidates(const Candidates& candidates, std::string* err);
   bool ReadyForRemoteCandidates(const std::string& transport_name) const;
   // TODO(deadbeef): GetStats isn't const because all the way down to
   // OpenSSLStreamAdapter,
   // GetSslCipherSuite and GetDtlsSrtpCryptoSuite are not const. Fix this.
   bool GetStats(const std::string& transport_name, TransportStats* stats);
+  bool GetStats_n(const std::string& transport_name, TransportStats* stats);
   void SetMetricsObserver(webrtc::MetricsObserverInterface* metrics_observer);
 
   // Creates a channel if it doesn't exist. Otherwise, increments a reference
   // count and returns an existing channel.
   virtual TransportChannel* CreateTransportChannel_n(
       const std::string& transport_name,
       int component);
 
   // Decrements a channel's reference count, and destroys the channel if
   // nothing is referencing it.
@@ skipping 104 matching lines @@
   JsepTransport* GetOrCreateJsepTransport(const std::string& transport_name);
   void DestroyAllChannels_n();
 
   bool SetSslMaxProtocolVersion_n(rtc::SSLProtocolVersion version);
   void SetIceConfig_n(const IceConfig& config);
   void SetIceRole_n(IceRole ice_role);
   bool GetSslRole_n(const std::string& transport_name,
                     rtc::SSLRole* role) const;
   bool SetLocalCertificate_n(
       const rtc::scoped_refptr<rtc::RTCCertificate>& certificate);
-  bool GetLocalCertificate_n(
-      const std::string& transport_name,
-      rtc::scoped_refptr<rtc::RTCCertificate>* certificate) const;
-  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate_n(
-      const std::string& transport_name) const;
   bool SetLocalTransportDescription_n(const std::string& transport_name,
                                       const TransportDescription& tdesc,
                                       ContentAction action,
                                       std::string* err);
   bool SetRemoteTransportDescription_n(const std::string& transport_name,
                                        const TransportDescription& tdesc,
                                        ContentAction action,
                                        std::string* err);
   void MaybeStartGathering_n();
   bool AddRemoteCandidates_n(const std::string& transport_name,
                              const Candidates& candidates,
                              std::string* err);
   bool RemoveRemoteCandidates_n(const Candidates& candidates, std::string* err);
   bool ReadyForRemoteCandidates_n(const std::string& transport_name) const;
-  bool GetStats_n(const std::string& transport_name, TransportStats* stats);
   void SetMetricsObserver_n(webrtc::MetricsObserverInterface* metrics_observer);
 
   // Handlers for signals from Transport.
   void OnChannelWritableState_n(rtc::PacketTransportInterface* transport);
   void OnChannelReceivingState_n(rtc::PacketTransportInterface* transport);
   void OnChannelGatheringState_n(TransportChannelImpl* channel);
   void OnChannelCandidateGathered_n(TransportChannelImpl* channel,
                                     const Candidate& candidate);
   void OnChannelCandidatesRemoved(const Candidates& candidates);
   void OnChannelCandidatesRemoved_n(TransportChannelImpl* channel,
@@ skipping 26 matching lines @@
   rtc::AsyncInvoker invoker_;
   // True if QUIC is used instead of DTLS.
   bool quic_ = false;
 
   webrtc::MetricsObserverInterface* metrics_observer_ = nullptr;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_TRANSPORTCONTROLLER_H_