Adding partially circular memory buffer wrapper.

content/common/partial_circular_buffer.cc

+// Copyright (c) 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 "content/common/partial_circular_buffer.h"
+
+#include <algorithm>
+
+#include "base/logging.h"
+
+#define MIN3(a, b, c) std::min(a, std::min(b, c))
+
+namespace content {
+
+PartialCircularBuffer::PartialCircularBuffer(void* buffer,
+                                             size_t buffer_size)
+    : buffer_data_(reinterpret_cast<BufferData*>(buffer)),
+      memory_buffer_size_(buffer_size),
+      data_size_(0),
+      position_(0),
+      total_read_(0) {
+  size_t header_size =
+      buffer_data_->data - reinterpret_cast<uint8*>(buffer_data_);
+  data_size_ = memory_buffer_size_ - header_size;
+
+  DCHECK(buffer_data_);
+  DCHECK_GE(memory_buffer_size_, header_size);
+  DCHECK_LE(buffer_data_->total_written, data_size_);
+  DCHECK_LT(buffer_data_->wrap_position, data_size_);
+  DCHECK_LT(buffer_data_->end_position, data_size_);
+}
+
+PartialCircularBuffer::PartialCircularBuffer(void* buffer,
+                                             size_t buffer_size,
+                                             size_t wrap_position)
+    : buffer_data_(reinterpret_cast<BufferData*>(buffer)),
+      memory_buffer_size_(buffer_size),
+      data_size_(0),
+      position_(0),
+      total_read_(0) {
+  size_t header_size =
+      buffer_data_->data - reinterpret_cast<uint8*>(buffer_data_);
+  data_size_ = memory_buffer_size_ - header_size;
+
+  DCHECK(buffer_data_);
+  DCHECK_GE(memory_buffer_size_, header_size);
+  DCHECK_LT(wrap_position, data_size_);
+
+  buffer_data_->total_written = 0;
+  buffer_data_->wrap_position = wrap_position;
+  buffer_data_->end_position = 0;
+}
+
+size_t PartialCircularBuffer::Read(void* buffer, size_t buffer_size) {
+  DCHECK(buffer_data_);
+  if (total_read_ >= buffer_data_->total_written)
+    return 0;
+
+  uint8* buffer_uint8 = static_cast<uint8*>(buffer);

[tommi (sloooow) - chröme, 2013/04/05 14:43:07]

use reinterpret_cast in these cases.  void* and uint8* aren't related.

[Henrik Grunell, 2013/04/10 13:25:13]

Done.

+  size_t read = 0;
+
+  // Read from beginning part.
+  if (position_ < buffer_data_->wrap_position) {
+    size_t to_wrap_pos = buffer_data_->wrap_position - position_;
+    size_t to_eow = buffer_data_->total_written - total_read_;
+    size_t to_read = MIN3(buffer_size, to_wrap_pos, to_eow);
+    memcpy(buffer_uint8, buffer_data_->data + position_, to_read);
+    position_ += to_read;
+    total_read_ += to_read;
+    read += to_read;
+    if (position_ == buffer_data_->wrap_position &&
+        buffer_data_->total_written == data_size_) {
+      // We've read all the beginning part, set the position to the middle part.
+      // (The second condition above checks if the wrapping part is filled, i.e.
+      // writing has wrapped.)
+      position_ = buffer_data_->end_position;
+    }
+    if (read >= buffer_size) {
+      DCHECK(read == buffer_size);
+      return read;
+    }
+    if (read >= to_eow) {
+      DCHECK(read == to_eow);
+      DCHECK(total_read_ == buffer_data_->total_written);
+      return read;
+    }
+  }
+
+  // Read from middle part.
+  DCHECK(position_ >= buffer_data_->wrap_position);
+  if (position_ >= buffer_data_->end_position) {
+    size_t remaining_buffer_size = buffer_size - read;
+    size_t to_eof = data_size_ - position_;
+    size_t to_eow = buffer_data_->total_written - total_read_;
+    size_t to_read = MIN3(remaining_buffer_size, to_eof, to_eow);
+    memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
+    position_ += to_read;
+    total_read_ += to_read;
+    read += to_read;
+    if (position_ == data_size_) {
+      // We've read all the middle part, set position to the end part.
+      position_ = buffer_data_->wrap_position;
+    }
+    if (read >= buffer_size) {
+      DCHECK(read == buffer_size);
+      return read;
+    }
+    if (read >= to_eow) {
+      DCHECK(read == to_eow);
+      DCHECK(total_read_ == buffer_data_->total_written);
+      return read;
+    }
+  }
+
+  // Read from end part.
+  DCHECK(position_ >= buffer_data_->wrap_position &&
+         position_ < buffer_data_->end_position);
+  size_t remaining_buffer_size = buffer_size - read;
+  size_t to_eob = buffer_data_->end_position - position_;
+  size_t to_eow = buffer_data_->total_written - total_read_;
+  size_t to_read = MIN3(remaining_buffer_size, to_eob, to_eow);
+  memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
+  position_ += to_read;
+  total_read_ += to_read;
+  read += to_read;
+  DCHECK(read <= buffer_size);
+  DCHECK(read <= to_eow);
+  DCHECK(total_read_ <= buffer_data_->total_written);
+  return read;
+}
+
+void PartialCircularBuffer::Write(const void* buffer, size_t buffer_size) {
+  DCHECK(buffer_data_);
+  size_t position_before_write = position_;
+
+  size_t to_eof = data_size_ - position_;
+  size_t to_write = std::min(buffer_size, to_eof);
+  DoWrite(buffer_data_->data + position_, buffer, to_write);
+  if (position_ >= data_size_) {
+    DCHECK_EQ(position_, data_size_);
+    position_ = buffer_data_->wrap_position;
+  }
+
+  if (to_write < buffer_size) {
+    size_t remainder_to_write = buffer_size - to_write;
+    DCHECK_LT(position_, position_before_write);
+    DCHECK_LE(position_ + remainder_to_write, position_before_write);
+    DoWrite(buffer_data_->data + position_,
+            reinterpret_cast<const uint8*>(buffer) + to_write,
+            remainder_to_write);
+  }
+}
+
+void PartialCircularBuffer::DoWrite(void* dest, const void* src, size_t num) {
+  memcpy(dest, src, num);
+  position_ += num;
+  buffer_data_->total_written =
+      std::min(buffer_data_->total_written + num, data_size_);
+  buffer_data_->end_position = position_;
+}
+
+}  // namespace content