Libjingle roll 129:132.

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 108 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(), "", "", ""));
+      talk_base::SocketAddress(), username(), password(), ""));
 
   ResolveStunServerAddress();
   AllocateRelaySession();
 }
 
 void P2PPortAllocatorSession::ResolveStunServerAddress() {
  if (allocator_->config_.stun_server.empty())
    return;
 
  DCHECK(!stun_address_request_);
@@ skipping 46 matching lines @@
       WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
 
   relay_session_request_.reset(
       allocator_->web_frame_->createAssociatedURLLoader(options));
   if (!relay_session_request_.get()) {
     LOG(ERROR) << "Failed to create URL loader.";
     return;
   }
 
   std::string url = "https://" + allocator_->config_.relay_server +
-      kCreateRelaySessionURL;
+      kCreateRelaySessionURL +
+      "?username=" + net::EscapeUrlEncodedData(username(), true) +
+      "&password=" + net::EscapeUrlEncodedData(password(), true);
 
   // Use |relay_username| parameter to identify type of client for the
   // relay session.
   //
   // TODO(sergeyu): Username is not used for legacy non-TURN relay
   // servers, so we reuse it here to identify relay client type. This
   // is currently used for Chromoting only. This code should be removed
   // once Chromoting stops using Transport API and the API is removed.
   if (!allocator_->config_.relay_username.empty()) {
-    url += "?sn=" +
+    url += "&sn=" +
         net::EscapeUrlEncodedData(allocator_->config_.relay_username, true);
   }
 
   WebURLRequest request;
   request.initialize();
   request.setURL(WebURL(GURL(url)));
   request.setAllowStoredCredentials(false);
   request.setCachePolicy(WebURLRequest::ReloadIgnoringCacheData);
   request.setHTTPMethod("GET");
   request.addHTTPHeaderField(
@@ skipping 11 matching lines @@
 }
 
 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;
   }
 
-  relay_username_.clear();
-  relay_password_.clear();
   relay_ip_.Clear();
   relay_udp_port_ = 0;
   relay_tcp_port_ = 0;
   relay_ssltcp_port_ = 0;
 
   for (std::vector<std::pair<std::string, std::string> >::iterator
            it = value_pairs.begin();
        it != value_pairs.end(); ++it) {
     std::string key;
     std::string value;
     TrimWhitespaceASCII(it->first, TRIM_ALL, &key);
     TrimWhitespaceASCII(it->second, TRIM_ALL, &value);
 
     if (key == "username") {
-      relay_username_ = value;
+      if (value != username()) {
+        LOG(ERROR) << "When creating relay session received user name "
+            " that was different from the value specified in the query.";
+        return;
+      }
     } else if (key == "password") {
-      relay_password_ = value;
+      if (value != password()) {
+        LOG(ERROR) << "When creating relay session received password "
+            "that was different from the value specified in the query.";
+        return;
+      }
     } else if (key == "relay.ip") {
       relay_ip_.SetIP(value);
       if (relay_ip_.ip() == 0) {
         LOG(ERROR) << "Received unresolved relay server address: " << value;
         return;
       }
     } else if (key == "relay.udp_port") {
       if (!ParsePortNumber(value, &relay_udp_port_))
         return;
     } else if (key == "relay.tcp_port") {
       if (!ParsePortNumber(value, &relay_tcp_port_))
         return;
     } else if (key == "relay.ssltcp_port") {
       if (!ParsePortNumber(value, &relay_ssltcp_port_))
         return;
     }
   }
 
   AddConfig();
 }
 
 void P2PPortAllocatorSession::AddConfig() {
   cricket::PortConfiguration* config =
       new cricket::PortConfiguration(stun_server_address_,
-                                     relay_username_, relay_password_, "");
+                                     username(), password(), "");
 
   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