RTCStatsCollector: timestamps updated.

webrtc/api/rtcstats.h

 /*
  *  Copyright 2016 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 31 matching lines @@
 // foo.baz->push_back("hello world");
 // uint32_t x = *foo.bar;
 //
 // Pointers to all the members are available with |Members|, allowing iteration:
 //
 // for (const RTCStatsMemberInterface* member : foo.Members()) {
 //   printf("%s = %s\n", member->name(), member->ValueToString().c_str());
 // }
 class RTCStats {
  public:
-  RTCStats(const std::string& id, double timestamp)
-      : id_(id), timestamp_(timestamp) {}
-  RTCStats(std::string&& id, double timestamp)
-      : id_(std::move(id)), timestamp_(timestamp) {}
+  RTCStats(const std::string& id, int64_t timestamp_us)
+      : id_(id), timestamp_us_(timestamp_us) {}
+  RTCStats(std::string&& id, int64_t timestamp_us)
+      : id_(std::move(id)), timestamp_us_(timestamp_us) {}
   virtual ~RTCStats() {}
 
   virtual std::unique_ptr<RTCStats> copy() const = 0;
 
   const std::string& id() const { return id_; }
-  // Time relative to the UNIX epoch (Jan 1, 1970, UTC), in seconds.
-  double timestamp() const { return timestamp_; }
+  // Time relative to the UNIX epoch (Jan 1, 1970, UTC), in microseconds.
+  int64_t timestamp_us() const { return timestamp_us_; }
   // Returns the static member variable |kType| of the implementing class.
   virtual const char* type() const = 0;
   // Returns a vector of pointers to all the RTCStatsMemberInterface members of
   // this class. This allows for iteration of members.
   std::vector<const RTCStatsMemberInterface*> Members() const;
 
   // Creates a human readable string representation of the report, listing all
   // of its members (names and values).
   std::string ToString() const;
 
   // Downcasts the stats object to an |RTCStats| subclass |T|. DCHECKs that the
   // object is of type |T|.
   template<typename T>
   const T& cast_to() const {
     RTC_DCHECK_EQ(type(), T::kType);
     return static_cast<const T&>(*this);
   }
 
  protected:
   // Gets a vector of all members of this |RTCStats| object, including members
   // derived from parent classes. |additional_capacity| is how many more members
   // shall be reserved in the vector (so that subclasses can allocate a vector
   // with room for both parent and child members without it having to resize).
   virtual std::vector<const RTCStatsMemberInterface*>
   MembersOfThisObjectAndAncestors(
       size_t additional_capacity) const;
 
   std::string const id_;
-  double timestamp_;
+  int64_t timestamp_us_;
 };
 
 // All |RTCStats| classes should use this macro in a public section of the class
 // definition.
 //
 // This macro declares the static |kType| and overrides methods as required by
 // subclasses of |RTCStats|: |copy|, |type|, and
 // |MembersOfThisObjectAndAncestors|. The |...| argument is a list of addresses
 // to each member defined in the implementing class (list cannot be empty, must
 // have at least one new member).
 //
 // (Since class names need to be known to implement these methods this cannot be
 // part of the base |RTCStats|. While these methods could be implemented using
 // templates, that would only work for immediate subclasses. Subclasses of
 // subclasses also have to override these methods, resulting in boilerplate
 // code. Using a macro avoids this and works for any |RTCStats| class, including
 // grandchildren.)
 //
 // Sample usage:
 //
 // rtcfoostats.h:
 //   class RTCFooStats : public RTCStats {
 //    public:
-//     RTCFooStats(const std::string& id, double timestamp)
-//         : RTCStats(id, timestamp),
+//     RTCFooStats(const std::string& id, int64_t timestamp_us)
+//         : RTCStats(id, timestamp_us),
 //           foo("foo"),
 //           bar("bar") {
 //     }
 //
 //     WEBRTC_RTCSTATS_IMPL(RTCStats, RTCFooStats,
 //         &foo,
 //         &bar);
 //
 //     RTCStatsMember<int32_t> foo;
 //     RTCStatsMember<int32_t> bar;
@@ skipping 147 matching lines @@
     return &value_;
   }
 
  private:
   T value_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_RTCSTATS_H_