C++ bindings

mojo/public/bindings/lib/buffer.cc

+// 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 "mojo/public/bindings/lib/buffer.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <algorithm>
+
+namespace mojo {
+
+const size_t kAlignment = 8U;
+
+//-----------------------------------------------------------------------------
+
+StackBuffer::StackBuffer()
+    : overflow_(NULL) {
+  fixed_.next = NULL;
+  fixed_.cursor = fixed_data_;
+  fixed_.end = fixed_data_ + kMinSegmentSize;
+}
+
+StackBuffer::~StackBuffer() {
+  while (overflow_) {
+    Segment* doomed = overflow_;
+    overflow_ = overflow_->next;
+    free(doomed);
+  }
+}
+
+void* StackBuffer::Allocate(size_t delta) {
+  if (delta % kAlignment)
+    delta += (kAlignment - (delta % kAlignment));
+
+  void* result =
+      AllocateInSegment((overflow_ != NULL) ? overflow_ : &fixed_, delta);
+  if (result)
+    return result;
+
+  AddOverflowSegment(delta);
+  return Allocate(delta);
+}
+
+void* StackBuffer::AllocateInSegment(Segment* segment, size_t delta) {
+  void* result;
+  if (static_cast<size_t>(segment->end - segment->cursor) >= delta) {
+    result = segment->cursor;
+    memset(result, 0, delta);
+    segment->cursor += delta;
+  } else {
+    result = NULL;
+  }
+  return result;
+}
+
+void StackBuffer::AddOverflowSegment(size_t delta) {
+  if (delta < kMinSegmentSize)
+    delta = kMinSegmentSize;
+  Segment* segment = static_cast<Segment*>(malloc(sizeof(Segment) + delta));
+  segment->next = overflow_;
+  segment->cursor = reinterpret_cast<char*>(segment + 1);
+  segment->end = segment->cursor + delta;
+  overflow_ = segment;
+}
+
+//-----------------------------------------------------------------------------
+
+ContiguousBuffer::ContiguousBuffer()
+    : ptr_(NULL),
+      size_(0),
+      capacity_(0) {
+}
+
+ContiguousBuffer::~ContiguousBuffer() {
+  free(ptr_);
+}
+
+void* ContiguousBuffer::Allocate(size_t delta) {
+  size_t old_size = size_;
+  size_t new_size = old_size + delta;
+
+  if (new_size % kAlignment)
+    new_size += (kAlignment - (new_size % kAlignment));
+
+  const size_t kInitialCapacity = 512U;
+  size_t new_capacity = std::max(capacity_, kInitialCapacity);
+  while (new_capacity < new_size)
+    new_capacity <<= 1;
+
+  if (new_capacity != capacity_) {
+    ptr_ = static_cast<char*>(realloc(ptr_, new_capacity));
+    // TODO: only memset what gets used
+    memset(ptr_ + capacity_, 0, new_capacity - capacity_);
+    capacity_ = new_capacity;
+  }
+
+  size_ = new_size;
+  return ptr_ + old_size;
+}
+
+void* ContiguousBuffer::Leak() {
+  char* ptr = ptr_;
+  ptr_ = NULL;
+  size_ = 0;

[viettrungluu, 2013/10/09 17:00:24]

Also, |capacity_ = 0;|?

[darin (slow to review), 2013/10/09 17:05:32]

Yes, good catch.

+  return ptr;
+}
+
+}  // namespace mojo