Update libjingle 273:277.

content/renderer/media/rtc_peer_connection_handler.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/media/rtc_peer_connection_handler.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 88 matching lines @@
   }
 
   description.initialize(UTF8ToUTF16(native_desc->type()), UTF8ToUTF16(sdp));
   return description;
 }
 
 // Converter functions from WebKit types to libjingle types.
 
 static void GetNativeIceServers(
     const WebKit::WebRTCConfiguration& server_configuration,
-    webrtc::JsepInterface::IceServers* servers) {
+    webrtc::PeerConnectionInterface::IceServers* servers) {
   if (server_configuration.isNull() || !servers)
     return;
   for (size_t i = 0; i < server_configuration.numberOfServers(); ++i) {
-    webrtc::JsepInterface::IceServer server;
+    webrtc::PeerConnectionInterface::IceServer server;
     const WebKit::WebRTCICEServer& webkit_server =
         server_configuration.server(i);
     server.password = UTF16ToUTF8(webkit_server.credential());
     server.uri = webkit_server.uri().spec();
     servers->push_back(server);
   }
 }
 
 class SessionDescriptionRequestTracker {
  public:
@@ skipping 204 matching lines @@
 }
 
 bool RTCPeerConnectionHandler::initialize(
     const WebKit::WebRTCConfiguration& server_configuration,
     const WebKit::WebMediaConstraints& options) {
   DCHECK(frame_);
 
   peer_connection_tracker_ =
       RenderThreadImpl::current()->peer_connection_tracker();
 
-  webrtc::JsepInterface::IceServers servers;
+  webrtc::PeerConnectionInterface::IceServers servers;
   GetNativeIceServers(server_configuration, &servers);
 
   RTCMediaConstraints constraints(options);
   native_peer_connection_ =
       dependency_factory_->CreatePeerConnection(
           servers, &constraints, frame_, this);
   if (!native_peer_connection_) {
     LOG(ERROR) << "Failed to initialize native PeerConnection.";
     return false;
   }
   if (peer_connection_tracker_)
     peer_connection_tracker_->RegisterPeerConnection(
         this, servers, constraints, frame_);
 
   return true;
 }
 
 bool RTCPeerConnectionHandler::InitializeForTest(
     const WebKit::WebRTCConfiguration& server_configuration,
     const WebKit::WebMediaConstraints& options,
     PeerConnectionTracker* peer_connection_tracker) {
-  webrtc::JsepInterface::IceServers servers;
+  webrtc::PeerConnectionInterface::IceServers servers;
   GetNativeIceServers(server_configuration, &servers);
 
   RTCMediaConstraints constraints(options);
   native_peer_connection_ =
       dependency_factory_->CreatePeerConnection(
           servers, &constraints, NULL, this);
   if (!native_peer_connection_) {
     LOG(ERROR) << "Failed to initialize native PeerConnection.";
     return false;
   }
@@ skipping 23 matching lines @@
   RTCMediaConstraints constraints(options);
   native_peer_connection_->CreateAnswer(description_request, &constraints);
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateAnswer(this, constraints);
 }
 
 void RTCPeerConnectionHandler::setLocalDescription(
     const WebKit::WebRTCVoidRequest& request,
     const WebKit::WebRTCSessionDescription& description) {
+  webrtc::SdpParseError error;
   webrtc::SessionDescriptionInterface* native_desc =
-      CreateNativeSessionDescription(description);
+      CreateNativeSessionDescription(description, &error);
   if (!native_desc) {
-    const char kReason[] = "Failed to parse SessionDescription.";
-    LOG(ERROR) << kReason;
-    WebKit::WebString reason(kReason);
-    request.requestFailed(reason);
+    std::string reason_str = "Failed to parse SessionDescription. ";
+    reason_str.append(error.line);
+    reason_str.append(" ");
+    reason_str.append(error.description);
+    LOG(ERROR) << reason_str;
+    request.requestFailed(WebKit::WebString::fromUTF8(reason_str));
     return;
   }
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackSetSessionDescription(
         this, native_desc, PeerConnectionTracker::SOURCE_LOCAL);
 
   scoped_refptr<SetSessionDescriptionRequest> set_request(
       new talk_base::RefCountedObject<SetSessionDescriptionRequest>(
           request, this, PeerConnectionTracker::ACTION_SET_LOCAL_DESCRIPTION));
   native_peer_connection_->SetLocalDescription(set_request, native_desc);
 }
 
 void RTCPeerConnectionHandler::setRemoteDescription(
     const WebKit::WebRTCVoidRequest& request,
     const WebKit::WebRTCSessionDescription& description) {
+  webrtc::SdpParseError error;
   webrtc::SessionDescriptionInterface* native_desc =
-      CreateNativeSessionDescription(description);
+      CreateNativeSessionDescription(description, &error);
   if (!native_desc) {
-    const char kReason[] = "Failed to parse SessionDescription.";
-    LOG(ERROR) << kReason;
-    WebKit::WebString reason(kReason);
-    request.requestFailed(reason);
+    std::string reason_str = "Failed to parse SessionDescription. ";
+    reason_str.append(error.line);
+    reason_str.append(" ");
+    reason_str.append(error.description);
+    LOG(ERROR) << reason_str;
+    request.requestFailed(WebKit::WebString::fromUTF8(reason_str));
     return;
   }
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackSetSessionDescription(
         this, native_desc, PeerConnectionTracker::SOURCE_REMOTE);
 
   scoped_refptr<SetSessionDescriptionRequest> set_request(
       new talk_base::RefCountedObject<SetSessionDescriptionRequest>(
           request, this, PeerConnectionTracker::ACTION_SET_REMOTE_DESCRIPTION));
   native_peer_connection_->SetRemoteDescription(set_request, native_desc);
@@ skipping 13 matching lines @@
   const webrtc::SessionDescriptionInterface* native_desc =
       native_peer_connection_->remote_description();
   WebKit::WebRTCSessionDescription description =
       CreateWebKitSessionDescription(native_desc);
   return description;
 }
 
 bool RTCPeerConnectionHandler::updateICE(
     const WebKit::WebRTCConfiguration& server_configuration,
     const WebKit::WebMediaConstraints& options) {
-  webrtc::JsepInterface::IceServers servers;
+  webrtc::PeerConnectionInterface::IceServers servers;
   GetNativeIceServers(server_configuration, &servers);
   RTCMediaConstraints constraints(options);
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackUpdateIce(this, servers, constraints);
 
   return native_peer_connection_->UpdateIce(servers,
                                             &constraints);
 }
 
@@ skipping 244 matching lines @@
 void RTCPeerConnectionHandler::OnRenegotiationNeeded() {
   client_->negotiationNeeded();
 }
 
 PeerConnectionTracker* RTCPeerConnectionHandler::peer_connection_tracker() {
   return peer_connection_tracker_;
 }
 
 webrtc::SessionDescriptionInterface*
 RTCPeerConnectionHandler::CreateNativeSessionDescription(
-    const WebKit::WebRTCSessionDescription& description) {
+    const WebKit::WebRTCSessionDescription& description,
+    webrtc::SdpParseError* error) {
   std::string sdp = UTF16ToUTF8(description.sdp());
   std::string type = UTF16ToUTF8(description.type());
   webrtc::SessionDescriptionInterface* native_desc =
-      dependency_factory_->CreateSessionDescription(type, sdp);
+      dependency_factory_->CreateSessionDescription(type, sdp, error);
 
   LOG_IF(ERROR, !native_desc) << "Failed to create native session description."
                               << " Type: " << type << " SDP: " << sdp;
 
   return native_desc;
 }
 
 }  // namespace content