Remove redundant reading and writing of data about SharedBuffer.

third_party/WebKit/Source/platform/SharedBuffer.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 #ifndef SharedBuffer_h
 #define SharedBuffer_h
 
+#include <atomic>
+
 #include "platform/PlatformExport.h"
+#include "platform/SharedBufferStep.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/RefCounted.h"
+#include "platform/wtf/ThreadingPrimitives.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/WTFString.h"
 #include "third_party/skia/include/core/SkData.h"
 
 namespace blink {
 
 class WebProcessMemoryDump;
 
 class PLATFORM_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
  public:
@@ skipping 20 matching lines @@
   static PassRefPtr<SharedBuffer> Create(const unsigned char* data,
                                          STRICTLY_TYPED_ARG(size)) {
     STRICT_ARG_TYPE(size_t);
     return AdoptRef(new SharedBuffer(data, size));
   }
 
   static PassRefPtr<SharedBuffer> AdoptVector(Vector<char>&);
 
   ~SharedBuffer();
 
+  class ThreadSafeStepper : public ThreadSafeRefCounted<ThreadSafeStepper> {
+   public:
+    PassRefPtr<SharedBufferStep> current_step();
+    ~ThreadSafeStepper();
+
+   private:
+    static PassRefPtr<ThreadSafeStepper> Create(
+        PassRefPtr<SharedBufferStep> step) {
+      return AdoptRef(new ThreadSafeStepper(std::move(step)));
+    }
+
+    ThreadSafeStepper(PassRefPtr<SharedBufferStep>);
+
+    void set_current_step(PassRefPtr<SharedBufferStep>);
+
+    struct Steps {
+      Steps();
+
+      static const size_t kStepArraySize = 5;
+      struct StepHolder {
+        RefPtr<SharedBufferStep> step;
+        bool self_keep;
+        bool keep_ref;
+        std::atomic<size_t> keep_count;
+      };
+      StepHolder step_holder_arr[kStepArraySize];
+
+      Steps* next;
+    };
+
+    void ClearStepHolderSelfKeep(Steps::StepHolder*);
+    void ClearStepHolder(Steps::StepHolder*);
+
+    Steps* steps_head_;
+    Steps* steps_tail_;
+    Steps* steps_to_write_;
+    size_t to_write_index_;
+    Steps::StepHolder* step_holder_to_read_;
+
+    friend class SharedBuffer;
+  };
+
+  PassRefPtr<ThreadSafeStepper> thread_safe_stepper() const;
+
   // DEPRECATED: use a segment iterator or Copy() instead.
   //
   // Calling this function will force internal segmented buffers to be merged
   // into a flat buffer. Use getSomeData() whenever possible for better
   // performance.
   const char* Data() const;
 
   size_t size() const;
 
   bool IsEmpty() const { return !size(); }
@@ skipping 59 matching lines @@
       pos += length;
     }
   }
 
  private:
   SharedBuffer();
   explicit SharedBuffer(size_t);
   SharedBuffer(const char*, size_t);
   SharedBuffer(const unsigned char*, size_t);
 
-  // See SharedBuffer::data().
-  void MergeSegmentsIntoBuffer() const;
-
   void AppendInternal(const char* data, size_t);
   bool GetBytesInternal(void* dest, size_t) const;
   size_t GetSomeDataInternal(const char*& data, size_t position) const;
 
-  size_t size_;
-  mutable Vector<char> buffer_;
-  mutable Vector<char*> segments_;
+  void SynchronizeStepWithThreadStepper() const;
+  bool forward_step_if_needed() const { return thread_safe_stepper_.Get(); }
+
+  mutable RefPtr<SharedBufferStep> current_step_;
+  mutable RefPtr<ThreadSafeStepper> thread_safe_stepper_;
 };
 
 }  // namespace blink
 
 #endif  // SharedBuffer_h