Renamed WebRTCStats.h to WebRTCLegacyStats.h and cleaned it up

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>
@@ skipping 17 matching lines @@
 #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 {
+class MockWebRTCLegacyStats : public blink::WebRTCLegacyStats {
  public:
-  class MemberIterator : public blink::WebRTCStatsMemberIterator {
+  class MemberIterator : public blink::WebRTCLegacyStatsMemberIterator {
    public:
     MemberIterator(
         const std::vector<std::pair<std::string, std::string>>* values)
         : values_(values) {}
 
-    // blink::WebRTCStatsMemberIterator
+    // blink::WebRTCLegacyStatsMemberIterator
     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 {
+    blink::WebString name() const override {
       return blink::WebString::fromUTF8((*values_)[i].first);
     }
-    blink::WebRTCStatsMemberType type() const override {
-      return blink::WebRTCStatsMemberTypeString;
+    blink::WebRTCLegacyStatsMemberType type() const override {
+      return blink::WebRTCLegacyStatsMemberTypeString;
     }
     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)
+  MockWebRTCLegacyStats(const char* id, const char* type_name, double timestamp)
       : id_(id), type_name_(type_name), timestamp_(timestamp) {}
 
-  // blink::WebRTCStats
+  // blink::WebRTCLegacyStats
   blink::WebString id() const override {
     return blink::WebString::fromUTF8(id_);
   }
-  blink::WebRTCStatsType type() const override {
-    return blink::WebRTCStatsTypeUnknown;
-  }
-  blink::WebString typeToString() const override {
+  blink::WebString type() const override {
     return blink::WebString::fromUTF8(type_name_);
   }
   double timestamp() const override {
     return timestamp_;
   }
-  blink::WebRTCStatsMemberIterator* iterator() const override {
+  blink::WebRTCLegacyStatsMemberIterator* 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_;
@@ skipping 259 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.
-    MockWebRTCStats stats("Mock video", "ssrc", current_date);
+    MockWebRTCLegacyStats stats("Mock video", "ssrc", current_date);
     stats.addStatistic("type", "video");
     response.addStats(stats);
   } else {
     for (int i = 0; i < stream_count_; ++i) {
-      MockWebRTCStats audio_stats("Mock audio", "ssrc", current_date);
+      MockWebRTCLegacyStats audio_stats("Mock audio", "ssrc", current_date);
       audio_stats.addStatistic("type", "audio");
       response.addStats(audio_stats);
 
-      MockWebRTCStats video_stats("Mock video", "ssrc", current_date);
+      MockWebRTCLegacyStats 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() {
@@ skipping 21 matching lines @@
     const WebMediaStreamTrack& track) {
   return new MockWebRTCDTMFSenderHandler(track, interfaces_->GetDelegate());
 }
 
 void MockWebRTCPeerConnectionHandler::stop() {
   stopped_ = true;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace test_runner