Cast: Reshuffle files under media/cast

media/cast/test/utility/udp_proxy.cc

 // Copyright 2014 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 <math.h>
 #include <stdlib.h>
 #include <vector>
 
 #include "media/cast/test/utility/udp_proxy.h"
 
@@ skipping 38 matching lines @@
  public:
   Buffer(size_t buffer_size, double max_megabits_per_second)
       : buffer_size_(0),
         max_buffer_size_(buffer_size),
         max_megabits_per_second_(max_megabits_per_second),
         weak_factory_(this) {
     CHECK_GT(max_buffer_size_, 0UL);
     CHECK_GT(max_megabits_per_second, 0);
   }
 
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE {
     if (packet->size() + buffer_size_ <= max_buffer_size_) {
       buffer_size_ += packet->size();
-      buffer_.push_back(linked_ptr<transport::Packet>(packet.release()));
+      buffer_.push_back(linked_ptr<Packet>(packet.release()));
       if (buffer_.size() == 1) {
         Schedule();
       }
     }
   }
 
  private:
   void Schedule() {
     double megabits = buffer_.front()->size() * 8 / 1000000.0;
     double seconds = megabits / max_megabits_per_second_;
     int64 microseconds = static_cast<int64>(seconds * 1E6);
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&Buffer::ProcessBuffer, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(microseconds));
   }
 
   void ProcessBuffer() {
     CHECK(!buffer_.empty());
-    scoped_ptr<transport::Packet> packet(buffer_.front().release());
+    scoped_ptr<Packet> packet(buffer_.front().release());
     buffer_size_ -= packet->size();
     buffer_.pop_front();
     pipe_->Send(packet.Pass());
     if (!buffer_.empty()) {
       Schedule();
     }
   }
 
-  std::deque<linked_ptr<transport::Packet> > buffer_;
+  std::deque<linked_ptr<Packet> > buffer_;
   size_t buffer_size_;
   size_t max_buffer_size_;
   double max_megabits_per_second_;  // megabits per second
   base::WeakPtrFactory<Buffer> weak_factory_;
 };
 
 scoped_ptr<PacketPipe> NewBuffer(size_t buffer_size, double bandwidth) {
   return scoped_ptr<PacketPipe>(new Buffer(buffer_size, bandwidth)).Pass();
 }
 
 class RandomDrop : public PacketPipe {
  public:
   RandomDrop(double drop_fraction)
       : drop_fraction_(static_cast<int>(drop_fraction * RAND_MAX)) {}
 
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE {
     if (rand() > drop_fraction_) {
       pipe_->Send(packet.Pass());
     }
   }
 
  private:
   int drop_fraction_;
 };
 
 scoped_ptr<PacketPipe> NewRandomDrop(double drop_fraction) {
   return scoped_ptr<PacketPipe>(new RandomDrop(drop_fraction)).Pass();
 }
 
 class SimpleDelayBase : public PacketPipe {
  public:
   SimpleDelayBase() : weak_factory_(this) {}
   virtual ~SimpleDelayBase() {}
 
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE {
     double seconds = GetDelay();
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&SimpleDelayBase::SendInternal,
                    weak_factory_.GetWeakPtr(),
                    base::Passed(&packet)),
         base::TimeDelta::FromMicroseconds(static_cast<int64>(seconds * 1E6)));
   }
  protected:
   virtual double GetDelay() = 0;
 
  private:
-  virtual void SendInternal(scoped_ptr<transport::Packet> packet) {
+  virtual void SendInternal(scoped_ptr<Packet> packet) {
     pipe_->Send(packet.Pass());
   }
 
   base::WeakPtrFactory<SimpleDelayBase> weak_factory_;
 };
 
 class ConstantDelay : public SimpleDelayBase {
  public:
   ConstantDelay(double delay_seconds) : delay_seconds_(delay_seconds) {}
   virtual double GetDelay() OVERRIDE {
@@ skipping 28 matching lines @@
 class RandomSortedDelay : public PacketPipe {
  public:
   RandomSortedDelay(double random_delay,
                     double extra_delay,
                     double seconds_between_extra_delay)
       : random_delay_(random_delay),
         extra_delay_(extra_delay),
         seconds_between_extra_delay_(seconds_between_extra_delay),
         weak_factory_(this) {}
 
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
-    buffer_.push_back(linked_ptr<transport::Packet>(packet.release()));
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE {
+    buffer_.push_back(linked_ptr<Packet>(packet.release()));
     if (buffer_.size() == 1) {
       Schedule();
     }
   }
   virtual void InitOnIOThread(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) OVERRIDE {
     PacketPipe::InitOnIOThread(task_runner, clock);
     // As we start the stream, assume that we are in a random
     // place between two extra delays, thus multiplier = 1.0;
@@ skipping 32 matching lines @@
     }
 
     task_runner_->PostDelayedTask(FROM_HERE,
                                   base::Bind(&RandomSortedDelay::ProcessBuffer,
                                              weak_factory_.GetWeakPtr()),
                                   delay_time);
   }
 
   void ProcessBuffer() {
     CHECK(!buffer_.empty());
-    scoped_ptr<transport::Packet> packet(buffer_.front().release());
+    scoped_ptr<Packet> packet(buffer_.front().release());
     pipe_->Send(packet.Pass());
     buffer_.pop_front();
     if (!buffer_.empty()) {
       Schedule();
     }
   }
 
   base::TimeTicks block_until_;
-  std::deque<linked_ptr<transport::Packet> > buffer_;
+  std::deque<linked_ptr<Packet> > buffer_;
   double random_delay_;
   double extra_delay_;
   double seconds_between_extra_delay_;
   base::WeakPtrFactory<RandomSortedDelay> weak_factory_;
 };
 
 scoped_ptr<PacketPipe> NewRandomSortedDelay(
     double random_delay,
     double extra_delay,
     double seconds_between_extra_delay) {
@@ skipping 11 matching lines @@
         max_outage_time_(average_outage_time * 2),
         weak_factory_(this) {}
 
   virtual void InitOnIOThread(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) OVERRIDE {
     PacketPipe::InitOnIOThread(task_runner, clock);
     Flip();
   }
 
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE {
     if (works_) {
       pipe_->Send(packet.Pass());
     }
   }
 
  private:
   void Flip() {
     works_ = !works_;
     double seconds = base::RandDouble() *
         (works_ ? max_work_time_ : max_outage_time_);
@@ skipping 23 matching lines @@
  public:
   InternalBuffer(base::WeakPtr<InterruptedPoissonProcess> ipp,
                  size_t size)
       : ipp_(ipp),
         stored_size_(0),
         stored_limit_(size),
         clock_(NULL),
         weak_factory_(this) {
   }
 
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE {
     // Drop if buffer is full.
     if (stored_size_ >= stored_limit_)
       return;
     stored_size_ += packet->size();
-    buffer_.push_back(linked_ptr<transport::Packet>(packet.release()));
+    buffer_.push_back(linked_ptr<Packet>(packet.release()));
     buffer_time_.push_back(clock_->NowTicks());
     DCHECK(buffer_.size() == buffer_time_.size());
   }
 
   virtual void InitOnIOThread(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) OVERRIDE {
     clock_ = clock;
     if (ipp_)
       ipp_->InitOnIOThread(task_runner, clock);
     PacketPipe::InitOnIOThread(task_runner, clock);
   }
 
   void SendOnePacket() {
-    scoped_ptr<transport::Packet> packet(buffer_.front().release());
+    scoped_ptr<Packet> packet(buffer_.front().release());
     stored_size_ -= packet->size();
     buffer_.pop_front();
     buffer_time_.pop_front();
     pipe_->Send(packet.Pass());
     DCHECK(buffer_.size() == buffer_time_.size());
   }
 
   bool Empty() const {
     return buffer_.empty();
   }
 
   base::TimeTicks FirstPacketTime() const {
     DCHECK(!buffer_time_.empty());
     return buffer_time_.front();
   }
 
   base::WeakPtr<InternalBuffer> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
 
   }
 
  private:
   const base::WeakPtr<InterruptedPoissonProcess> ipp_;
   size_t stored_size_;
   const size_t stored_limit_;
-  std::deque<linked_ptr<transport::Packet> > buffer_;
+  std::deque<linked_ptr<Packet> > buffer_;
   std::deque<base::TimeTicks> buffer_time_;
   base::TickClock* clock_;
   base::WeakPtrFactory<InternalBuffer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InternalBuffer);
 };
 
 InterruptedPoissonProcess::InterruptedPoissonProcess(
     const std::vector<double>& average_rates,
     double coef_burstiness,
@@ skipping 125 matching lines @@
     break;
   }
 }
 
 class UDPProxyImpl;
 
 class PacketSender : public PacketPipe {
  public:
   PacketSender(UDPProxyImpl* udp_proxy, const net::IPEndPoint* destination)
       : udp_proxy_(udp_proxy), destination_(destination) {}
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE;
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE;
   virtual void AppendToPipe(scoped_ptr<PacketPipe> pipe) OVERRIDE {
     NOTREACHED();
   }
 
  private:
   UDPProxyImpl* udp_proxy_;
   const net::IPEndPoint* destination_;  // not owned
 };
 
 namespace {
@@ skipping 89 matching lines @@
     base::WaitableEvent stop_event(false, false);
     proxy_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&UDPProxyImpl::Stop,
                    base::Unretained(this),
                    base::Unretained(&stop_event)));
     stop_event.Wait();
     proxy_thread_.Stop();
   }
 
-  void Send(scoped_ptr<transport::Packet> packet,
+  void Send(scoped_ptr<Packet> packet,
             const net::IPEndPoint& destination) {
     if (blocked_) {
       LOG(ERROR) << "Cannot write packet right now: blocked";
       return;
     }
 
     VLOG(1) << "Sending packet, len = " << packet->size();
     // We ignore all problems, callbacks and errors.
     // If it didn't work we just drop the packet at and call it a day.
     scoped_refptr<net::IOBuffer> buf =
@@ skipping 75 matching lines @@
     }
   }
 
   void ReadCallback(scoped_refptr<net::IOBuffer> recv_buf, int len) {
     ProcessPacket(recv_buf, len);
     PollRead();
   }
 
   void PollRead() {
     while (true) {
-      packet_.reset(new transport::Packet(kMaxPacketSize));
+      packet_.reset(new Packet(kMaxPacketSize));
       scoped_refptr<net::IOBuffer> recv_buf =
           new net::WrappedIOBuffer(reinterpret_cast<char*>(&packet_->front()));
       int len = socket_->RecvFrom(
           recv_buf,
           kMaxPacketSize,
           &recv_address_,
           base::Bind(&UDPProxyImpl::ReadCallback,
                      base::Unretained(this),
                      recv_buf));
       if (len == net::ERR_IO_PENDING)
         break;
       ProcessPacket(recv_buf, len);
     }
   }
 
   void AllowWrite(scoped_refptr<net::IOBuffer> buf,
-                  scoped_ptr<transport::Packet> packet,
+                  scoped_ptr<Packet> packet,
                   int unused_len) {
     DCHECK(blocked_);
     blocked_ = false;
   }
 
   // Input
   net::IPEndPoint local_port_;
 
   net::IPEndPoint destination_;
   bool destination_is_mutable_;
 
   net::IPEndPoint return_address_;
   bool set_destination_next_;
 
   base::DefaultTickClock tick_clock_;
   base::Thread proxy_thread_;
   scoped_ptr<net::UDPSocket> socket_;
   scoped_ptr<PacketPipe> to_dest_pipe_;
   scoped_ptr<PacketPipe> from_dest_pipe_;
 
   // For receiving.
   net::IPEndPoint recv_address_;
-  scoped_ptr<transport::Packet> packet_;
+  scoped_ptr<Packet> packet_;
 
   // For sending.
   bool blocked_;
 
   base::WeakPtrFactory<UDPProxyImpl> weak_factory_;
 };
 
-void PacketSender::Send(scoped_ptr<transport::Packet> packet) {
+void PacketSender::Send(scoped_ptr<Packet> packet) {
   udp_proxy_->Send(packet.Pass(), *destination_);
 }
 
 scoped_ptr<UDPProxy> UDPProxy::Create(
     const net::IPEndPoint& local_port,
     const net::IPEndPoint& destination,
     scoped_ptr<PacketPipe> to_dest_pipe,
     scoped_ptr<PacketPipe> from_dest_pipe,
     net::NetLog* net_log) {
   scoped_ptr<UDPProxy> ret(new UDPProxyImpl(local_port,
                                             destination,
                                             to_dest_pipe.Pass(),
                                             from_dest_pipe.Pass(),
                                             net_log));
   return ret.Pass();
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media