Hookup new ice state callbacks OnIceConnectionChange and OnIceGatheringChange from PeerConnectionOb…

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 15 matching lines @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCPeerConnectionHandlerClient.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCSessionDescription.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCSessionDescriptionRequest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCStatsRequest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCVoidRequest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 
 namespace content {
 
-// Converter functions from  libjingle types to WebKit types.
-
-static WebKit::WebRTCPeerConnectionHandlerClient::ICEState
-GetWebKitIceState(webrtc::PeerConnectionInterface::IceState ice_state) {
-  switch (ice_state) {
-    case webrtc::PeerConnectionInterface::kIceNew:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateNew;
-    case webrtc::PeerConnectionInterface::kIceGathering:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateGathering;
-    case webrtc::PeerConnectionInterface::kIceWaiting:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateWaiting;
-    case webrtc::PeerConnectionInterface::kIceChecking:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateChecking;
-    case webrtc::PeerConnectionInterface::kIceConnected:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateConnected;
-    case webrtc::PeerConnectionInterface::kIceCompleted:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateCompleted;
-    case webrtc::PeerConnectionInterface::kIceFailed:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateFailed;
-    case webrtc::PeerConnectionInterface::kIceClosed:
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateClosed;
+// Converter functions from libjingle types to WebKit types.
+WebKit::WebRTCPeerConnectionHandlerClient::ICEGatheringState
+GetWebKitIceGatheringState(
+    webrtc::PeerConnectionInterface::IceGatheringState state) {
+  using WebKit::WebRTCPeerConnectionHandlerClient;
+  switch (state) {
+    case webrtc::PeerConnectionInterface::kIceGatheringNew:
+      return WebRTCPeerConnectionHandlerClient::ICEGatheringStateNew;
+    case webrtc::PeerConnectionInterface::kIceGatheringGathering:
+      return WebRTCPeerConnectionHandlerClient::ICEGatheringStateGathering;
+    case webrtc::PeerConnectionInterface::kIceGatheringComplete:
+      return WebRTCPeerConnectionHandlerClient::ICEGatheringStateComplete;
     default:
       NOTREACHED();
-      return WebKit::WebRTCPeerConnectionHandlerClient::ICEStateClosed;
+      return WebRTCPeerConnectionHandlerClient::ICEGatheringStateNew;
   }
 }
 
+static WebKit::WebRTCPeerConnectionHandlerClient::ICEConnectionState
+GetWebKitIceConnectionState(
+    webrtc::PeerConnectionInterface::IceConnectionState ice_state) {
+  using WebKit::WebRTCPeerConnectionHandlerClient;
+  switch (ice_state) {
+    case webrtc::PeerConnectionInterface::kIceConnectionNew:
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateStarting;
+    case webrtc::PeerConnectionInterface::kIceConnectionChecking:
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateChecking;
+    case webrtc::PeerConnectionInterface::kIceConnectionConnected:
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateConnected;
+    case webrtc::PeerConnectionInterface::kIceConnectionCompleted:
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateCompleted;
+    case webrtc::PeerConnectionInterface::kIceConnectionFailed:
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateFailed;
+    case webrtc::PeerConnectionInterface::kIceConnectionDisconnected:
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateDisconnected;
+    case webrtc::PeerConnectionInterface::kIceConnectionClosed:
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateClosed;
+    default:
+      NOTREACHED();
+      return WebRTCPeerConnectionHandlerClient::ICEConnectionStateClosed;
+  }
+}
+
 static WebKit::WebRTCPeerConnectionHandlerClient::SignalingState
 GetWebKitSignalingState(webrtc::PeerConnectionInterface::SignalingState state) {
   using WebKit::WebRTCPeerConnectionHandlerClient;
   switch (state) {
     case webrtc::PeerConnectionInterface::kStable:
       return WebRTCPeerConnectionHandlerClient::SignalingStateStable;
     case webrtc::PeerConnectionInterface::kHaveLocalOffer:
       return WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalOffer;
     case webrtc::PeerConnectionInterface::kHaveLocalPrAnswer:
       return WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalPrAnswer;
@@ skipping 544 matching lines @@
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackStop(this);
 }
 
 void RTCPeerConnectionHandler::OnError() {
   // TODO(perkj): Implement.
   NOTIMPLEMENTED();
 }
 
-void RTCPeerConnectionHandler::OnStateChange(StateType state_changed) {
-  switch (state_changed) {
-    case kSignalingState: {
-      WebKit::WebRTCPeerConnectionHandlerClient::SignalingState state =
-          GetWebKitSignalingState(native_peer_connection_->signaling_state());
-      if (peer_connection_tracker_)
-        peer_connection_tracker_->TrackSignalingStateChange(this, state);
+void RTCPeerConnectionHandler::OnSignalingChange(
+    webrtc::PeerConnectionInterface::SignalingState new_state) {
+  WebKit::WebRTCPeerConnectionHandlerClient::SignalingState state =
+      GetWebKitSignalingState(new_state);
+  if (peer_connection_tracker_)
+    peer_connection_tracker_->TrackSignalingStateChange(this, state);
+  client_->didChangeSignalingState(state);
+}
 
-      client_->didChangeSignalingState(state);
-      break;
-    }
-    case kIceState: {
-      WebKit::WebRTCPeerConnectionHandlerClient::ICEState state =
-          GetWebKitIceState(native_peer_connection_->ice_state());
-      if (peer_connection_tracker_)
-        peer_connection_tracker_->TrackIceStateChange(this, state);
+// Called any time the IceConnectionState changes
+void RTCPeerConnectionHandler::OnIceConnectionChange(
+    webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+  WebKit::WebRTCPeerConnectionHandlerClient::ICEConnectionState state =
+      GetWebKitIceConnectionState(new_state);
+  // TODO(perkj): Add new ice connection state to the tracker.
+  client_->didChangeICEConnectionState(state);
+}
 
-      client_->didChangeICEState(state);
-      break;
-    }
-    default:
-      NOTREACHED();
-      break;
-  }
+// Called any time the IceGatheringState changes
+void RTCPeerConnectionHandler::OnIceGatheringChange(
+    webrtc::PeerConnectionInterface::IceGatheringState new_state) {
+  WebKit::WebRTCPeerConnectionHandlerClient::ICEGatheringState state =
+      GetWebKitIceGatheringState(new_state);
+  // TODO(perkj): Add new ice gathering state to the tracker.
+  client_->didChangeICEGatheringState(state);
 }
 
 void RTCPeerConnectionHandler::OnAddStream(
     webrtc::MediaStreamInterface* stream_interface) {
   DCHECK(stream_interface);
   DCHECK(remote_streams_.find(stream_interface) == remote_streams_.end());
   WebKit::WebMediaStream stream =
       CreateWebKitStreamDescriptor(stream_interface);
 
   if (peer_connection_tracker_)
@@ skipping 37 matching lines @@
   web_candidate.initialize(UTF8ToUTF16(sdp),
                            UTF8ToUTF16(candidate->sdp_mid()),
                            candidate->sdp_mline_index());
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackAddIceCandidate(
         this, web_candidate, PeerConnectionTracker::SOURCE_LOCAL);
 
   client_->didGenerateICECandidate(web_candidate);
 }
 
-void RTCPeerConnectionHandler::OnIceComplete() {
-  if (peer_connection_tracker_)
-    peer_connection_tracker_->TrackOnIceComplete(this);
-  // Generates a NULL ice candidate object.
-  WebKit::WebRTCICECandidate web_candidate;
-  client_->didGenerateICECandidate(web_candidate);
-}
-
 void RTCPeerConnectionHandler::OnDataChannel(
     webrtc::DataChannelInterface* data_channel) {
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateDataChannel(
         this, data_channel, PeerConnectionTracker::SOURCE_REMOTE);
 
   DVLOG(1) << "RTCPeerConnectionHandler::OnDataChannel "
            << data_channel->label();
   client_->didAddRemoteDataChannel(new RtcDataChannelHandler(data_channel));
 }
@@ skipping 15 matching lines @@
   webrtc::SessionDescriptionInterface* native_desc =
       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