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

components/test_runner/mock_webrtc_peer_connection_handler.cc

 // Copyright 2014 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 "components/test_runner/mock_webrtc_peer_connection_handler.h"
 
 #include <stddef.h>
 
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "components/test_runner/mock_webrtc_data_channel_handler.h"
 #include "components/test_runner/mock_webrtc_dtmf_sender_handler.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/web_task.h"
 #include "components/test_runner/web_test_delegate.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/WebRTCAnswerOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
 #include "third_party/WebKit/public/platform/WebRTCOfferOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebRTCStatsResponse.h"
 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
 using namespace blink;
 
 namespace test_runner {
 
+namespace {
+
+class MockWebRTCStats : public blink::WebRTCStats {
+ public:
+  class MemberIterator : public blink::WebRTCStatsMemberIterator {
+   public:
+    MemberIterator(
+        const std::vector<std::pair<std::string, std::string>>& values)

[tommi (sloooow) - chröme, 2016/07/27 18:38:40]

I think that in cases like this, it's more appropriate to pass in a const* than
a const&

[hbos_chromium, 2016/07/28 08:27:45]

Done.

+        : values_(values) {}
+
+    // blink::WebRTCStatsMemberIterator
+    bool isEnd() const override { return i >= values_.size(); }
+    void next() override { ++i; }
+    blink::WebRTCStatsMemberName name() const override {
+      return blink::WebRTCStatsMemberNameUnknown;
+    }
+    blink::WebString displayName() const override {
+      return blink::WebString::fromUTF8(values_[i].first);
+    }
+    blink::WebRTCStatsMemberType type() const override {
+      return blink::WebRTCStatsMemberTypeString;
+    }
+    int valueInt() const override {
+      NOTREACHED();
+      return 0;
+    }
+    int64_t valueInt64() const override {
+      NOTREACHED();
+      return 0;
+    }
+    float valueFloat() const override {
+      NOTREACHED();
+      return 0.0f;
+    }
+    blink::WebString valueString() const override {
+      return blink::WebString::fromUTF8(values_[i].second);
+    }
+    bool valueBool() const override {
+      NOTREACHED();
+      return false;
+    }
+    blink::WebString valueToString() const override {
+      return valueString();
+    }
+
+   private:
+    size_t i = 0;
+    const std::vector<std::pair<std::string, std::string>>& values_;
+  };
+
+  MockWebRTCStats(const char* id, const char* type_name, double timestamp)
+      : id_(id), type_name_(type_name), timestamp_(timestamp) {}
+
+  // blink::WebRTCStats
+  blink::WebString id() const override {
+    return blink::WebString::fromUTF8(id_);
+  }
+  blink::WebRTCStatsType type() const override {
+    return blink::WebRTCStatsTypeUnknown;
+  }
+  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_);
+  }
+
+  void addStatistic(const std::string& name, const std::string& value) {
+    values_.push_back(std::make_pair(name, value));
+  }
+
+ private:
+  const std::string id_;
+  const std::string type_name_;
+  const double timestamp_;
+  // (name, value) pairs.
+  std::vector<std::pair<std::string, std::string>> values_;
+};
+
+}  // namespace
+
 MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler()
     : weak_factory_(this) {}
 
 MockWebRTCPeerConnectionHandler::~MockWebRTCPeerConnectionHandler() {
 }
 
 MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler(
     WebRTCPeerConnectionHandlerClient* client,
     TestInterfaces* interfaces)
     : client_(client),
@@ skipping 242 matching lines @@
   client_->negotiationNeeded();
 }
 
 void MockWebRTCPeerConnectionHandler::getStats(
     const WebRTCStatsRequest& request) {
   WebRTCStatsResponse response = request.createResponse();
   double current_date =
       interfaces_->GetDelegate()->GetCurrentTimeInMillisecond();
   if (request.hasSelector()) {
     // FIXME: There is no check that the fetched values are valid.
-    size_t report_index =
-        response.addReport("Mock video", "ssrc", current_date);
-    response.addStatistic(report_index, "type", "video");
+    MockWebRTCStats stats("Mock video", "ssrc", current_date);
+    stats.addStatistic("type", "video");
+    response.addStats(stats);
   } else {
     for (int i = 0; i < stream_count_; ++i) {
-      size_t report_index =
-          response.addReport("Mock audio", "ssrc", current_date);
-      response.addStatistic(report_index, "type", "audio");
-      report_index = response.addReport("Mock video", "ssrc", current_date);
-      response.addStatistic(report_index, "type", "video");
+      MockWebRTCStats audio_stats("Mock audio", "ssrc", current_date);
+      audio_stats.addStatistic("type", "audio");
+      response.addStats(audio_stats);
+
+      MockWebRTCStats video_stats("Mock video", "ssrc", current_date);
+      video_stats.addStatistic("type", "video");
+      response.addStats(video_stats);
     }
   }
   interfaces_->GetDelegate()->PostTask(new WebCallbackTask(
       base::Bind(&blink::WebRTCStatsRequest::requestSucceeded,
                  base::Owned(new WebRTCStatsRequest(request)), response)));
 }
 
 void MockWebRTCPeerConnectionHandler::ReportCreationOfDataChannel() {
   WebRTCDataChannelInit init;
   WebRTCDataChannelHandler* remote_data_channel =
@@ skipping 19 matching lines @@
     const WebMediaStreamTrack& track) {
   return new MockWebRTCDTMFSenderHandler(track, interfaces_->GetDelegate());
 }
 
 void MockWebRTCPeerConnectionHandler::stop() {
   stopped_ = true;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace test_runner