WebRTCStats added, retaining type info when surfacing WebRTC stats into Blink

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.h>
 
 #include <string>
 #include <utility>
@@ skipping 25 matching lines @@
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/media_switches.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebRTCAnswerOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCConfiguration.h"
 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
 #include "third_party/WebKit/public/platform/WebRTCOfferOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescription.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescriptionRequest.h"
+#include "third_party/WebKit/public/platform/WebRTCStats.h"
 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/webrtc/pc/mediasession.h"
 
 using webrtc::DataChannelInterface;
 using webrtc::IceCandidateInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::PeerConnectionInterface;
 using webrtc::PeerConnectionObserver;
 using webrtc::StatsReport;
@@ skipping 388 matching lines @@
     DLOG_IF(ERROR, !webkit_request_.isNull())
         << "SetSessionDescriptionRequest not completed. Shutting down?";
   }
 
  private:
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
   blink::WebRTCVoidRequest webkit_request_;
   SessionDescriptionRequestTracker tracker_;
 };
 
+blink::WebRTCStatsType WebRTCStatsTypeFromStatsType(
+    webrtc::StatsReport::StatsType name) {
+  // TODO(hbos): Translate StatsType -> WebRTCStatsType. crbug.com/627816
+  return blink::WebRTCStatsTypeUnknown;
+}
+
+blink::WebRTCStatsMemberName WebRTCStatsMemberNameFromStatsValueName(
+    webrtc::StatsReport::StatsValueName name) {
+  // TODO(hbos): Translate StatsValueName -> WebRTCStatsMemberName.
+  // crbug.com/627816
+  return blink::WebRTCStatsMemberNameUnknown;
+}
+
+blink::WebRTCStatsMemberType WebRTCStatsMemberTypeFromStatsValueType(
+    webrtc::StatsReport::Value::Type type) {
+  switch (type) {
+    case StatsReport::Value::kInt:
+      return blink::WebRTCStatsMemberTypeInt;
+    case StatsReport::Value::kInt64:
+      return blink::WebRTCStatsMemberTypeInt64;
+    case StatsReport::Value::kFloat:
+      return blink::WebRTCStatsMemberTypeFloat;
+    case StatsReport::Value::kString:
+    case StatsReport::Value::kStaticString:
+      return blink::WebRTCStatsMemberTypeString;
+    case StatsReport::Value::kBool:
+      return blink::WebRTCStatsMemberTypeBool;
+    case StatsReport::Value::kId:
+      return blink::WebRTCStatsMemberTypeId;
+  }
+  NOTREACHED();
+  return blink::WebRTCStatsMemberTypeInt;
+}
+
 // Class mapping responses from calls to libjingle
 // GetStats into a blink::WebRTCStatsCallback.
 class StatsResponse : public webrtc::StatsObserver {
  public:
   explicit StatsResponse(const scoped_refptr<LocalRTCStatsRequest>& request)
       : request_(request.get()),
         main_thread_(base::ThreadTaskRunnerHandle::Get()) {
     // Measure the overall time it takes to satisfy a getStats request.
     TRACE_EVENT_ASYNC_BEGIN0("webrtc", "getStats_Native", this);
     signaling_thread_checker_.DetachFromThread();
@@ skipping 10 matching lines @@
       report_copies->push_back(new Report(r));
 
     main_thread_->PostTaskAndReply(FROM_HERE,
         base::Bind(&StatsResponse::DeliverCallback, this,
                    base::Unretained(report_copies)),
         base::Bind(&StatsResponse::DeleteReports,
                    base::Unretained(report_copies)));
   }
 
  private:
-  struct Report {
+  class Report : public blink::WebRTCStats {
+   public:
+    class MemberIterator : public blink::WebRTCStatsMemberIterator {
+     public:
+      MemberIterator(const StatsReport::Values::const_iterator& it,
+                     const StatsReport::Values::const_iterator& end)
+          : it_(it), end_(end) {}
+
+      // blink::WebRTCStatsMemberIterator
+      bool isEnd() const override { return it_ == end_; }
+      void next() override { ++it_; }
+      blink::WebRTCStatsMemberName name() const override {
+        return WebRTCStatsMemberNameFromStatsValueName(it_->second->name);
+      }
+      blink::WebString displayName() const override {
+        return blink::WebString::fromUTF8(it_->second->display_name());
+      }
+      blink::WebRTCStatsMemberType type() const override {
+        return WebRTCStatsMemberTypeFromStatsValueType(it_->second->type());
+      }
+      int valueInt() const override {
+        return it_->second->int_val();
+      }
+      int64_t valueInt64() const override {
+        return it_->second->int64_val();
+      }
+      float valueFloat() const override {
+        return it_->second->float_val();
+      }
+      blink::WebString valueString() const override {
+        const StatsReport::ValuePtr& value = it_->second;
+        if (value->type() == StatsReport::Value::kString)
+          return blink::WebString::fromUTF8(value->string_val());
+        DCHECK_EQ(value->type(), StatsReport::Value::kStaticString);
+        return blink::WebString::fromUTF8(value->static_string_val());
+      }
+      bool valueBool() const override {
+        return it_->second->bool_val();
+      }
+      blink::WebString valueToString() const override {
+        const StatsReport::ValuePtr& value = it_->second;
+        if (value->type() == StatsReport::Value::kString)
+          return blink::WebString::fromUTF8(value->string_val());
+        if (value->type() == StatsReport::Value::kStaticString)
+          return blink::WebString::fromUTF8(value->static_string_val());
+        return blink::WebString::fromUTF8(value->ToString());
+      }
+
+     private:
+      StatsReport::Values::const_iterator it_;
+      StatsReport::Values::const_iterator end_;
+    };
+
     Report(const StatsReport* report)
-        : thread_checker(), id(report->id()->ToString()),
-          type(report->TypeToString()),  timestamp(report->timestamp()),
-          values(report->values()) {
+        : thread_checker_(),
+          id_(report->id()->ToString()),
+          type_(report->type()),
+          type_name_(report->TypeToString()),
+          timestamp_(report->timestamp()),
+          values_(report->values()) {}
+
+    ~Report() override {
+      // Since the values vector holds pointers to const objects that are bound
+      // to the signaling thread, they must be released on the same thread.
+      DCHECK(thread_checker_.CalledOnValidThread());
     }
 
-    ~Report() {
-      // Since the values vector holds pointers to const objects that are bound
-      // to the signaling thread, they must be released on the same thread.
-      DCHECK(thread_checker.CalledOnValidThread());
+    // blink::WebRTCStats
+    blink::WebString id() const override {
+      return blink::WebString::fromUTF8(id_);
+    }
+    blink::WebRTCStatsType type() const override {
+      return WebRTCStatsTypeFromStatsType(type_);
+    }
+    blink::WebString typeToString() const override {
+      return blink::WebString::fromUTF8(type_name_);
+    }
+    double timestamp() const override {
+      return timestamp_;
+    }
+    blink::WebRTCStatsMemberIterator* iterator() const override {
+      return new MemberIterator(values_.cbegin(), values_.cend());
     }
 
-    const base::ThreadChecker thread_checker;
-    const std::string id, type;
-    const double timestamp;
-    const StatsReport::Values values;
+    bool HasValues() const {
+      return values_.size() > 0;
+    }
+
+   private:
+    const base::ThreadChecker thread_checker_;
+    const std::string id_;
+    const StatsReport::StatsType type_;
+    const std::string type_name_;
+    const double timestamp_;
+    const StatsReport::Values values_;
   };
 
   static void DeleteReports(std::vector<Report*>* reports) {
     TRACE_EVENT0("webrtc", "StatsResponse::DeleteReports");
     for (auto* p : *reports)
       delete p;
     delete reports;
   }
 
   void DeliverCallback(const std::vector<Report*>* reports) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     TRACE_EVENT0("webrtc", "StatsResponse::DeliverCallback");
 
     rtc::scoped_refptr<LocalRTCStatsResponse> response(
         request_->createResponse().get());
     for (const auto* report : *reports) {
-      if (report->values.size() > 0)
+      if (report->HasValues())
         AddReport(response.get(), *report);
     }
 
     // Record the getStats operation as done before calling into Blink so that
     // we don't skew the perf measurements of the native code with whatever the
     // callback might be doing.
     TRACE_EVENT_ASYNC_END0("webrtc", "getStats_Native", this);
     request_->requestSucceeded(response);
     request_ = nullptr;  // must be freed on the main thread.
   }
 
   void AddReport(LocalRTCStatsResponse* response, const Report& report) {
-    int idx = response->addReport(blink::WebString::fromUTF8(report.id),
-                                  blink::WebString::fromUTF8(report.type),
-                                  report.timestamp);
-    blink::WebString name, value_str;
-    for (const auto& value : report.values) {
-      const StatsReport::ValuePtr& v = value.second;
-      name = blink::WebString::fromUTF8(value.second->display_name());
-
-      if (v->type() == StatsReport::Value::kString)
-        value_str = blink::WebString::fromUTF8(v->string_val());
-      if (v->type() == StatsReport::Value::kStaticString)
-        value_str = blink::WebString::fromUTF8(v->static_string_val());
-      else
-        value_str = blink::WebString::fromUTF8(v->ToString());
-
-      response->addStatistic(idx, name, value_str);
-    }
+    response->addStats(report);
   }
 
   rtc::scoped_refptr<LocalRTCStatsRequest> request_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
   base::ThreadChecker signaling_thread_checker_;
 };
 
 void GetStatsOnSignalingThread(
     const scoped_refptr<webrtc::PeerConnectionInterface>& pc,
     webrtc::PeerConnectionInterface::StatsOutputLevel level,
@@ skipping 191 matching lines @@
 void LocalRTCStatsRequest::requestSucceeded(
     const LocalRTCStatsResponse* response) {
   impl_.requestSucceeded(response->webKitStatsResponse());
 }
 
 // Implementation of LocalRTCStatsResponse.
 blink::WebRTCStatsResponse LocalRTCStatsResponse::webKitStatsResponse() const {
   return impl_;
 }
 
-size_t LocalRTCStatsResponse::addReport(blink::WebString type,
-                                        blink::WebString id,
-                                        double timestamp) {
-  return impl_.addReport(type, id, timestamp);
-}
-
-void LocalRTCStatsResponse::addStatistic(size_t report,
-                                         blink::WebString name,
-                                         blink::WebString value) {
-  impl_.addStatistic(report, name, value);
+void LocalRTCStatsResponse::addStats(const blink::WebRTCStats& stats) {
+  impl_.addStats(stats);
 }
 
 // Receives notifications from a PeerConnection object about state changes,
 // track addition/removal etc.  The callbacks we receive here come on the
 // signaling thread, so this class takes care of delivering them to an
 // RTCPeerConnectionHandler instance on the main thread.
 // In order to do safe PostTask-ing, the class is reference counted and
 // checks for the existence of the RTCPeerConnectionHandler instance before
 // delivering callbacks on the main thread.
 class RTCPeerConnectionHandler::Observer
@@ skipping 1027 matching lines @@
 }
 
 void RTCPeerConnectionHandler::ResetUMAStats() {
   DCHECK(thread_checker_.CalledOnValidThread());
   num_local_candidates_ipv6_ = 0;
   num_local_candidates_ipv4_ = 0;
   ice_connection_checking_start_ = base::TimeTicks();
   memset(ice_state_seen_, 0, sizeof(ice_state_seen_));
 }
 }  // namespace content