Merge from Chromium at DEPS revision 228962

This commit was generated by merge_to_master.py.

Change-Id: I23bd7d7766f213fd52f28ae5e1ecc6ae9df905ea

10 files changed, 124 insertions, 92 deletions

diff --git a/media/cast/video_sender/codecs/vp8/vp8_encoder.cc b/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
index eaf6fbd714..44761ed5d9 100644
--- a/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
+++ b/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
@@ -158,7 +158,7 @@ bool Vp8Encoder::Encode(const I420VideoFrame& input_image,
   // Get encoded frame.
   const vpx_codec_cx_pkt_t *pkt = NULL;
   vpx_codec_iter_t iter = NULL;
-  int total_size = 0;
+  size_t total_size = 0;
   while ((pkt = vpx_codec_get_cx_data(encoder_, &iter)) != NULL) {
     if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
       total_size += pkt->data.frame.sz;
@@ -183,6 +183,9 @@ bool Vp8Encoder::Encode(const I420VideoFrame& input_image,
   encoded_image->last_referenced_frame_id = latest_frame_id_to_reference;
   encoded_image->frame_id = ++last_encoded_frame_id_;
 
+  VLOG(1) << "VP8 encoded frame:" << static_cast<int>(encoded_image->frame_id)
+          << " sized:" << total_size;
+
   if (encoded_image->key_frame) {
     key_frame_requested_ = false;
 
@@ -310,7 +313,11 @@ void Vp8Encoder::GetCodecUpdateFlags(Vp8Buffers buffer_to_update,
 }
 
 void Vp8Encoder::UpdateRates(uint32 new_bitrate) {
-  config_->rc_target_bitrate = new_bitrate / 1000;  // In kbit/s.
+  uint32 new_bitrate_kbit = new_bitrate / 1000;
+  if (config_->rc_target_bitrate == new_bitrate_kbit) return;
+
+  config_->rc_target_bitrate = new_bitrate_kbit;
+
   // Update encoder context.
   if (vpx_codec_enc_config_set(encoder_, config_.get())) {
     DCHECK(false) << "Invalid return value";
diff --git a/media/cast/video_sender/codecs/vp8/vp8_encoder.h b/media/cast/video_sender/codecs/vp8/vp8_encoder.h
index 3b041a01d2..777f862e4a 100644
--- a/media/cast/video_sender/codecs/vp8/vp8_encoder.h
+++ b/media/cast/video_sender/codecs/vp8/vp8_encoder.h
@@ -42,7 +42,7 @@ class Vp8Encoder {
     kAltRefBuffer = 0,
     kGoldenBuffer = 1,
     kLastBuffer = 2,
-    kNoBuffer = 3 // Note: must be last.
+    kNoBuffer = 3  // Note: must be last.
   };
 
   void InitEncode(int number_of_cores);
@@ -54,7 +54,7 @@ class Vp8Encoder {
   Vp8Buffers GetNextBufferToUpdate();
 
   // Calculate which previous frame to reference.
-  uint8_t GetLatestFrameIdToReference();
+  uint8 GetLatestFrameIdToReference();
 
   // Get encoder flags for our referenced encoder buffers.
   void GetCodecReferenceFlags(vpx_codec_flags_t* flags);
diff --git a/media/cast/video_sender/mock_video_encoder_controller.cc b/media/cast/video_sender/mock_video_encoder_controller.cc
new file mode 100644
index 0000000000..4f649aa44f
--- /dev/null
+++ b/media/cast/video_sender/mock_video_encoder_controller.cc
@@ -0,0 +1,17 @@
+// Copyright 2013 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 "media/cast/video_sender/mock_video_encoder_controller.h"
+
+namespace media {
+namespace cast {
+
+MockVideoEncoderController::MockVideoEncoderController() {
+}
+
+MockVideoEncoderController::~MockVideoEncoderController() {
+}
+
+}  // namespace cast
+}  // namespace media
diff --git a/media/cast/video_sender/mock_video_encoder_controller.h b/media/cast/video_sender/mock_video_encoder_controller.h
index 90b2abdf3b..a97bcb1eb9 100644
--- a/media/cast/video_sender/mock_video_encoder_controller.h
+++ b/media/cast/video_sender/mock_video_encoder_controller.h
@@ -13,6 +13,9 @@ namespace cast {
 
 class MockVideoEncoderController : public VideoEncoderController {
  public:
+  MockVideoEncoderController();
+  virtual ~MockVideoEncoderController();
+
   MOCK_METHOD1(SetBitRate, void(int new_bit_rate));
 
   MOCK_METHOD1(SkipNextFrame, void(bool skip_next_frame));
diff --git a/media/cast/video_sender/video_encoder.cc b/media/cast/video_sender/video_encoder.cc
index 94a296c1bc..42d1a88cc2 100644
--- a/media/cast/video_sender/video_encoder.cc
+++ b/media/cast/video_sender/video_encoder.cc
@@ -10,11 +10,11 @@
 namespace media {
 namespace cast {
 
-VideoEncoder::VideoEncoder(scoped_refptr<CastThread> cast_thread,
+VideoEncoder::VideoEncoder(scoped_refptr<CastEnvironment> cast_environment,
                            const VideoSenderConfig& video_config,
                            uint8 max_unacked_frames)
     : video_config_(video_config),
-      cast_thread_(cast_thread),
+      cast_environment_(cast_environment),
       skip_next_frame_(false),
       skip_count_(0) {
   if (video_config.codec == kVp8) {
@@ -43,7 +43,7 @@ bool VideoEncoder::EncodeVideoFrame(
     return false;
   }
 
-  cast_thread_->PostTask(CastThread::VIDEO_ENCODER, FROM_HERE,
+  cast_environment_->PostTask(CastEnvironment::VIDEO_ENCODER, FROM_HERE,
       base::Bind(&VideoEncoder::EncodeVideoFrameEncoderThread, this,
           video_frame, capture_time, dynamic_config_, frame_encoded_callback,
           frame_release_callback));
@@ -69,7 +69,8 @@ void VideoEncoder::EncodeVideoFrameEncoderThread(
   bool retval = vp8_encoder_->Encode(*video_frame, encoded_frame.get());
 
   // We are done with the video frame release it.
-  cast_thread_->PostTask(CastThread::MAIN, FROM_HERE, frame_release_callback);
+  cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
+                              frame_release_callback);
 
   if (!retval) {
     VLOG(1) << "Encoding failed";
@@ -79,32 +80,32 @@ void VideoEncoder::EncodeVideoFrameEncoderThread(
     VLOG(1) << "Encoding resulted in an empty frame";
     return;
   }
-  cast_thread_->PostTask(CastThread::MAIN, FROM_HERE,
+  cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(frame_encoded_callback,
           base::Passed(&encoded_frame), capture_time));
 }
 
 // Inform the encoder about the new target bit rate.
-void VideoEncoder::SetBitRate(int new_bit_rate) OVERRIDE {
+void VideoEncoder::SetBitRate(int new_bit_rate) {
   dynamic_config_.bit_rate = new_bit_rate;
 }
 
 // Inform the encoder to not encode the next frame.
-void VideoEncoder::SkipNextFrame(bool skip_next_frame) OVERRIDE {
+void VideoEncoder::SkipNextFrame(bool skip_next_frame) {
   skip_next_frame_ = skip_next_frame;
 }
 
 // Inform the encoder to encode the next frame as a key frame.
-void VideoEncoder::GenerateKeyFrame() OVERRIDE {
+void VideoEncoder::GenerateKeyFrame() {
   dynamic_config_.key_frame_requested = true;
 }
 
 // Inform the encoder to only reference frames older or equal to frame_id;
-void VideoEncoder::LatestFrameIdToReference(uint8 frame_id) OVERRIDE {
+void VideoEncoder::LatestFrameIdToReference(uint8 frame_id) {
   dynamic_config_.latest_frame_id_to_reference = frame_id;
 }
 
-int VideoEncoder::NumberOfSkippedFrames() const OVERRIDE {
+int VideoEncoder::NumberOfSkippedFrames() const {
   return skip_count_;
 }
 
diff --git a/media/cast/video_sender/video_encoder.h b/media/cast/video_sender/video_encoder.h
index d3b261e103..fa85468c1f 100644
--- a/media/cast/video_sender/video_encoder.h
+++ b/media/cast/video_sender/video_encoder.h
@@ -9,7 +9,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_config.h"
-#include "media/cast/cast_thread.h"
+#include "media/cast/cast_environment.h"
 #include "media/cast/video_sender/codecs/vp8/vp8_encoder.h"
 
 namespace media {
@@ -23,12 +23,10 @@ class VideoEncoder : public VideoEncoderController,
   typedef base::Callback<void(scoped_ptr<EncodedVideoFrame>,
                               const base::TimeTicks&)> FrameEncodedCallback;
 
-  VideoEncoder(scoped_refptr<CastThread> cast_thread,
+  VideoEncoder(scoped_refptr<CastEnvironment> cast_environment,
                const VideoSenderConfig& video_config,
                uint8 max_unacked_frames);
 
-  virtual ~VideoEncoder();
-
   // Called from the main cast thread. This function post the encode task to the
   // video encoder thread;
   // The video_frame must be valid until the closure callback is called.
@@ -42,6 +40,8 @@ class VideoEncoder : public VideoEncoderController,
                         const base::Closure frame_release_callback);
 
  protected:
+  virtual ~VideoEncoder();
+
   struct CodecDynamicConfig {
     bool key_frame_requested;
     uint8 latest_frame_id_to_reference;
@@ -64,8 +64,10 @@ class VideoEncoder : public VideoEncoderController,
   virtual int NumberOfSkippedFrames() const OVERRIDE;
 
  private:
+  friend class base::RefCountedThreadSafe<VideoEncoder>;
+
   const VideoSenderConfig video_config_;
-  scoped_refptr<CastThread> cast_thread_;
+  scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<Vp8Encoder> vp8_encoder_;
   CodecDynamicConfig dynamic_config_;
   bool skip_next_frame_;
diff --git a/media/cast/video_sender/video_encoder_unittest.cc b/media/cast/video_sender/video_encoder_unittest.cc
index d18a043b73..2e511adb3a 100644
--- a/media/cast/video_sender/video_encoder_unittest.cc
+++ b/media/cast/video_sender/video_encoder_unittest.cc
@@ -8,7 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/cast_thread.h"
+#include "media/cast/cast_environment.h"
 #include "media/cast/test/fake_task_runner.h"
 #include "media/cast/video_sender/video_encoder.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -46,7 +46,12 @@ class TestVideoEncoderCallback :
     EXPECT_EQ(expected_capture_time_, capture_time);
   }
 
+ protected:
+  virtual ~TestVideoEncoderCallback() {}
+
  private:
+  friend class base::RefCountedThreadSafe<TestVideoEncoderCallback>;
+
   bool expected_key_frame_;
   uint8 expected_frame_id_;
   uint8 expected_last_referenced_frame_id_;
@@ -85,16 +90,16 @@ class VideoEncoderTest : public ::testing::Test {
     video_frame_.v_plane.data = &(pixels_[0]);
   }
 
-  ~VideoEncoderTest() {}
+  virtual ~VideoEncoderTest() {}
 
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
-    cast_thread_ = new CastThread(task_runner_, task_runner_, task_runner_,
-                                  task_runner_, task_runner_);
+    cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
+        task_runner_, task_runner_, task_runner_, task_runner_);
   }
 
   void Configure(uint8 max_unacked_frames) {
-    video_encoder_= new VideoEncoder(cast_thread_, video_config_,
+    video_encoder_= new VideoEncoder(cast_environment_, video_config_,
        max_unacked_frames);
     video_encoder_controller_ = video_encoder_.get();
   }
@@ -108,7 +113,7 @@ class VideoEncoderTest : public ::testing::Test {
   VideoEncoderController* video_encoder_controller_;
   I420VideoFrame video_frame_;
 
-  scoped_refptr<CastThread> cast_thread_;
+  scoped_refptr<CastEnvironment> cast_environment_;
 };
 
 TEST_F(VideoEncoderTest, EncodePattern30fpsRunningOutOfAck) {
diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc
index 1b42238832..cdc152196a 100644
--- a/media/cast/video_sender/video_sender.cc
+++ b/media/cast/video_sender/video_sender.cc
@@ -24,8 +24,6 @@ class LocalRtcpVideoSenderFeedback : public RtcpSenderFeedback {
       : video_sender_(video_sender) {
   }
 
-  virtual void OnReceivedSendReportRequest() OVERRIDE {}
-
   virtual void OnReceivedReportBlock(
       const RtcpReportBlock& report_block) OVERRIDE {}
 
@@ -72,7 +70,7 @@ class LocalRtpVideoSenderStatistics : public RtpSenderStatistics {
 };
 
 VideoSender::VideoSender(
-    scoped_refptr<CastThread> cast_thread,
+    scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     VideoEncoderController* const video_encoder_controller,
     PacedPacketSender* const paced_packet_sender)
@@ -80,19 +78,20 @@ VideoSender::VideoSender(
       rtp_max_delay_(
           base::TimeDelta::FromMilliseconds(video_config.rtp_max_delay_ms)),
       max_frame_rate_(video_config.max_frame_rate),
-      cast_thread_(cast_thread),
+      cast_environment_(cast_environment),
       rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)),
-      rtp_sender_(new RtpSender(NULL, &video_config, paced_packet_sender)),
+      rtp_sender_(new RtpSender(cast_environment->Clock(), NULL, &video_config,
+                                paced_packet_sender)),
       last_acked_frame_id_(-1),
       last_sent_frame_id_(-1),
       last_sent_key_frame_id_(-1),
       duplicate_ack_(0),
       last_skip_count_(0),
-      congestion_control_(video_config.congestion_control_back_off,
+      congestion_control_(cast_environment->Clock(),
+                          video_config.congestion_control_back_off,
                           video_config.max_bitrate,
                           video_config.min_bitrate,
                           video_config.start_bitrate),
-      clock_(&default_tick_clock_),
       weak_factory_(this) {
   max_unacked_frames_ = static_cast<uint8>(video_config.rtp_max_delay_ms *
       video_config.max_frame_rate / 1000);
@@ -105,11 +104,12 @@ VideoSender::VideoSender(
     DCHECK(video_encoder_controller) << "Invalid argument";
     video_encoder_controller_ = video_encoder_controller;
   } else {
-    video_encoder_ = new VideoEncoder(cast_thread, video_config,
+    video_encoder_ = new VideoEncoder(cast_environment, video_config,
         max_unacked_frames_);
     video_encoder_controller_ = video_encoder_.get();
   }
   rtcp_.reset(new Rtcp(
+      cast_environment_->Clock(),
       rtcp_feedback_.get(),
       paced_packet_sender,
       rtp_video_sender_statistics_.get(),
@@ -159,7 +159,7 @@ void VideoSender::SendEncodedVideoFrameMainThread(
 
 void VideoSender::SendEncodedVideoFrame(const EncodedVideoFrame* encoded_frame,
                                         const base::TimeTicks& capture_time) {
-  last_send_time_ = clock_->NowTicks();
+  last_send_time_ = cast_environment_->Clock()->NowTicks();
   rtp_sender_->IncomingEncodedVideoFrame(encoded_frame, capture_time);
   if (encoded_frame->key_frame) {
     last_sent_key_frame_id_ = encoded_frame->frame_id;
@@ -182,17 +182,17 @@ void VideoSender::OnReceivedIntraFrameRequest() {
 void VideoSender::IncomingRtcpPacket(const uint8* packet, int length,
                                      const base::Closure callback) {
   rtcp_->IncomingRtcpPacket(packet, length);
-  cast_thread_->PostTask(CastThread::MAIN, FROM_HERE, callback);
+  cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, callback);
 }
 
 void VideoSender::ScheduleNextRtcpReport() {
-  base::TimeDelta time_to_next =
-      rtcp_->TimeToSendNextRtcpReport() - clock_->NowTicks();
+  base::TimeDelta time_to_next = rtcp_->TimeToSendNextRtcpReport() -
+     cast_environment_->Clock()->NowTicks();
 
   time_to_next = std::max(time_to_next,
       base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
-  cast_thread_->PostDelayedTask(CastThread::MAIN, FROM_HERE,
+  cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoSender::SendRtcpReport, weak_factory_.GetWeakPtr()),
                  time_to_next);
 }
@@ -207,29 +207,33 @@ void VideoSender::ScheduleNextResendCheck() {
   if (last_send_time_.is_null()) {
     time_to_next = rtp_max_delay_;
   } else {
-    time_to_next = last_send_time_ - clock_->NowTicks() + rtp_max_delay_;
+    time_to_next = last_send_time_ - cast_environment_->Clock()->NowTicks() +
+        rtp_max_delay_;
   }
   time_to_next = std::max(time_to_next,
       base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
-  cast_thread_->PostDelayedTask(CastThread::MAIN, FROM_HERE,
+  cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoSender::ResendCheck, weak_factory_.GetWeakPtr()),
                  time_to_next);
 }
 
 void VideoSender::ResendCheck() {
   if (!last_send_time_.is_null() && last_sent_frame_id_ != -1) {
-    base::TimeDelta time_to_next =
-        last_send_time_ - clock_->NowTicks() + rtp_max_delay_;
-
-    if (last_acked_frame_id_ == -1) {
-      // We have not received any ack, send a key frame.
-      video_encoder_controller_->GenerateKeyFrame();
-      last_acked_frame_id_ = -1;
-      last_sent_frame_id_ = -1;
-      UpdateFramesInFlight();
-    } else {
-      ResendFrame(static_cast<uint8>(last_acked_frame_id_ + 1));
+    base::TimeDelta time_since_last_send =
+       cast_environment_->Clock()->NowTicks() - last_send_time_;
+    if (time_since_last_send > rtp_max_delay_) {
+      if (last_acked_frame_id_ == -1) {
+        // We have not received any ack, send a key frame.
+         video_encoder_controller_->GenerateKeyFrame();
+        last_acked_frame_id_ = -1;
+        last_sent_frame_id_ = -1;
+        UpdateFramesInFlight();
+      } else {
+        uint8 frame_id = static_cast<uint8>(last_acked_frame_id_ + 1);
+        VLOG(1) << "ACK timeout resend frame:" << static_cast<int>(frame_id);
+        ResendFrame(frame_id);
+      }
     }
   }
   ScheduleNextResendCheck();
@@ -241,13 +245,14 @@ void VideoSender::ScheduleNextSkippedFramesCheck() {
     time_to_next =
         base::TimeDelta::FromMilliseconds(kSkippedFramesCheckPeriodkMs);
   } else {
-    time_to_next = last_checked_skip_count_time_ - clock_->NowTicks() +
+    time_to_next = last_checked_skip_count_time_ -
+         cast_environment_->Clock()->NowTicks() +
          base::TimeDelta::FromMilliseconds(kSkippedFramesCheckPeriodkMs);
   }
   time_to_next = std::max(time_to_next,
       base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
-  cast_thread_->PostDelayedTask(CastThread::MAIN, FROM_HERE,
+  cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoSender::SkippedFramesCheck, weak_factory_.GetWeakPtr()),
                  time_to_next);
 }
@@ -259,7 +264,7 @@ void VideoSender::SkippedFramesCheck() {
       // TODO(pwestin): Propagate this up to the application.
   }
   last_skip_count_ = skip_count;
-  last_checked_skip_count_time_ = clock_->NowTicks();
+  last_checked_skip_count_time_ = cast_environment_->Clock()->NowTicks();
   ScheduleNextSkippedFramesCheck();
 }
 
@@ -303,11 +308,13 @@ void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
       resend_frame = static_cast<uint8>(last_acked_frame_id_ + 1);
     }
     if (resend_frame != -1) {
+      VLOG(1) << "Received duplicate ACK for frame:"
+              << static_cast<int>(resend_frame);
       ResendFrame(static_cast<uint8>(resend_frame));
     }
   } else {
     rtp_sender_->ResendPackets(cast_feedback.missing_frames_and_packets_);
-    last_send_time_ = clock_->NowTicks();
+    last_send_time_ = cast_environment_->Clock()->NowTicks();
 
     uint32 new_bitrate = 0;
     if (congestion_control_.OnNack(rtt, &new_bitrate)) {
@@ -318,6 +325,7 @@ void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
 }
 
 void VideoSender::ReceivedAck(uint8 acked_frame_id) {
+  VLOG(1) << "ReceivedAck:" << static_cast<int>(acked_frame_id);
   last_acked_frame_id_ = acked_frame_id;
   UpdateFramesInFlight();
 }
@@ -339,7 +347,7 @@ void VideoSender::ResendFrame(uint8 resend_frame_id) {
   PacketIdSet missing;
   missing_frames_and_packets.insert(std::make_pair(resend_frame_id, missing));
   rtp_sender_->ResendPackets(missing_frames_and_packets);
-  last_send_time_ = clock_->NowTicks();
+  last_send_time_ = cast_environment_->Clock()->NowTicks();
 }
 
 }  // namespace cast
diff --git a/media/cast/video_sender/video_sender.h b/media/cast/video_sender/video_sender.h
index 9098e975c4..6e86645445 100644
--- a/media/cast/video_sender/video_sender.h
+++ b/media/cast/video_sender/video_sender.h
@@ -10,11 +10,10 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
-#include "base/time/default_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "media/cast/cast_config.h"
-#include "media/cast/cast_thread.h"
+#include "media/cast/cast_environment.h"
 #include "media/cast/congestion_control/congestion_control.h"
 #include "media/cast/rtcp/rtcp.h"
 #include "media/cast/rtp_sender/rtp_sender.h"
@@ -37,7 +36,7 @@ class PacedPacketSender;
 class VideoSender : public base::NonThreadSafe,
                     public base::SupportsWeakPtr<VideoSender> {
  public:
-  VideoSender(scoped_refptr<CastThread> cast_thread,
+  VideoSender(scoped_refptr<CastEnvironment> cast_environment,
               const VideoSenderConfig& video_config,
               VideoEncoderController* const video_encoder_controller,
               PacedPacketSender* const paced_packet_sender);
@@ -65,13 +64,6 @@ class VideoSender : public base::NonThreadSafe,
   void IncomingRtcpPacket(const uint8* packet, int length,
                           const base::Closure callback);
 
-  void set_clock(base::TickClock* clock) {
-    clock_ = clock;
-    congestion_control_.set_clock(clock);
-    rtcp_->set_clock(clock);
-    rtp_sender_->set_clock(clock);
-  }
-
  protected:
   // Protected for testability.
   void OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback);
@@ -113,7 +105,7 @@ class VideoSender : public base::NonThreadSafe,
   const base::TimeDelta rtp_max_delay_;
   const int max_frame_rate_;
 
-  scoped_refptr<CastThread> cast_thread_;
+  scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<LocalRtcpVideoSenderFeedback> rtcp_feedback_;
   scoped_ptr<LocalRtpVideoSenderStatistics> rtp_video_sender_statistics_;
   scoped_refptr<VideoEncoder> video_encoder_;
@@ -130,9 +122,6 @@ class VideoSender : public base::NonThreadSafe,
   int last_skip_count_;
   CongestionControl congestion_control_;
 
-  base::DefaultTickClock default_tick_clock_;
-  base::TickClock* clock_;
-
   base::WeakPtrFactory<VideoSender> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoSender);
diff --git a/media/cast/video_sender/video_sender_unittest.cc b/media/cast/video_sender/video_sender_unittest.cc
index 72582a7ff3..fc29492b5c 100644
--- a/media/cast/video_sender/video_sender_unittest.cc
+++ b/media/cast/video_sender/video_sender_unittest.cc
@@ -7,7 +7,7 @@
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
-#include "media/cast/cast_thread.h"
+#include "media/cast/cast_environment.h"
 #include "media/cast/pacing/mock_paced_packet_sender.h"
 #include "media/cast/pacing/paced_sender.h"
 #include "media/cast/test/fake_task_runner.h"
@@ -19,18 +19,19 @@
 namespace media {
 namespace cast {
 
-static const int64 kStartMillisecond = 123456789;
+static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
+static const uint8 kPixelValue = 123;
 
 using testing::_;
 
 class PeerVideoSender : public VideoSender {
  public:
-  PeerVideoSender(scoped_refptr<CastThread> cast_thread,
+  PeerVideoSender(scoped_refptr<CastEnvironment> cast_environment,
                   const VideoSenderConfig& video_config,
                   VideoEncoderController* const video_encoder_controller,
                   PacedPacketSender* const paced_packet_sender)
-      : VideoSender(cast_thread, video_config, video_encoder_controller,
-                    paced_packet_sender) {
+      : VideoSender(cast_environment, video_config,
+                    video_encoder_controller, paced_packet_sender) {
   }
   using VideoSender::OnReceivedCastFeedback;
 };
@@ -53,7 +54,7 @@ class VideoSenderTest : public ::testing::Test {
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
-  ~VideoSenderTest() {}
+  virtual ~VideoSenderTest() {}
 
   void InitEncoder(bool external) {
     VideoSenderConfig video_config;
@@ -73,19 +74,18 @@ class VideoSenderTest : public ::testing::Test {
     video_config.codec = kVp8;
 
     if (external) {
-      video_sender_.reset(new PeerVideoSender(cast_thread_, video_config,
-          &mock_video_encoder_controller_, &mock_transport_));
+      video_sender_.reset(new PeerVideoSender(cast_environment_,
+          video_config, &mock_video_encoder_controller_, &mock_transport_));
     } else {
-      video_sender_.reset(new PeerVideoSender(cast_thread_, video_config, NULL,
-          &mock_transport_));
+      video_sender_.reset(new PeerVideoSender(cast_environment_, video_config,
+                                              NULL, &mock_transport_));
     }
-    video_sender_->set_clock(&testing_clock_);
   }
 
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
-    cast_thread_ = new CastThread(task_runner_, task_runner_, task_runner_,
-                                  task_runner_, task_runner_);
+    cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
+       task_runner_, task_runner_, task_runner_, task_runner_);
   }
 
   I420VideoFrame* AllocateNewVideoFrame() {
@@ -97,19 +97,19 @@ class VideoSenderTest : public ::testing::Test {
     video_frame->y_plane.length = video_frame->width;
     video_frame->y_plane.data =
         new uint8[video_frame->width * video_frame->height];
-    memset(video_frame->y_plane.data, 123,
+    memset(video_frame->y_plane.data, kPixelValue,
         video_frame->width * video_frame->height);
     video_frame->u_plane.stride = video_frame->width / 2;
     video_frame->u_plane.length = video_frame->width / 2;
     video_frame->u_plane.data =
         new uint8[video_frame->width * video_frame->height / 4];
-    memset(video_frame->u_plane.data, 123,
+    memset(video_frame->u_plane.data, kPixelValue,
         video_frame->width * video_frame->height / 4);
     video_frame->v_plane.stride = video_frame->width / 2;
     video_frame->v_plane.length = video_frame->width / 2;
     video_frame->v_plane.data =
         new uint8[video_frame->width * video_frame->height / 4];
-    memset(video_frame->v_plane.data, 123,
+    memset(video_frame->v_plane.data, kPixelValue,
         video_frame->width * video_frame->height / 4);
     return video_frame;
   }
@@ -119,11 +119,11 @@ class VideoSenderTest : public ::testing::Test {
   MockPacedPacketSender mock_transport_;
   scoped_refptr<test::FakeTaskRunner> task_runner_;
   scoped_ptr<PeerVideoSender> video_sender_;
-  scoped_refptr<CastThread> cast_thread_;
+  scoped_refptr<CastEnvironment> cast_environment_;
 };
 
 TEST_F(VideoSenderTest, BuiltInEncoder) {
-  EXPECT_CALL(mock_transport_, SendPacket(_, _)).Times(1);
+  EXPECT_CALL(mock_transport_, SendPackets(_)).Times(1);
 
   InitEncoder(false);
   I420VideoFrame* video_frame = AllocateNewVideoFrame();
@@ -136,7 +136,7 @@ TEST_F(VideoSenderTest, BuiltInEncoder) {
 }
 
 TEST_F(VideoSenderTest, ExternalEncoder) {
-  EXPECT_CALL(mock_transport_, SendPacket(_, _)).Times(1);
+  EXPECT_CALL(mock_transport_, SendPackets(_)).Times(1);
   EXPECT_CALL(mock_video_encoder_controller_, SkipNextFrame(false)).Times(1);
   InitEncoder(true);
 
@@ -147,7 +147,7 @@ TEST_F(VideoSenderTest, ExternalEncoder) {
   video_frame.key_frame = true;
   video_frame.frame_id = 0;
   video_frame.last_referenced_frame_id = 0;
-  video_frame.data.insert(video_frame.data.begin(), 123, 1000);
+  video_frame.data.insert(video_frame.data.begin(), 1000, kPixelValue);
 
   video_sender_->InsertCodedVideoFrame(&video_frame, capture_time,
     base::Bind(&ReleaseEncodedFrame, &video_frame));
@@ -166,8 +166,8 @@ TEST_F(VideoSenderTest, RtcpTimer) {
 }
 
 TEST_F(VideoSenderTest, ResendTimer) {
-  EXPECT_CALL(mock_transport_, SendPacket(_, _)).Times(2);
-  EXPECT_CALL(mock_transport_, ResendPacket(_, _)).Times(1);
+  EXPECT_CALL(mock_transport_, SendPackets(_)).Times(2);
+  EXPECT_CALL(mock_transport_, ResendPackets(_)).Times(1);
 
   InitEncoder(false);