Deliver webrtc-internals updates in bulk, every 500ms at most.

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 <stddef.h>
 #include <stdint.h>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 329 matching lines @@
   static void OnCompleteImpl(scoped_ptr<base::ListValue> list, int lid) {
     DCHECK(!list->empty());
     RenderThreadImpl::current()->Send(
         new PeerConnectionTrackerHost_AddStats(lid, *list.get()));
   }
 
   const int lid_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
 };
 
-PeerConnectionTracker::PeerConnectionTracker() : next_lid_(1) {
+PeerConnectionTracker::PeerConnectionTracker() : next_local_id_(1) {
 }
 
 PeerConnectionTracker::~PeerConnectionTracker() {
 }
 
 bool PeerConnectionTracker::OnControlMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PeerConnectionTracker, message)
     IPC_MESSAGE_HANDLER(PeerConnectionTracker_GetAllStats, OnGetAllStats)
@@ skipping 27 matching lines @@
     it->first->CloseClientPeerConnection();
   }
 }
 
 void PeerConnectionTracker::RegisterPeerConnection(
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     const RTCMediaConstraints& constraints,
     const blink::WebFrame* frame) {
   DCHECK(main_thread_.CalledOnValidThread());
+  DCHECK_EQ(GetLocalIDForHandler(pc_handler), -1);
   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
   PeerConnectionInfo info;
 
   info.lid = GetNextLocalID();
   info.rtc_configuration =
       "{ servers: " +  SerializeServers(config.servers) + ", " +
       "iceTransportType: " + SerializeIceTransportType(config.type) + ", " +
       "bundlePolicy: " + SerializeBundlePolicy(config.bundle_policy) + ", " +
       "rtcpMuxPolicy: " + SerializeRtcpMuxPolicy(config.rtcp_mux_policy) + " }";
 
   info.constraints = SerializeMediaConstraints(constraints);
   info.url = frame->document().url().string().utf8();
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_AddPeerConnection(info));
 
-  DCHECK(peer_connection_id_map_.find(pc_handler) ==
-         peer_connection_id_map_.end());
-  peer_connection_id_map_[pc_handler] = info.lid;
+  peer_connection_id_map_.insert(std::make_pair(pc_handler, info.lid));
 }
 
 void PeerConnectionTracker::UnregisterPeerConnection(
     RTCPeerConnectionHandler* pc_handler) {
   DCHECK(main_thread_.CalledOnValidThread());
   DVLOG(1) << "PeerConnectionTracker::UnregisterPeerConnection()";
 
   std::map<RTCPeerConnectionHandler*, int>::iterator it =
       peer_connection_id_map_.find(pc_handler);
 
   if (it == peer_connection_id_map_.end()) {
     // The PeerConnection might not have been registered if its initilization
     // failed.
     return;
   }
 
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_RemovePeerConnection(it->second));
 
   peer_connection_id_map_.erase(it);
 }
 
 void PeerConnectionTracker::TrackCreateOffer(
     RTCPeerConnectionHandler* pc_handler,
     const RTCMediaConstraints& constraints) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   SendPeerConnectionUpdate(
-      pc_handler, "createOffer",
+      id, "createOffer",
       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 }
 
 void PeerConnectionTracker::TrackCreateAnswer(
     RTCPeerConnectionHandler* pc_handler,
     const RTCMediaConstraints& constraints) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   SendPeerConnectionUpdate(
-      pc_handler, "createAnswer",
+      id, "createAnswer",
       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 }
 
 void PeerConnectionTracker::TrackSetSessionDescription(
     RTCPeerConnectionHandler* pc_handler,
     const std::string& sdp, const std::string& type, Source source) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   string value = "type: " + type + ", sdp: " + sdp;
   SendPeerConnectionUpdate(
-      pc_handler,
+      id,
       source == SOURCE_LOCAL ? "setLocalDescription" : "setRemoteDescription",
       value);
 }
 
 void PeerConnectionTracker::TrackUpdateIce(
       RTCPeerConnectionHandler* pc_handler,
       const webrtc::PeerConnectionInterface::RTCConfiguration& config,
       const RTCMediaConstraints& options) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   string servers_string = "servers: " + SerializeServers(config.servers);
 
   string transport_type =
       "iceTransportType: " + SerializeIceTransportType(config.type);
 
   string bundle_policy =
       "bundlePolicy: " + SerializeBundlePolicy(config.bundle_policy);
 
   string rtcp_mux_policy =
       "rtcpMuxPolicy: " + SerializeRtcpMuxPolicy(config.rtcp_mux_policy);
 
   string constraints =
       "constraints: {" + SerializeMediaConstraints(options) + "}";
 
   SendPeerConnectionUpdate(
-      pc_handler,
+      id,
       "updateIce",
       servers_string + ", " + transport_type + ", " +
       bundle_policy + ", " + rtcp_mux_policy + ", " +
       constraints);
 }
 
 void PeerConnectionTracker::TrackAddIceCandidate(
       RTCPeerConnectionHandler* pc_handler,
       const blink::WebRTCICECandidate& candidate,
       Source source,
       bool succeeded) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   string value =
       "sdpMid: " +
       base::UTF16ToUTF8(base::StringPiece16(candidate.sdpMid())) + ", " +
       "sdpMLineIndex: " + base::UintToString(candidate.sdpMLineIndex()) +
       ", " + "candidate: " +
       base::UTF16ToUTF8(base::StringPiece16(candidate.candidate()));
 
   // OnIceCandidate always succeeds as it's a callback from the browser.
   DCHECK(source != SOURCE_LOCAL || succeeded);
 
-  string event =
+  const char* event =
       (source == SOURCE_LOCAL) ? "onIceCandidate"
                                : (succeeded ? "addIceCandidate"
                                             : "addIceCandidateFailed");
 
-  SendPeerConnectionUpdate(pc_handler, event, value);
+  SendPeerConnectionUpdate(id, event, value);
 }
 
 void PeerConnectionTracker::TrackAddStream(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebMediaStream& stream,
     Source source) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   SendPeerConnectionUpdate(
-      pc_handler, source == SOURCE_LOCAL ? "addStream" : "onAddStream",
+      id, source == SOURCE_LOCAL ? "addStream" : "onAddStream",
       SerializeMediaDescriptor(stream));
 }
 
 void PeerConnectionTracker::TrackRemoveStream(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebMediaStream& stream,
     Source source){
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   SendPeerConnectionUpdate(
-      pc_handler, source == SOURCE_LOCAL ? "removeStream" : "onRemoveStream",
+      id, source == SOURCE_LOCAL ? "removeStream" : "onRemoveStream",
       SerializeMediaDescriptor(stream));
 }
 
 void PeerConnectionTracker::TrackCreateDataChannel(
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::DataChannelInterface* data_channel,
     Source source) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   string value = "label: " + data_channel->label() +
                  ", reliable: " + (data_channel->reliable() ? "true" : "false");
   SendPeerConnectionUpdate(
-      pc_handler,
+      id,
       source == SOURCE_LOCAL ? "createLocalDataChannel" : "onRemoteDataChannel",
       value);
 }
 
 void PeerConnectionTracker::TrackStop(RTCPeerConnectionHandler* pc_handler) {
   DCHECK(main_thread_.CalledOnValidThread());
-  SendPeerConnectionUpdate(pc_handler, "stop", std::string());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
+  SendPeerConnectionUpdate(id, "stop", std::string());
 }
 
 void PeerConnectionTracker::TrackSignalingStateChange(
       RTCPeerConnectionHandler* pc_handler,
       WebRTCPeerConnectionHandlerClient::SignalingState state) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   SendPeerConnectionUpdate(
-      pc_handler, "signalingStateChange", GetSignalingStateString(state));
+      id, "signalingStateChange", GetSignalingStateString(state));
 }
 
 void PeerConnectionTracker::TrackIceConnectionStateChange(
       RTCPeerConnectionHandler* pc_handler,
       WebRTCPeerConnectionHandlerClient::ICEConnectionState state) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   SendPeerConnectionUpdate(
-      pc_handler, "iceConnectionStateChange",
+      id, "iceConnectionStateChange",
       GetIceConnectionStateString(state));
 }
 
 void PeerConnectionTracker::TrackIceGatheringStateChange(
       RTCPeerConnectionHandler* pc_handler,
       WebRTCPeerConnectionHandlerClient::ICEGatheringState state) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   SendPeerConnectionUpdate(
-      pc_handler, "iceGatheringStateChange",
+      id, "iceGatheringStateChange",
       GetIceGatheringStateString(state));
 }
 
 void PeerConnectionTracker::TrackSessionDescriptionCallback(
     RTCPeerConnectionHandler* pc_handler, Action action,
     const string& callback_type, const string& value) {
   DCHECK(main_thread_.CalledOnValidThread());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
   string update_type;
   switch (action) {
     case ACTION_SET_LOCAL_DESCRIPTION:
       update_type = "setLocalDescription";
       break;
     case ACTION_SET_REMOTE_DESCRIPTION:
       update_type = "setRemoteDescription";
       break;
     case ACTION_CREATE_OFFER:
       update_type = "createOffer";
       break;
     case ACTION_CREATE_ANSWER:
       update_type = "createAnswer";
       break;
     default:
       NOTREACHED();
       break;
   }
   update_type += callback_type;
 
-  SendPeerConnectionUpdate(pc_handler, update_type, value);
+  SendPeerConnectionUpdate(id, update_type.c_str(), value);
 }
 
 void PeerConnectionTracker::TrackOnRenegotiationNeeded(
     RTCPeerConnectionHandler* pc_handler) {
   DCHECK(main_thread_.CalledOnValidThread());
-  SendPeerConnectionUpdate(pc_handler, "onRenegotiationNeeded", std::string());
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
+  SendPeerConnectionUpdate(id, "onRenegotiationNeeded", std::string());
 }
 
 void PeerConnectionTracker::TrackCreateDTMFSender(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebMediaStreamTrack& track) {
   DCHECK(main_thread_.CalledOnValidThread());
-  SendPeerConnectionUpdate(pc_handler, "createDTMFSender",
+  int id = GetLocalIDForHandler(pc_handler);
+  if (id == -1)
+    return;
+  SendPeerConnectionUpdate(id, "createDTMFSender",
                            base::UTF16ToUTF8(base::StringPiece16(track.id())));
 }
 
 void PeerConnectionTracker::TrackGetUserMedia(
     const blink::WebUserMediaRequest& user_media_request) {
   DCHECK(main_thread_.CalledOnValidThread());
   RTCMediaConstraints audio_constraints(
       GetNativeMediaConstraints(user_media_request.audioConstraints()));
   RTCMediaConstraints video_constraints(
       GetNativeMediaConstraints(user_media_request.videoConstraints()));
 
   RenderThreadImpl::current()->Send(new PeerConnectionTrackerHost_GetUserMedia(
       user_media_request.securityOrigin().toString().utf8(),
       user_media_request.audio(),
       user_media_request.video(),
       SerializeMediaConstraints(audio_constraints),
       SerializeMediaConstraints(video_constraints)));
 }
 
 int PeerConnectionTracker::GetNextLocalID() {
   DCHECK(main_thread_.CalledOnValidThread());
-  return next_lid_++;
+  if (next_local_id_< 0)
+    next_local_id_ = 1;
+  return next_local_id_++;
+}
+
+int PeerConnectionTracker::GetLocalIDForHandler(
+    RTCPeerConnectionHandler* handler) const {
+  DCHECK(main_thread_.CalledOnValidThread());
+  const auto found = peer_connection_id_map_.find(handler);
+  if (found == peer_connection_id_map_.end())
+    return -1;
+  DCHECK_NE(found->second, -1);
+  return found->second;
 }
 
 void PeerConnectionTracker::SendPeerConnectionUpdate(
-    RTCPeerConnectionHandler* pc_handler,
-    const std::string& type,
+    int local_id,
+    const char* callback_type,
     const std::string& value) {
   DCHECK(main_thread_.CalledOnValidThread());
-  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));
+          local_id, std::string(callback_type), value));
 }
 
 }  // namespace content