Remove flip_server.

net/tools/flip_server/ring_buffer.cc

Index: net/tools/flip_server/ring_buffer.cc
diff --git a/net/tools/flip_server/ring_buffer.cc b/net/tools/flip_server/ring_buffer.cc
deleted file mode 100644
index 16c278bcdefa8773188242a5e8f47cc76fb9a0e0..0000000000000000000000000000000000000000
--- a/net/tools/flip_server/ring_buffer.cc
+++ /dev/null
@@ -1,241 +0,0 @@
-// Copyright (c) 2009 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 "net/tools/flip_server/ring_buffer.h"
-#include "base/logging.h"
-
-namespace net {
-
-RingBuffer::RingBuffer(int buffer_size)
-    : buffer_(new char[buffer_size]),
-      buffer_size_(buffer_size),
-      bytes_used_(0),
-      read_idx_(0),
-      write_idx_(0) {}
-
-RingBuffer::~RingBuffer() {}
-
-int RingBuffer::ReadableBytes() const { return bytes_used_; }
-
-int RingBuffer::BufferSize() const { return buffer_size_; }
-
-int RingBuffer::BytesFree() const { return BufferSize() - ReadableBytes(); }
-
-bool RingBuffer::Empty() const { return ReadableBytes() == 0; }
-
-bool RingBuffer::Full() const { return ReadableBytes() == BufferSize(); }
-
-// Returns the number of characters written.
-// Appends up-to-'size' bytes to the ringbuffer.
-int RingBuffer::Write(const char* bytes, int size) {
-  CHECK_GE(size, 0);
-#if 1
-  char* wptr;
-  int wsize;
-  GetWritablePtr(&wptr, &wsize);
-  int bytes_remaining = size;
-  int bytes_written = 0;
-
-  while (wsize && bytes_remaining) {
-    if (wsize > bytes_remaining) {
-      wsize = bytes_remaining;
-    }
-    memcpy(wptr, bytes + bytes_written, wsize);
-    bytes_written += wsize;
-    bytes_remaining -= wsize;
-    AdvanceWritablePtr(wsize);
-    GetWritablePtr(&wptr, &wsize);
-  }
-  return bytes_written;
-#else
-  const char* p = bytes;
-
-  int bytes_to_write = size;
-  int bytes_available = BytesFree();
-  if (bytes_available < bytes_to_write) {
-    bytes_to_write = bytes_available;
-  }
-  const char* end = bytes + bytes_to_write;
-
-  while (p != end) {
-    this->buffer_[this->write_idx_] = *p;
-    ++p;
-    ++this->write_idx_;
-    if (this->write_idx_ >= this->buffer_size_) {
-      this->write_idx_ = 0;
-    }
-  }
-  bytes_used_ += bytes_to_write;
-  return bytes_to_write;
-#endif
-}
-
-// Sets *ptr to the beginning of writable memory, and sets *size to the size
-// available for writing using this pointer.
-void RingBuffer::GetWritablePtr(char** ptr, int* size) const {
-  *ptr = buffer_.get() + write_idx_;
-
-  if (bytes_used_ == buffer_size_) {
-    *size = 0;
-  } else if (read_idx_ > write_idx_) {
-    *size = read_idx_ - write_idx_;
-  } else {
-    *size = buffer_size_ - write_idx_;
-  }
-}
-
-// Sets *ptr to the beginning of readable memory, and sets *size to the size
-// available for reading using this pointer.
-void RingBuffer::GetReadablePtr(char** ptr, int* size) const {
-  *ptr = buffer_.get() + read_idx_;
-
-  if (bytes_used_ == 0) {
-    *size = 0;
-  } else if (write_idx_ > read_idx_) {
-    *size = write_idx_ - read_idx_;
-  } else {
-    *size = buffer_size_ - read_idx_;
-  }
-}
-
-// returns the number of bytes read into
-int RingBuffer::Read(char* bytes, int size) {
-  CHECK_GE(size, 0);
-#if 1
-  char* rptr;
-  int rsize;
-  GetReadablePtr(&rptr, &rsize);
-  int bytes_remaining = size;
-  int bytes_read = 0;
-
-  while (rsize && bytes_remaining) {
-    if (rsize > bytes_remaining) {
-      rsize = bytes_remaining;
-    }
-    memcpy(bytes + bytes_read, rptr, rsize);
-    bytes_read += rsize;
-    bytes_remaining -= rsize;
-    AdvanceReadablePtr(rsize);
-    GetReadablePtr(&rptr, &rsize);
-  }
-  return bytes_read;
-#else
-  char* p = bytes;
-  int bytes_to_read = size;
-  int bytes_used = ReadableBytes();
-  if (bytes_used < bytes_to_read) {
-    bytes_to_read = bytes_used;
-  }
-  char* end = bytes + bytes_to_read;
-
-  while (p != end) {
-    *p = this->buffer_[this->read_idx_];
-    ++p;
-    ++this->read_idx_;
-    if (this->read_idx_ >= this->buffer_size_) {
-      this->read_idx_ = 0;
-    }
-  }
-  this->bytes_used_ -= bytes_to_read;
-  return bytes_to_read;
-#endif
-}
-
-void RingBuffer::Clear() {
-  bytes_used_ = 0;
-  write_idx_ = 0;
-  read_idx_ = 0;
-}
-
-bool RingBuffer::Reserve(int size) {
-  DCHECK_GT(size, 0);
-  char* write_ptr = NULL;
-  int write_size = 0;
-  GetWritablePtr(&write_ptr, &write_size);
-
-  if (write_size < size) {
-    char* read_ptr = NULL;
-    int read_size = 0;
-    GetReadablePtr(&read_ptr, &read_size);
-    if (size <= BytesFree()) {
-      // The fact that the total Free size is big enough but writable size is
-      // not means that the writeable region is broken into two pieces: only
-      // possible if the read_idx < write_idx. If write_idx < read_idx, then
-      // the writeable region must be contiguous: [write_idx, read_idx). There
-      // is no work to be done for the latter.
-      DCHECK_LE(read_idx_, write_idx_);
-      DCHECK_EQ(read_size, ReadableBytes());
-      if (read_idx_ < write_idx_) {
-        // Writeable area fragmented, consolidate it.
-        memmove(buffer_.get(), read_ptr, read_size);
-        read_idx_ = 0;
-        write_idx_ = read_size;
-      } else if (read_idx_ == write_idx_) {
-        // No unconsumed data in the buffer, simply reset the indexes.
-        DCHECK_EQ(ReadableBytes(), 0);
-        read_idx_ = 0;
-        write_idx_ = 0;
-      }
-    } else {
-      Resize(ReadableBytes() + size);
-    }
-  }
-  DCHECK_LE(size, buffer_size_ - write_idx_);
-  return true;
-}
-
-void RingBuffer::AdvanceReadablePtr(int amount_to_consume) {
-  CHECK_GE(amount_to_consume, 0);
-  if (amount_to_consume >= bytes_used_) {
-    Clear();
-    return;
-  }
-  read_idx_ += amount_to_consume;
-  read_idx_ %= buffer_size_;
-  bytes_used_ -= amount_to_consume;
-}
-
-void RingBuffer::AdvanceWritablePtr(int amount_to_produce) {
-  CHECK_GE(amount_to_produce, 0);
-  CHECK_LE(amount_to_produce, BytesFree());
-  write_idx_ += amount_to_produce;
-  write_idx_ %= buffer_size_;
-  bytes_used_ += amount_to_produce;
-}
-
-void RingBuffer::Resize(int buffer_size) {
-  CHECK_GE(buffer_size, 0);
-  if (buffer_size == buffer_size_)
-    return;
-
-  char* new_buffer = new char[buffer_size];
-  if (buffer_size < bytes_used_) {
-    // consume the oldest data.
-    AdvanceReadablePtr(bytes_used_ - buffer_size);
-  }
-
-  int bytes_written = 0;
-  int bytes_used = bytes_used_;
-  while (true) {
-    int size;
-    char* ptr;
-    GetReadablePtr(&ptr, &size);
-    if (size == 0)
-      break;
-    if (size > buffer_size) {
-      size = buffer_size;
-    }
-    memcpy(new_buffer + bytes_written, ptr, size);
-    bytes_written += size;
-    AdvanceReadablePtr(size);
-  }
-  buffer_.reset(new_buffer);
-
-  buffer_size_ = buffer_size;
-  bytes_used_ = bytes_used;
-  read_idx_ = 0;
-  write_idx_ = bytes_used_ % buffer_size_;
-}
-
-}  // namespace net