Renamed WebMediaStreamComponent and WebMediaStreamDescriptor to WebMediaStreamTrack & WebMediaStream

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>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/rtc_data_channel_handler.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaConstraints.h"
 // TODO(hta): Move the following include to WebRTCStatsRequest.h file.
-#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamComponent.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamTrack.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCConfiguration.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCICECandidate.h"
 #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"
 
@@ skipping 232 matching lines @@
       response_(NULL) {
 }
 
 LocalRTCStatsRequest::LocalRTCStatsRequest() {}
 LocalRTCStatsRequest::~LocalRTCStatsRequest() {}
 
 bool LocalRTCStatsRequest::hasSelector() const {
   return impl_.hasSelector();
 }
 
-WebKit::WebMediaStreamDescriptor LocalRTCStatsRequest::stream() const {
+WebKit::WebMediaStream LocalRTCStatsRequest::stream() const {
   return impl_.stream();
 }
 
-WebKit::WebMediaStreamComponent LocalRTCStatsRequest::component() const {
+WebKit::WebMediaStreamTrack LocalRTCStatsRequest::component() const {
   return impl_.component();
 }
 
 scoped_refptr<LocalRTCStatsResponse> LocalRTCStatsRequest::createResponse() {
   DCHECK(!response_);
   response_ = new talk_base::RefCountedObject<LocalRTCStatsResponse>(
       impl_.createResponse());
   return response_.get();
 }
 
@@ skipping 201 matching lines @@
   LOG_IF(ERROR, !return_value) << "Error processing ICE candidate.";
 
   if (GetPeerConnectionTracker())
     GetPeerConnectionTracker()->TrackAddIceCandidate(
         this, candidate, PeerConnectionTracker::SOURCE_REMOTE);
 
   return return_value;
 }
 
 bool RTCPeerConnectionHandler::addStream(
-    const WebKit::WebMediaStreamDescriptor& stream,
+    const WebKit::WebMediaStream& stream,
     const WebKit::WebMediaConstraints& options) {
   RTCMediaConstraints constraints(options);
 
   if (GetPeerConnectionTracker())
     GetPeerConnectionTracker()->TrackAddStream(
         this, stream, PeerConnectionTracker::SOURCE_LOCAL);
   return AddStream(stream, &constraints);
 }
 
 void RTCPeerConnectionHandler::removeStream(
-    const WebKit::WebMediaStreamDescriptor& stream) {
+    const WebKit::WebMediaStream& stream) {
   RemoveStream(stream);
   if (GetPeerConnectionTracker())
     GetPeerConnectionTracker()->TrackRemoveStream(
         this, stream, PeerConnectionTracker::SOURCE_LOCAL);
 }
 
 void RTCPeerConnectionHandler::getStats(
     const WebKit::WebRTCStatsRequest& request) {
   scoped_refptr<LocalRTCStatsRequest> inner_request(
       new talk_base::RefCountedObject<LocalRTCStatsRequest>(request));
@@ skipping 87 matching lines @@
         GetPeerConnectionTracker()->TrackIceStateChange(this, state);
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
 void RTCPeerConnectionHandler::OnAddStream(
-    webrtc::MediaStreamInterface* stream) {
-  DCHECK(stream);
-  DCHECK(remote_streams_.find(stream) == remote_streams_.end());
-  WebKit::WebMediaStreamDescriptor descriptor =
-      CreateWebKitStreamDescriptor(stream);
+    webrtc::MediaStreamInterface* stream_interface) {
+  DCHECK(stream_interface);
+  DCHECK(remote_streams_.find(stream_interface) == remote_streams_.end());
+  WebKit::WebMediaStream stream =
+      CreateWebKitStreamDescriptor(stream_interface);
   remote_streams_.insert(
       std::pair<webrtc::MediaStreamInterface*,
-                WebKit::WebMediaStreamDescriptor>(stream, descriptor));
-  client_->didAddRemoteStream(descriptor);
+                WebKit::WebMediaStream>(stream_interface, stream));
+  client_->didAddRemoteStream(stream);
 
   if (GetPeerConnectionTracker())
     GetPeerConnectionTracker()->TrackAddStream(
-        this, descriptor, PeerConnectionTracker::SOURCE_REMOTE);
+        this, stream, PeerConnectionTracker::SOURCE_REMOTE);
 }
 
 void RTCPeerConnectionHandler::OnRemoveStream(
-    webrtc::MediaStreamInterface* stream) {
-  DCHECK(stream);
-  RemoteStreamMap::iterator it = remote_streams_.find(stream);
+    webrtc::MediaStreamInterface* stream_interface) {
+  DCHECK(stream_interface);
+  RemoteStreamMap::iterator it = remote_streams_.find(stream_interface);
   if (it == remote_streams_.end()) {
     NOTREACHED() << "Stream not found";
     return;
   }
-  WebKit::WebMediaStreamDescriptor descriptor = it->second;
-  DCHECK(!descriptor.isNull());
+  WebKit::WebMediaStream stream = it->second;
+  DCHECK(!stream.isNull());
   remote_streams_.erase(it);
-  client_->didRemoveRemoteStream(descriptor);
+  client_->didRemoveRemoteStream(stream);
 
   if (GetPeerConnectionTracker())
     GetPeerConnectionTracker()->TrackRemoveStream(
-        this, descriptor, PeerConnectionTracker::SOURCE_REMOTE);
+        this, stream, PeerConnectionTracker::SOURCE_REMOTE);
 }
 
 void RTCPeerConnectionHandler::OnIceCandidate(
     const webrtc::IceCandidateInterface* candidate) {
   DCHECK(candidate);
   std::string sdp;
   if (!candidate->ToString(&sdp)) {
     NOTREACHED() << "OnIceCandidate: Could not get SDP string.";
     return;
   }
@@ skipping 39 matching lines @@
   webrtc::SessionDescriptionInterface* native_desc =
       dependency_factory_->CreateSessionDescription(type, sdp);
 
   LOG_IF(ERROR, !native_desc) << "Failed to create native session description."
                               << " Type: " << type << " SDP: " << sdp;
 
   return native_desc;
 }
 
 }  // namespace content