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

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 22 matching lines @@
 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #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/WebRTCLegacyStats.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 396 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(
+blink::WebRTCLegacyStatsMemberType
+WebRTCLegacyStatsMemberTypeFromStatsValueType(
     webrtc::StatsReport::Value::Type type) {
   switch (type) {
     case StatsReport::Value::kInt:
-      return blink::WebRTCStatsMemberTypeInt;
+      return blink::WebRTCLegacyStatsMemberTypeInt;
     case StatsReport::Value::kInt64:
-      return blink::WebRTCStatsMemberTypeInt64;
+      return blink::WebRTCLegacyStatsMemberTypeInt64;
     case StatsReport::Value::kFloat:
-      return blink::WebRTCStatsMemberTypeFloat;
+      return blink::WebRTCLegacyStatsMemberTypeFloat;
     case StatsReport::Value::kString:
     case StatsReport::Value::kStaticString:
-      return blink::WebRTCStatsMemberTypeString;
+      return blink::WebRTCLegacyStatsMemberTypeString;
     case StatsReport::Value::kBool:
-      return blink::WebRTCStatsMemberTypeBool;
+      return blink::WebRTCLegacyStatsMemberTypeBool;
     case StatsReport::Value::kId:
-      return blink::WebRTCStatsMemberTypeId;
+      return blink::WebRTCLegacyStatsMemberTypeId;
   }
   NOTREACHED();
-  return blink::WebRTCStatsMemberTypeInt;
+  return blink::WebRTCLegacyStatsMemberTypeInt;
 }
 
 // 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.
@@ skipping 12 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:
-  class Report : public blink::WebRTCStats {
+  class Report : public blink::WebRTCLegacyStats {
    public:
-    class MemberIterator : public blink::WebRTCStatsMemberIterator {
+    class MemberIterator : public blink::WebRTCLegacyStatsMemberIterator {
      public:
       MemberIterator(const StatsReport::Values::const_iterator& it,
                      const StatsReport::Values::const_iterator& end)
           : it_(it), end_(end) {}
 
-      // blink::WebRTCStatsMemberIterator
+      // blink::WebRTCLegacyStatsMemberIterator
       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 {
+      blink::WebString name() const override {
         return blink::WebString::fromUTF8(it_->second->display_name());
       }
-      blink::WebRTCStatsMemberType type() const override {
-        return WebRTCStatsMemberTypeFromStatsValueType(it_->second->type());
+      blink::WebRTCLegacyStatsMemberType type() const override {
+        return WebRTCLegacyStatsMemberTypeFromStatsValueType(
+            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();
       }
@@ skipping 28 matching lines @@
           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());
     }
 
-    // blink::WebRTCStats
+    // blink::WebRTCLegacyStats
     blink::WebString id() const override {
       return blink::WebString::fromUTF8(id_);
     }
-    blink::WebRTCStatsType type() const override {
-      return WebRTCStatsTypeFromStatsType(type_);
-    }
-    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_.cbegin(), values_.cend());
     }
 
     bool HasValues() const {
       return values_.size() > 0;
     }
 
    private:
     const base::ThreadChecker thread_checker_;
     const std::string id_;
@@ skipping 239 matching lines @@
 void LocalRTCStatsRequest::requestSucceeded(
     const LocalRTCStatsResponse* response) {
   impl_.requestSucceeded(response->webKitStatsResponse());
 }
 
 // Implementation of LocalRTCStatsResponse.
 blink::WebRTCStatsResponse LocalRTCStatsResponse::webKitStatsResponse() const {
   return impl_;
 }
 
-void LocalRTCStatsResponse::addStats(const blink::WebRTCStats& stats) {
+void LocalRTCStatsResponse::addStats(const blink::WebRTCLegacyStats& 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.
@@ skipping 1028 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