Update QuicTransportChannel to latest version of libquic

webrtc/p2p/quic/quicconnectionhelper_unittest.cc

 /*
  *  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.
  */
 
 #include "webrtc/p2p/quic/quicconnectionhelper.h"
 
 #include "net/quic/quic_time.h"
 #include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
 
 using cricket::QuicAlarm;
 using cricket::QuicConnectionHelper;
 
 using net::QuicClock;
 using net::QuicTime;
 using net::QuicWallTime;
 
 // Clock that can be set to arbitrary times.
 class MockClock : public QuicClock {
@@ skipping 35 matching lines @@
   void Clear() { fired_ = false; }
 
  private:
   bool fired_;
 };
 
 class QuicAlarmTest : public ::testing::Test {
  public:
   QuicAlarmTest()
       : delegate_(new MockAlarmDelegate()),
-        alarm_(new QuicAlarm(&clock_, rtc::Thread::Current(), delegate_)) {}
+        alarm_(new QuicAlarm(
+            &clock_,
+            rtc::Thread::Current(),
+            net::QuicArenaScopedPtr<net::QuicAlarm::Delegate>(delegate_))) {}
 
   // Make the alarm fire after the given microseconds (us). Negative values
   // imply the alarm should fire immediately.
   void SetTime(int us) {
     QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(us);
     alarm_->Set(clock_.Now().Add(delta));
   }
 
   // Make rtc::Thread::Current() process the next message.
   void ProcessNextMessage() { rtc::Thread::Current()->ProcessMessages(0); }
 
  protected:
   // Handles event that alarm fires.
   MockAlarmDelegate* delegate_;
   // Used for setting clock time relative to alarm.
   MockClock clock_;
 
-  scoped_ptr<QuicAlarm> alarm_;
+  rtc::scoped_ptr<QuicAlarm> alarm_;
 };
 
 // Test that the alarm is fired.
 TEST_F(QuicAlarmTest, FireAlarm) {
   SetTime(-1);
   ProcessNextMessage();
   ASSERT_TRUE(delegate_->fired());
   ASSERT_EQ(QuicTime::Zero(), alarm_->deadline());
 }
 
@@ skipping 15 matching lines @@
   ASSERT_FALSE(delegate_->fired());
 }
 
 // Test that timing for posting task is accurate.
 TEST_F(QuicAlarmTest, AlarmGetDelay) {
   SetTime(1000000);
   EXPECT_EQ(1000, alarm_->GetDelay());
   clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(300000));
   EXPECT_EQ(700, alarm_->GetDelay());
 }