DataChannel[Interface]::[message/bytes]_[sent/received]() added.

webrtc/api/datachannel.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 108 matching lines @@
     return NULL;
   }
   return channel;
 }
 
 DataChannel::DataChannel(
     DataChannelProviderInterface* provider,
     cricket::DataChannelType dct,
     const std::string& label)
     : label_(label),
-      observer_(NULL),
+      observer_(nullptr),
       state_(kConnecting),
+      messages_sent_(0),
+      bytes_sent_(0),
+      messages_received_(0),
+      bytes_received_(0),
       data_channel_type_(dct),
       provider_(provider),
       handshake_state_(kHandshakeInit),
       connected_to_provider_(false),
       send_ssrc_set_(false),
       receive_ssrc_set_(false),
       writable_(false),
       send_ssrc_(0),
       receive_ssrc_(0) {
 }
@@ skipping 219 matching lines @@
   // We can send unordered as soon as we receive any DATA message since the
   // remote side must have received the OPEN (and old clients do not send
   // OPEN_ACK).
   if (handshake_state_ == kHandshakeWaitingForAck) {
     handshake_state_ = kHandshakeReady;
   }
 
   bool binary = (params.type == cricket::DMT_BINARY);
   std::unique_ptr<DataBuffer> buffer(new DataBuffer(payload, binary));
   if (state_ == kOpen && observer_) {
+    ++messages_received_;
+    bytes_received_ += buffer->size();
     observer_->OnMessage(*buffer.get());
   } else {
     if (queued_received_data_.byte_count() + payload.size() >
         kMaxQueuedReceivedDataBytes) {
       LOG(LS_ERROR) << "Queued received data exceeds the max buffer size.";
 
       queued_received_data_.Clear();
       if (data_channel_type_ != cricket::DCT_RTP) {
         Close();
       }
@@ skipping 111 matching lines @@
   }
 }
 
 void DataChannel::DeliverQueuedReceivedData() {
   if (!observer_) {
     return;
   }
 
   while (!queued_received_data_.Empty()) {
     std::unique_ptr<DataBuffer> buffer(queued_received_data_.Front());
+    ++messages_received_;
+    bytes_received_ += buffer->size();
     observer_->OnMessage(*buffer);
     queued_received_data_.Pop();
   }
 }
 
 void DataChannel::SendQueuedDataMessages() {
   if (queued_send_data_.Empty()) {
     return;
   }
 
@@ skipping 33 matching lines @@
     send_params.ssrc = config_.id;
   } else {
     send_params.ssrc = send_ssrc_;
   }
   send_params.type = buffer.binary ? cricket::DMT_BINARY : cricket::DMT_TEXT;
 
   cricket::SendDataResult send_result = cricket::SDR_SUCCESS;
   bool success = provider_->SendData(send_params, buffer.data, &send_result);
 
   if (success) {
+    ++messages_sent_;
+    bytes_sent_ += buffer.size();
     return true;
   }
 
   if (data_channel_type_ != cricket::DCT_SCTP) {
     return false;
   }
 
   if (send_result == cricket::SDR_BLOCK) {
     if (!queue_if_blocked || QueueSendDataMessage(buffer)) {
       return false;
@@ skipping 68 matching lines @@
     QueueControlMessage(buffer);
   } else {
     LOG(LS_ERROR) << "Closing the DataChannel due to a failure to send"
                   << " the CONTROL message, send_result = " << send_result;
     Close();
   }
   return retval;
 }
 
 }  // namespace webrtc