C++ bindings

mojo/public/bindings/lib/buffer.h

Index: mojo/public/bindings/lib/buffer.h
diff --git a/mojo/public/bindings/lib/buffer.h b/mojo/public/bindings/lib/buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b7ac7d418e111e2fda377a5dd6f1d2946f8a309
--- /dev/null
+++ b/mojo/public/bindings/lib/buffer.h
@@ -0,0 +1,104 @@
+// 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.
+
+#ifndef MOJO_PUBLIC_BINDINGS_LIB_BUFFER_H_
+#define MOJO_PUBLIC_BINDINGS_LIB_BUFFER_H_
+
+#include <stddef.h>
+
+#include "mojo/public/system/macros.h"
+
+namespace mojo {
+
+class Buffer {
+ public:
+  virtual ~Buffer() {}
+  virtual void* Allocate(size_t num_bytes) = 0;
+};
+
+// The following class is designed to be allocated on the stack.  If necessary,
+// it will failover to allocating objects on the heap.
+class StackBuffer : public Buffer {

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

I was thinking this class might be better named ScratchBuffer. It is not just a
buffer for allocating objects on the stack as it will failover to the heap if
necessary. From the perspective of users, this is the buffer that will almost
always be used. Maybe it should be called ScopedBuffer to make it clear that it
sets up a scope under which objects may be temporarily allocated. Thoughts?

[viettrungluu, 2013/10/09 20:54:26]

I think I like ScratchBuffer more. (To me, ScopedBuffer suggests that you could
"detach" objects in it for use elsewhere, or detach the buffer.)

+ public:
+  StackBuffer();
+  virtual ~StackBuffer();
+
+  virtual void* Allocate(size_t num_bytes) MOJO_OVERRIDE;
+
+ private:
+  static const size_t kMinSegmentSize = 512;

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

Note that C++ requires that you declare storage for static const members. Except
that MSVS doesn't handle this correctly (so for MSVS you shouldn't).

(Not having storage will often lead to link errors if you ever need to pass the
constant as a reference argument, e.g., to various STL functions.)

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

OK

+
+  struct Segment {
+    Segment* next;
+    char* cursor;
+    char* end;
+  };
+
+  void* AllocateInSegment(Segment* segment, size_t num_bytes);
+  void AddOverflowSegment(size_t delta);
+
+  char fixed_data_[kMinSegmentSize];
+  Segment fixed_;
+  Segment* overflow_;
+
+  // Not implemented.
+  StackBuffer(const StackBuffer&);

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

I wonder if we should have a MOJO_DISALLOW_COPY_AND_ASSIGN()....

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

Yes, I wanted to introduce that. Now that we have macros.h, that'll be easy to
do.

+  void operator=(const StackBuffer&);
+};
+
+// ContiguousBuffer provides a simple way to allocate objects within a
+// contiguous chunk of memory. Objects are allocated by calling the |Allocate|
+// method, which extends the buffer accordingly. Objects allocated in this way
+// are not freed explicitly. Instead, they remain valid so long as the
+// ContiguousBuffer remains valid.  The Leak method may be used to steal the
+// underlying memory from the ContiguousBuffer.
+//
+// Typical usage:
+//
+//   {
+//     ContiguousBuffer buf;
+//
+//     int* a = static_cast<int*>(buf.Allocate(sizeof(int)));
+//     *a = 2;
+//
+//     double* b = static_cast<double*>(buf.Grow(sizeof(double)));

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

There's no |Grow()| anymore....

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

Oops, yes. I renamed it.

+//     *b = 3.14f;
+//
+//     void* data = buf.Leak();
+//     Process(data);
+//
+//     free(data);
+//   }
+//
+class ContiguousBuffer : public Buffer {
+ public:
+  ContiguousBuffer();
+  virtual ~ContiguousBuffer();
+
+  // Grows the buffer by |num_bytes| and returns a pointer to the start of the
+  // addition. The resulting address is 8-byte aligned, and the contents of the
+  // memory is zero-filled.
+  virtual void* Allocate(size_t num_bytes) MOJO_OVERRIDE;

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

So it seems problematic that it might invalidate previously-returned pointers
(if it reallocs) ... which means that you can only use a pointer returned by
Allocate() until the next call to Allocate().

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

Oh, good catch. I need to think about that.

+
+  size_t size() const { return size_; }
+
+  // Returns the internal memory owned by the Buffer to the caller. The Buffer
+  // relinquishes its pointer, effectively resetting the state of the Buffer
+  // and leaving the caller responsible for freeing the returned memory address
+  // when no longer needed.
+  void* Leak();
+
+ private:
+  char* ptr_;
+  size_t size_;
+  size_t capacity_;
+
+  // Not implemented.
+  ContiguousBuffer(const ContiguousBuffer&);
+  void operator=(const ContiguousBuffer&);
+};
+
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_BINDINGS_LIB_BUFFER_H_