Rename WebKit namespace to blink (part 3)

content/renderer/media/peer_connection_tracker.cc

 // Copyright (c) 2013 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/peer_connection_tracker.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 
 using std::string;
 using webrtc::MediaConstraintsInterface;
-using WebKit::WebRTCPeerConnectionHandlerClient;
+using blink::WebRTCPeerConnectionHandlerClient;
 
 namespace content {
 
 static string SerializeServers(
     const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers) {
   string result = "[";
   for (size_t i = 0; i < servers.size(); ++i) {
     result += servers[i].uri;
     if (i != servers.size() - 1)
       result += ", ";
@@ skipping 24 matching lines @@
       result += optional[i].key + ":" + optional[i].value;
       if (i != optional.size() - 1)
         result += ", ";
     }
     result += "}";
   }
   return result;
 }
 
 static string SerializeMediaStreamComponent(
-    const WebKit::WebMediaStreamTrack component) {
+    const blink::WebMediaStreamTrack component) {
   string id = UTF16ToUTF8(component.source().id());
   return id;
 }
 
 static string SerializeMediaDescriptor(
-    const WebKit::WebMediaStream& stream) {
+    const blink::WebMediaStream& stream) {
   string label = UTF16ToUTF8(stream.id());
   string result = "label: " + label;
-  WebKit::WebVector<WebKit::WebMediaStreamTrack> tracks;
+  blink::WebVector<blink::WebMediaStreamTrack> tracks;
   stream.audioTracks(tracks);
   if (!tracks.isEmpty()) {
     result += ", audio: [";
     for (size_t i = 0; i < tracks.size(); ++i) {
       result += SerializeMediaStreamComponent(tracks[i]);
       if (i != tracks.size() - 1)
         result += ", ";
     }
     result += "]";
   }
@@ skipping 158 matching lines @@
         new talk_base::RefCountedObject<InternalStatsObserver>(it->second));
 
     it->first->GetStats(observer, NULL);
   }
 }
 
 void PeerConnectionTracker::RegisterPeerConnection(
     RTCPeerConnectionHandler* pc_handler,
     const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
     const RTCMediaConstraints& constraints,
-    const WebKit::WebFrame* frame) {
+    const blink::WebFrame* frame) {
   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
   PeerConnectionInfo info;
 
   info.lid = GetNextLocalID();
   info.servers = SerializeServers(servers);
   info.constraints = SerializeMediaConstraints(constraints);
   info.url = frame->document().url().spec();
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_AddPeerConnection(info));
 
@@ skipping 32 matching lines @@
 void PeerConnectionTracker::TrackCreateAnswer(
     RTCPeerConnectionHandler* pc_handler,
     const RTCMediaConstraints& constraints) {
   SendPeerConnectionUpdate(
       pc_handler, "createAnswer",
       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 }
 
 void PeerConnectionTracker::TrackSetSessionDescription(
     RTCPeerConnectionHandler* pc_handler,
-    const WebKit::WebRTCSessionDescription& desc,
+    const blink::WebRTCSessionDescription& desc,
     Source source) {
   string sdp = UTF16ToUTF8(desc.sdp());
   string type = UTF16ToUTF8(desc.type());
 
   string value = "type: " + type + ", sdp: " + sdp;
   SendPeerConnectionUpdate(
       pc_handler,
       source == SOURCE_LOCAL ? "setLocalDescription" : "setRemoteDescription",
       value);
 }
 
 void PeerConnectionTracker::TrackUpdateIce(
       RTCPeerConnectionHandler* pc_handler,
       const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
       const RTCMediaConstraints& options) {
   string servers_string = "servers: " + SerializeServers(servers);
   string constraints =
       "constraints: {" + SerializeMediaConstraints(options) + "}";
 
   SendPeerConnectionUpdate(
       pc_handler, "updateIce", servers_string + ", " + constraints);
 }
 
 void PeerConnectionTracker::TrackAddIceCandidate(
       RTCPeerConnectionHandler* pc_handler,
-      const WebKit::WebRTCICECandidate& candidate,
+      const blink::WebRTCICECandidate& candidate,
       Source source) {
   string value = "mid: " + UTF16ToUTF8(candidate.sdpMid()) + ", " +
                  "candidate: " + UTF16ToUTF8(candidate.candidate());
   SendPeerConnectionUpdate(
       pc_handler,
       source == SOURCE_LOCAL ? "onIceCandidate" : "addIceCandidate", value);
 }
 
 void PeerConnectionTracker::TrackAddStream(
     RTCPeerConnectionHandler* pc_handler,
-    const WebKit::WebMediaStream& stream,
+    const blink::WebMediaStream& stream,
     Source source){
   SendPeerConnectionUpdate(
       pc_handler, source == SOURCE_LOCAL ? "addStream" : "onAddStream",
       SerializeMediaDescriptor(stream));
 }
 
 void PeerConnectionTracker::TrackRemoveStream(
     RTCPeerConnectionHandler* pc_handler,
-    const WebKit::WebMediaStream& stream,
+    const blink::WebMediaStream& stream,
     Source source){
   SendPeerConnectionUpdate(
       pc_handler, source == SOURCE_LOCAL ? "removeStream" : "onRemoveStream",
       SerializeMediaDescriptor(stream));
 }
 
 void PeerConnectionTracker::TrackCreateDataChannel(
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::DataChannelInterface* data_channel,
     Source source) {
@@ skipping 58 matching lines @@
   SendPeerConnectionUpdate(pc_handler, update_type, value);
 }
 
 void PeerConnectionTracker::TrackOnRenegotiationNeeded(
     RTCPeerConnectionHandler* pc_handler) {
   SendPeerConnectionUpdate(pc_handler, "onRenegotiationNeeded", std::string());
 }
 
 void PeerConnectionTracker::TrackCreateDTMFSender(
     RTCPeerConnectionHandler* pc_handler,
-    const WebKit::WebMediaStreamTrack& track) {
+    const blink::WebMediaStreamTrack& track) {
   SendPeerConnectionUpdate(pc_handler, "createDTMFSender",
                            UTF16ToUTF8(track.id()));
 }
 
 int PeerConnectionTracker::GetNextLocalID() {
   return next_lid_++;
 }
 
 void PeerConnectionTracker::SendPeerConnectionUpdate(
     RTCPeerConnectionHandler* pc_handler,
     const std::string& type,
     const std::string& value) {
   if (peer_connection_id_map_.find(pc_handler) == peer_connection_id_map_.end())
     return;
 
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_UpdatePeerConnection(
           peer_connection_id_map_[pc_handler], type, value));
 }
 
 }  // namespace content