Detect situation when there is no missing send completion signal in P2PSocket implementation.

content/renderer/p2p/socket_client_impl.cc

 // Copyright 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/p2p/socket_client_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/time/time.h"
 #include "content/common/p2p_messages.h"
 #include "content/renderer/p2p/socket_client_delegate.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/render_thread_impl.h"
 #include "crypto/random.h"
 
 namespace {
 
-uint64 GetUniqueId(uint32 random_socket_id, uint32 packet_id) {
-  uint64 uid = random_socket_id;
+uint64_t GetUniqueId(uint32 random_socket_id, uint32 packet_id) {
+  uint64_t uid = random_socket_id;
   uid <<= 32;
   uid |= packet_id;
   return uid;
 }
 
 }  // namespace
 
 namespace content {
 
 P2PSocketClientImpl::P2PSocketClientImpl(P2PSocketDispatcher* dispatcher)
@@ skipping 32 matching lines @@
 void P2PSocketClientImpl::DoInit(P2PSocketType type,
                                  const net::IPEndPoint& local_address,
                                  const P2PHostAndIPEndPoint& remote_address) {
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   state_ = STATE_OPENING;
   socket_id_ = dispatcher_->RegisterClient(this);
   dispatcher_->SendP2PMessage(new P2PHostMsg_CreateSocket(
       type, socket_id_, local_address, remote_address));
 }
 
-void P2PSocketClientImpl::SendWithDscp(
-    const net::IPEndPoint& address,
-    const std::vector<char>& data,
-    const rtc::PacketOptions& options) {
+uint64_t P2PSocketClientImpl::Send(const net::IPEndPoint& address,
+                                   const std::vector<char>& data,
+                                   const rtc::PacketOptions& options) {
+  uint64_t unique_id = GetUniqueId(random_socket_id_, ++next_packet_id_);
   if (!ipc_message_loop_->BelongsToCurrentThread()) {
     ipc_message_loop_->PostTask(
-        FROM_HERE, base::Bind(
-            &P2PSocketClientImpl::SendWithDscp, this, address, data, options));
-    return;
+        FROM_HERE, base::Bind(&P2PSocketClientImpl::SendWithPacketId, this,
+                              address, data, options, unique_id));
+    return unique_id;
   }
 
   // Can send data only when the socket is open.
   DCHECK(state_ == STATE_OPEN || state_ == STATE_ERROR);
   if (state_ == STATE_OPEN) {
-    uint64 unique_id = GetUniqueId(random_socket_id_, ++next_packet_id_);
-    TRACE_EVENT_ASYNC_BEGIN0("p2p", "Send", unique_id);
-    dispatcher_->SendP2PMessage(new P2PHostMsg_Send(socket_id_, address, data,
-                                                    options, unique_id));
+    SendWithPacketId(address, data, options, unique_id);
   }
+
+  return unique_id;
 }
 
-void P2PSocketClientImpl::Send(const net::IPEndPoint& address,
-                               const std::vector<char>& data) {
-  rtc::PacketOptions options(rtc::DSCP_DEFAULT);
-  SendWithDscp(address, data, options);
+void P2PSocketClientImpl::SendWithPacketId(const net::IPEndPoint& address,
+                                           const std::vector<char>& data,
+                                           const rtc::PacketOptions& options,
+                                           uint64_t packet_id) {
+  TRACE_EVENT_ASYNC_BEGIN0("p2p", "Send", packet_id);
+  dispatcher_->SendP2PMessage(
+      new P2PHostMsg_Send(socket_id_, address, data, options, packet_id));
 }
 
 void P2PSocketClientImpl::SetOption(P2PSocketOption option,
                                     int value) {
   if (!ipc_message_loop_->BelongsToCurrentThread()) {
     ipc_message_loop_->PostTask(
         FROM_HERE, base::Bind(
             &P2PSocketClientImpl::SetOption, this, option, value));
     return;
   }
@@ skipping 82 matching lines @@
     scoped_refptr<P2PSocketClient> new_client) {
   DCHECK(delegate_message_loop_->BelongsToCurrentThread());
   if (delegate_) {
     delegate_->OnIncomingTcpConnection(address, new_client.get());
   } else {
     // Just close the socket if there is no delegate to accept it.
     new_client->Close();
   }
 }
 
-void P2PSocketClientImpl::OnSendComplete() {
+void P2PSocketClientImpl::OnSendComplete(
+    const P2PSendPacketMetrics& send_metrics) {
   DCHECK(ipc_message_loop_->BelongsToCurrentThread());
 
   delegate_message_loop_->PostTask(
-      FROM_HERE, base::Bind(&P2PSocketClientImpl::DeliverOnSendComplete, this));
+      FROM_HERE, base::Bind(&P2PSocketClientImpl::DeliverOnSendComplete, this,
+                            send_metrics));
 }
 
-void P2PSocketClientImpl::DeliverOnSendComplete() {
+void P2PSocketClientImpl::DeliverOnSendComplete(
+    const P2PSendPacketMetrics& send_metrics) {
   DCHECK(delegate_message_loop_->BelongsToCurrentThread());
   if (delegate_)
-    delegate_->OnSendComplete();
+    delegate_->OnSendComplete(send_metrics);
 }
 
 void P2PSocketClientImpl::OnError() {
   DCHECK(ipc_message_loop_->BelongsToCurrentThread());
   state_ = STATE_ERROR;
 
   delegate_message_loop_->PostTask(
       FROM_HERE, base::Bind(&P2PSocketClientImpl::DeliverOnError, this));
 }
 
@@ skipping 25 matching lines @@
     delegate_->OnDataReceived(address, data, timestamp);
 }
 
 void P2PSocketClientImpl::Detach() {
   DCHECK(ipc_message_loop_->BelongsToCurrentThread());
   dispatcher_ = NULL;
   OnError();
 }
 
 }  // namespace content