Roll libjingle 132:133

content/renderer/p2p/port_allocator.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 "content/renderer/p2p/port_allocator.h"
 
 #include "base/bind.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 53 matching lines @@
   uint32 flags = 0;
   if (config_.disable_tcp_transport)
     flags |= cricket::PORTALLOCATOR_DISABLE_TCP;
   set_flags(flags);
 }
 
 P2PPortAllocator::~P2PPortAllocator() {
 }
 
 cricket::PortAllocatorSession* P2PPortAllocator::CreateSession(
-    const std::string& name,
-    const std::string& session_type) {
-  return new P2PPortAllocatorSession(this, name, session_type);
+    const std::string& channel_name,
+    int component) {
+  return new P2PPortAllocatorSession(this, channel_name, component);
 }
 
 P2PPortAllocatorSession::P2PPortAllocatorSession(
     P2PPortAllocator* allocator,
-    const std::string& name,
-    const std::string& session_type)
-    : cricket::BasicPortAllocatorSession(allocator, name, session_type),
+    const std::string& channel_name,
+    int component)
+    : cricket::BasicPortAllocatorSession(allocator, channel_name, component),
       allocator_(allocator),
       relay_session_attempts_(0),
       relay_udp_port_(0),
       relay_tcp_port_(0),
       relay_ssltcp_port_(0) {
 }
 
 P2PPortAllocatorSession::~P2PPortAllocatorSession() {
   if (stun_address_request_)
     stun_address_request_->Cancel();
@@ skipping 24 matching lines @@
 
   LOG(ERROR) << "Relay session request failed.";
 
   // Retry the request.
   AllocateRelaySession();
 }
 
 void P2PPortAllocatorSession::GetPortConfigurations() {
   // Add an empty configuration synchronously, so a local connection
   // can be started immediately.
-  ConfigReady(new cricket::PortConfiguration(
-      talk_base::SocketAddress(), username(), password(), ""));
+  ConfigReady(new cricket::PortConfiguration(talk_base::SocketAddress()));
 
   ResolveStunServerAddress();
   AllocateRelaySession();
 }
 
 void P2PPortAllocatorSession::ResolveStunServerAddress() {
  if (allocator_->config_.stun_server.empty())
    return;
 
  DCHECK(!stun_address_request_);
@@ skipping 74 matching lines @@
   request.setURL(WebURL(GURL(url)));
   request.setAllowStoredCredentials(false);
   request.setCachePolicy(WebURLRequest::ReloadIgnoringCacheData);
   request.setHTTPMethod("GET");
   request.addHTTPHeaderField(
       WebString::fromUTF8("X-Talk-Google-Relay-Auth"),
       WebString::fromUTF8(allocator_->config_.relay_password));
   request.addHTTPHeaderField(
       WebString::fromUTF8("X-Google-Relay-Auth"),
       WebString::fromUTF8(allocator_->config_.relay_password));
-  request.addHTTPHeaderField(WebString::fromUTF8("X-Session-Type"),
-                             WebString::fromUTF8(session_type()));
   request.addHTTPHeaderField(WebString::fromUTF8("X-Stream-Type"),
-                             WebString::fromUTF8(name()));
+                             WebString::fromUTF8(channel_name()));
 
   relay_session_request_->loadAsynchronously(request, this);
 }
 
 void P2PPortAllocatorSession::ParseRelayResponse() {
   std::vector<std::pair<std::string, std::string> > value_pairs;
   if (!base::SplitStringIntoKeyValuePairs(relay_session_response_, '=', '\n',
                                           &value_pairs)) {
     LOG(ERROR) << "Received invalid response from relay server";
     return;
@@ skipping 40 matching lines @@
       if (!ParsePortNumber(value, &relay_ssltcp_port_))
         return;
     }
   }
 
   AddConfig();
 }
 
 void P2PPortAllocatorSession::AddConfig() {
   cricket::PortConfiguration* config =
-      new cricket::PortConfiguration(stun_server_address_,
-                                     username(), password(), "");
+      new cricket::PortConfiguration(stun_server_address_);
 
   if (relay_ip_.ip() != 0) {
     cricket::PortConfiguration::PortList ports;
     if (relay_udp_port_ > 0) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_udp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_UDP));
     }
     if (relay_tcp_port_ > 0 && !allocator_->config_.disable_tcp_transport) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_tcp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_TCP));
     }
     if (relay_ssltcp_port_ > 0 && !allocator_->config_.disable_tcp_transport) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_ssltcp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_SSLTCP));
     }
     if (!ports.empty())
       config->AddRelay(ports, 0.0f);
   }
   ConfigReady(config);
 }
 
 }  // namespace content