Remove redundant reading and writing of data about SharedBuffer.

third_party/WebKit/Source/platform/SharedBufferStep.h

Index: third_party/WebKit/Source/platform/SharedBufferStep.h
diff --git a/third_party/WebKit/Source/platform/SharedBufferStep.h b/third_party/WebKit/Source/platform/SharedBufferStep.h
new file mode 100644
index 0000000000000000000000000000000000000000..5699e35cafe7e0d284bfd9a4344f09621deb3609
--- /dev/null
+++ b/third_party/WebKit/Source/platform/SharedBufferStep.h
@@ -0,0 +1,164 @@
+// Copyright 2017 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 SharedBufferStep_h
+#define SharedBufferStep_h
+
+#include "platform/PlatformExport.h"
+#include "platform/wtf/PassRefPtr.h"
+#include "platform/wtf/RefPtr.h"
+#include "platform/wtf/ThreadSafeRefCounted.h"
+#include "platform/wtf/Vector.h"
+#include "third_party/skia/include/core/SkData.h"
+
+namespace blink {
+
+class PLATFORM_EXPORT SharedBufferStep
+    : public ThreadSafeRefCounted<SharedBufferStep> {
+ public:
+  size_t size() const { return size_; }
+
+  bool IsEmpty() const { return !size(); }
+
+  size_t GetSomeData(const char*& data, size_t position = 0) const;
+
+  bool GetBytes(void* dest, size_t byte_length) const;
+
+  sk_sp<SkData> GetAsSkData() const;
+
+  PassRefPtr<SharedBufferStep> Copy() const;
+
+ private:
+  class BufferVector : public ThreadSafeRefCounted<BufferVector> {
+   public:
+    static PassRefPtr<BufferVector> Create() {
+      return AdoptRef(new BufferVector());
+    }
+
+    static PassRefPtr<BufferVector> Create(size_t size) {
+      return AdoptRef(new BufferVector(size));
+    }
+
+    static PassRefPtr<BufferVector> AdoptVector(Vector<char>&);
+
+    PassRefPtr<BufferVector> ForwardStep();
+
+    void Append(const char* data, size_t length) {
+      vector_.Append(data, length);
+    }
+
+    void clear() { vector_.clear(); }
+
+    const char* data() const { return vector_.data(); }
+
+    size_t size() const { return vector_.size(); }
+
+    size_t capacity() const { return vector_.capacity(); }
+
+    void ReserveInitialCapacity(size_t capacity) {
+      vector_.ReserveInitialCapacity(capacity);
+    }
+
+   private:
+    BufferVector(){};
+    BufferVector(size_t size) : vector_(size){};
+
+    Vector<char> vector_;
+  };
+
+  class SegmentVector : public ThreadSafeRefCounted<SegmentVector> {
+   public:
+    static PassRefPtr<SegmentVector> Create(size_t segmented_position) {
+      return AdoptRef(new SegmentVector(segmented_position));
+    }
+
+    ~SegmentVector();
+
+    PassRefPtr<SegmentVector> ForwardStep();
+
+    void clear();
+
+    void push_back(char* segment) { vector_.push_back(segment); }
+
+    char* back() const { return vector_.back(); }
+
+    size_t size() const { return vector_.size(); }
+
+    bool IsEmpty() const { return vector_.IsEmpty(); }
+
+    size_t capacity() const { return vector_.capacity(); }
+
+    char* at(size_t index) const { return vector_.at(index); }
+
+    size_t segmented_position() const { return segmented_position_; }
+
+    void set_segmented_position(size_t segmented_position) {
+      segmented_position_ = segmented_position;
+    }
+
+    size_t segmented_size() const { return segmented_size_; }
+
+    void set_segmented_size(size_t segmented_size) {
+      segmented_size_ = segmented_size;
+    }
+
+   private:
+    SegmentVector(size_t segmented_position)
+        : segmented_position_(segmented_position), segmented_size_(0) {}
+
+    Vector<char*> vector_;
+    size_t segmented_position_;
+    size_t segmented_size_;
+    RefPtr<SegmentVector> next_step_segments_;
+  };
+
+  SharedBufferStep();
+  SharedBufferStep(size_t);
+  SharedBufferStep(size_t size,
+                   PassRefPtr<BufferVector> buffer,
+                   PassRefPtr<SegmentVector> segments)
+      : size_(size),
+        buffer_(std::move(buffer)),
+        segments_(std::move(segments)) {}
+
+  static PassRefPtr<SharedBufferStep> Create() {
+    return AdoptRef(new SharedBufferStep);
+  }
+
+  static PassRefPtr<SharedBufferStep> Create(size_t size) {
+    return AdoptRef(new SharedBufferStep(size));
+  }
+
+  static PassRefPtr<SharedBufferStep> Create(
+      size_t size,
+      PassRefPtr<BufferVector> buffer,
+      PassRefPtr<SegmentVector> segments) {
+    return AdoptRef(new SharedBufferStep(std::move(size), std::move(buffer),
+                                         std::move(segments)));
+  }
+
+  static PassRefPtr<SharedBufferStep> AdoptVector(Vector<char>&);
+
+  PassRefPtr<SharedBufferStep> Append(const char* data,
+                                      size_t length,
+                                      bool forward_step_if_needed);
+
+  PassRefPtr<SharedBufferStep> MergeSegmentsIntoBuffer(
+      bool forward_step_if_needed) const;
+
+  PassRefPtr<SharedBufferStep> Clear(bool forward_step_if_needed);
+
+  PassRefPtr<BufferVector> buffer() const { return buffer_; }
+
+  PassRefPtr<SegmentVector> segments() const { return segments_; }
+
+  size_t size_;
+  mutable RefPtr<BufferVector> buffer_;
+  mutable RefPtr<SegmentVector> segments_;
+
+  friend class SharedBuffer;
+};
+}
+
+#endif