Tracing V2 prototype [NOT FOR REVIEW]

base/trace_event/v2/scattered_buffer.cc

Index: base/trace_event/v2/scattered_buffer.cc
diff --git a/base/trace_event/v2/scattered_buffer.cc b/base/trace_event/v2/scattered_buffer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0514c1dbcc23505e14e53681cb89eefc1e78cc5f
--- /dev/null
+++ b/base/trace_event/v2/scattered_buffer.cc
@@ -0,0 +1,73 @@
+// Copyright 2016 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 "base/trace_event/v2/scattered_buffer.h"
+
+#include <string.h>
+
+#include "base/logging.h"
+
+namespace base {
+namespace trace_event {
+namespace v2 {
+
+ScatteredBuffer::ScatteredBuffer(Delegate* delegate)
+    : delegate_(delegate), cur_range_({nullptr, nullptr}), wrptr_(nullptr) {}
+
+ScatteredBuffer::~ScatteredBuffer() {}
+
+void ScatteredBuffer::Reset(ScatteredBuffer::ContiguousMemoryRange range) {
+  cur_range_ = range;
+  wrptr_ = range.begin;
+  DCHECK_LT(wrptr_, cur_range_.end);
+  // TODO check or dcheck? Does this have security implications?
+}
+
+void ScatteredBuffer::Expand() {
+  Reset(delegate_->GetNewContiguousMemoryBuffer());
+}
+
+void ScatteredBuffer::WriteByte(uint8_t value) {
+  if (wrptr_ == cur_range_.end)
+    Expand();
+  *wrptr_ = value;
+  ++wrptr_;
+}
+
+void ScatteredBuffer::WriteBytes(const uint8_t* src, size_t size) {
+  uint8_t* const end = const_cast<uint8_t*>(wrptr_) + size;
+  if (end <= cur_range_.end) {
+    for(size_t i = 0; i < size; ++i)
+      wrptr_[i] = src[i];
+    wrptr_ = end;
+    return;
+  }
+
+  // Super silly slow path, can be optimized but I couldn't be bothered right now.
+  for (const uint8_t* c = src; c < src + size; ++c)
+    WriteByte(*c);
+}
+
+ScatteredBuffer::ContiguousMemoryRange ScatteredBuffer::ReserveBytes(size_t size) {
+  if (wrptr_ + size > cur_range_.end)
+    Expand();
+  uint8_t* begin = wrptr_;
+  wrptr_ += size;
+  return {begin, begin + size};
+}
+
+void ScatteredBuffer::WriteReservedBytes(
+    const ScatteredBuffer::ContiguousMemoryRange& reserved_range,
+    const uint8_t* src,
+    size_t size) {
+  DCHECK_EQ(size, static_cast<size_t>(reserved_range.end - reserved_range.begin));
+  DCHECK(size == 4); // todo omptimize this, we always call it with size 4.
+  *((uint32_t*)reserved_range.begin) = *((uint32_t*)src);
+  // for(size_t i = 0; i < size; ++i)
+  //   reserved_range.begin[i] = src[i];
+}
+
+}  // namespace v2
+}  // namespace trace_event
+}  // namespace base