Delete Timing class, timing.h, and update all users.

webrtc/media/base/rtpdataengine_unittest.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
 #include <memory>
 #include <string>
 
 #include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/ssladapter.h"
-#include "webrtc/base/timing.h"
 #include "webrtc/media/base/fakenetworkinterface.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/rtpdataengine.h"
 #include "webrtc/media/base/rtputils.h"
 
-class FakeTiming : public rtc::Timing {
- public:
-  FakeTiming() : now_(0.0) {}
-
-  virtual double TimerNow() {
-    return now_;
-  }
-
-  void set_now(double now) {
-    now_ = now;
-  }
-
- private:
-  double now_;
-};
-
 class FakeDataReceiver : public sigslot::has_slots<> {
  public:
   FakeDataReceiver() : has_received_data_(false) {}
 
   void OnDataReceived(
       const cricket::ReceiveDataParams& params,
       const char* data, size_t len) {
     has_received_data_ = true;
     last_received_data_ = std::string(data, len);
     last_received_data_len_ = len;
@@ skipping 12 matching lines @@
   std::string last_received_data_;
   size_t last_received_data_len_;
   cricket::ReceiveDataParams last_received_data_params_;
 };
 
 class RtpDataMediaChannelTest : public testing::Test {
  protected:
   virtual void SetUp() {
     // Seed needed for each test to satisfy expectations.
     iface_.reset(new cricket::FakeNetworkInterface());
-    timing_ = new FakeTiming();
-    dme_.reset(CreateEngine(timing_));
+    dme_.reset(CreateEngine());
     receiver_.reset(new FakeDataReceiver());
   }
 
   void SetNow(double now) {
-    timing_->set_now(now);
+    clock_.SetTimeNanos(now * rtc::kNumNanosecsPerSec);
   }
 
-  cricket::RtpDataEngine* CreateEngine(FakeTiming* timing) {
+  cricket::RtpDataEngine* CreateEngine() {
     cricket::RtpDataEngine* dme = new cricket::RtpDataEngine();
-    dme->SetTiming(timing);
     return dme;
   }
 
   cricket::RtpDataMediaChannel* CreateChannel() {
     return CreateChannel(dme_.get());
   }
 
   cricket::RtpDataMediaChannel* CreateChannel(cricket::RtpDataEngine* dme) {
     cricket::RtpDataMediaChannel* channel =
         static_cast<cricket::RtpDataMediaChannel*>(dme->CreateChannel(
@@ skipping 42 matching lines @@
   cricket::RtpHeader GetSentDataHeader(int index) {
     std::unique_ptr<const rtc::CopyOnWriteBuffer> packet(
         iface_->GetRtpPacket(index));
     cricket::RtpHeader header;
     GetRtpHeader(packet->data(), packet->size(), &header);
     return header;
   }
 
  private:
   std::unique_ptr<cricket::RtpDataEngine> dme_;
-  // Timing passed into dme_.  Owned by dme_;
-  FakeTiming* timing_;
+  rtc::ScopedFakeClock clock_;
   std::unique_ptr<cricket::FakeNetworkInterface> iface_;
   std::unique_ptr<FakeDataReceiver> receiver_;
 };
 
 TEST_F(RtpDataMediaChannelTest, SetUnknownCodecs) {
   std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::DataCodec known_codec;
   known_codec.id = 103;
   known_codec.name = "google-data";
@@ skipping 126 matching lines @@
       padded_data, GetSentData(1).data(), sizeof(padded_data)));
   cricket::RtpHeader header1 = GetSentDataHeader(1);
   EXPECT_EQ(header1.ssrc, 42U);
   EXPECT_EQ(header1.payload_type, 103);
   EXPECT_EQ(static_cast<uint16_t>(header0.seq_num + 1),
             static_cast<uint16_t>(header1.seq_num));
   EXPECT_EQ(header0.timestamp + 180000, header1.timestamp);
 }
 
 TEST_F(RtpDataMediaChannelTest, SendDataMultipleClocks) {
-  // Timings owned by RtpDataEngines.
-  FakeTiming* timing1 = new FakeTiming();
-  std::unique_ptr<cricket::RtpDataEngine> dme1(CreateEngine(timing1));
+  std::unique_ptr<cricket::RtpDataEngine> dme1(CreateEngine());
   std::unique_ptr<cricket::RtpDataMediaChannel> dmc1(
       CreateChannel(dme1.get()));
-  FakeTiming* timing2 = new FakeTiming();
-  std::unique_ptr<cricket::RtpDataEngine> dme2(CreateEngine(timing2));
+  std::unique_ptr<cricket::RtpDataEngine> dme2(CreateEngine());
   std::unique_ptr<cricket::RtpDataMediaChannel> dmc2(
       CreateChannel(dme2.get()));
 
   ASSERT_TRUE(dmc1->SetSend(true));
   ASSERT_TRUE(dmc2->SetSend(true));
 
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
   ASSERT_TRUE(dmc1->AddSendStream(stream1));
   cricket::StreamParams stream2;
@@ skipping 14 matching lines @@
   params2.ssrc = 42;
 
   unsigned char data[] = "foo";
   rtc::CopyOnWriteBuffer payload(data, 3);
   cricket::SendDataResult result;
 
   EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
   EXPECT_TRUE(dmc2->SendData(params2, payload, &result));
 
   // Should bump timestamp by 90000 because the clock rate is 90khz.
-  timing1->set_now(1);
+  SetNow(1);
+  EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
   // Should bump timestamp by 180000 because the clock rate is 90khz.
-  timing2->set_now(2);
-
-  EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
+  SetNow(2);
   EXPECT_TRUE(dmc2->SendData(params2, payload, &result));
 
   ASSERT_TRUE(HasSentData(3));
   cricket::RtpHeader header1a = GetSentDataHeader(0);
   cricket::RtpHeader header2a = GetSentDataHeader(1);
   cricket::RtpHeader header1b = GetSentDataHeader(2);
   cricket::RtpHeader header2b = GetSentDataHeader(3);
 
   EXPECT_EQ(static_cast<uint16_t>(header1a.seq_num + 1),
             static_cast<uint16_t>(header1b.seq_num));
@@ skipping 101 matching lines @@
     0x80, 0x65, 0x00, 0x02
   };
   rtc::CopyOnWriteBuffer packet(data, sizeof(data));
 
   std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // Too short
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 }