Roll WebRTC 10010:10022, Libjingle 10011:10022

remoting/protocol/libjingle_transport_factory.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/libjingle_transport_factory.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ skipping 60 matching lines @@
   void SetRemoteCredentials(const std::string& ufrag,
                             const std::string& password) override;
   void AddRemoteCandidate(const cricket::Candidate& candidate) override;
   const std::string& name() const override;
   bool is_connected() const override;
 
  private:
   void DoStart();
   void NotifyConnected();
 
-  // Signal handlers for cricket::TransportChannel.
-  void OnRequestSignaling(cricket::TransportChannelImpl* channel);
-  void OnCandidateReady(cricket::TransportChannelImpl* channel,
+  void OnCandidateGathered(cricket::TransportChannelImpl* channel,
                         const cricket::Candidate& candidate);

[Sergey Ulanov, 2015/09/04 18:37:32]

update indentation please

[Taylor_Brandstetter, 2015/09/04 18:58:59]

Done.

   void OnRouteChange(cricket::TransportChannel* channel,
                      const cricket::Candidate& candidate);
   void OnWritableState(cricket::TransportChannel* channel);
 
   // Callback for TransportChannelSocketAdapter to notify when the socket is
   // destroyed.
   void OnChannelDestroyed();
 
   void NotifyRouteChanged();
 
@@ skipping 59 matching lines @@
   if (!callback_.is_null())
     DoStart();
 
   // Pass pending ICE credentials and candidates to the channel.
   if (!remote_ice_username_fragment_.empty()) {
     channel_->SetRemoteIceCredentials(remote_ice_username_fragment_,
                                       remote_ice_password_);
   }
 
   while (!pending_candidates_.empty()) {
-    channel_->OnCandidate(pending_candidates_.front());
+    channel_->AddRemoteCandidate(pending_candidates_.front());
     pending_candidates_.pop_front();
   }
 }
 
 void LibjingleTransport::Connect(
     const std::string& name,
     Transport::EventHandler* event_handler,
     const Transport::ConnectedCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!name.empty());
@@ skipping 16 matching lines @@
   // TODO(sergeyu): Specify correct component ID for the channel.
   channel_.reset(new cricket::P2PTransportChannel(
       std::string(), 0, nullptr, port_allocator_));
   std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
   channel_->SetIceRole((role_ == TransportRole::CLIENT)
                            ? cricket::ICEROLE_CONTROLLING
                            : cricket::ICEROLE_CONTROLLED);
   event_handler_->OnTransportIceCredentials(this, ice_username_fragment_,
                                             ice_password);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password);
-  channel_->SignalRequestSignaling.connect(
-      this, &LibjingleTransport::OnRequestSignaling);
-  channel_->SignalCandidateReady.connect(
-      this, &LibjingleTransport::OnCandidateReady);
+  channel_->SignalCandidateGathered.connect(
+      this, &LibjingleTransport::OnCandidateGathered);
   channel_->SignalRouteChange.connect(
       this, &LibjingleTransport::OnRouteChange);
   channel_->SignalWritableState.connect(
       this, &LibjingleTransport::OnWritableState);
   channel_->set_incoming_only(
       !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING));
 
   channel_->Connect();
 
   --connect_attempts_left_;
@@ skipping 33 matching lines @@
   DCHECK(CalledOnValidThread());
 
   // To enforce the no-relay setting, it's not enough to not produce relay
   // candidates. It's also necessary to discard remote relay candidates.
   bool relay_allowed = (network_settings_.flags &
                         NetworkSettings::NAT_TRAVERSAL_RELAY) != 0;
   if (!relay_allowed && candidate.type() == cricket::RELAY_PORT_TYPE)
     return;
 
   if (channel_) {
-    channel_->OnCandidate(candidate);
+    channel_->AddRemoteCandidate(candidate);
   } else {
     pending_candidates_.push_back(candidate);
   }
 }
 
 const std::string& LibjingleTransport::name() const {
   DCHECK(CalledOnValidThread());
   return name_;
 }
 
 bool LibjingleTransport::is_connected() const {
   DCHECK(CalledOnValidThread());
   return callback_.is_null();
 }
 
-void LibjingleTransport::OnRequestSignaling(
-    cricket::TransportChannelImpl* channel) {
-  DCHECK(CalledOnValidThread());
-  channel_->OnSignalingReady();
-}
-
-void LibjingleTransport::OnCandidateReady(
+void LibjingleTransport::OnCandidateGathered(
     cricket::TransportChannelImpl* channel,
     const cricket::Candidate& candidate) {
   DCHECK(CalledOnValidThread());
   event_handler_->OnTransportCandidate(this, candidate);
 }
 
 void LibjingleTransport::OnRouteChange(
     cricket::TransportChannel* channel,
     const cricket::Candidate& candidate) {
   // Ignore notifications if the channel is not writable.
@@ skipping 154 matching lines @@
     last_jingle_info_update_time_ = base::TimeTicks::Now();
 
   while (!on_jingle_info_callbacks_.empty()) {
     on_jingle_info_callbacks_.begin()->Run();
     on_jingle_info_callbacks_.pop_front();
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting