third_party/blink/renderer/platform/shared_buffer.h - chromium/src.git - Git at Google

 /*
  * 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 THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_H_
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_H_

 #include <algorithm>
 #include <utility>
 #include <vector>

 #include "base/containers/span.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/wtf/forward.h"
 #include "third_party/blink/renderer/platform/wtf/ref_counted.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"

 class SkData;
 template <typename T>
 class sk_sp;

 namespace blink {

 class WebProcessMemoryDump;

 class PLATFORM_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
  public:
   // Iterator for ShreadBuffer contents. An Iterator will get invalid once the
   // associated SharedBuffer is modified (e.g., Append() is called). An Iterator
   // doesn't retain the associated container.
   class PLATFORM_EXPORT Iterator final {
    public:
     ~Iterator() = default;

     Iterator& operator++();
     Iterator operator++(int) {
       auto temp = *this;
       ++*this;
       return temp;
     }
     bool operator==(const Iterator& that) const {
       return std::equal(value_.begin(), value_.end(), that.value_.begin(),
                         that.value_.end()) &&
              buffer_ == that.buffer_;
     }
     bool operator!=(const Iterator& that) const { return !(*this == that); }
     const base::span<const char>& operator*() const {
       DCHECK(!IsEnd());
       return value_;
     }
     const base::span<const char>* operator->() const {
       DCHECK(!IsEnd());
       return &value_;
     }

    private:
     friend class SharedBuffer;
     // for end()
     Iterator(const SharedBuffer* buffer);
     // for the consecutive part
     Iterator(size_t offset, const SharedBuffer* buffer);
     // for the rest
     Iterator(wtf_size_t segment_index,
              size_t offset,
              const SharedBuffer* buffer);

     void Init(size_t offset);
     bool IsEnd() const { return index_ == buffer_->segments_.size() + 1; }

     // It represents |buffer_->buffer| if |index_| is 0, and
     // |buffer_->segments[index_ - 1]| otherwise.
     wtf_size_t index_;
     base::span<const char> value_;
     const SharedBuffer* buffer_;
   };

   static constexpr unsigned kSegmentSize = 0x1000;

   static scoped_refptr<SharedBuffer> Create() {
     return base::AdoptRef(new SharedBuffer);
   }

   HAS_STRICTLY_TYPED_ARG
   static scoped_refptr<SharedBuffer> Create(STRICTLY_TYPED_ARG(size)) {
     ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
     return base::AdoptRef(new SharedBuffer(SafeCast<wtf_size_t>(size)));
   }

   HAS_STRICTLY_TYPED_ARG
   static scoped_refptr<SharedBuffer> Create(const char* data,
                                             STRICTLY_TYPED_ARG(size)) {
     ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
     return base::AdoptRef(new SharedBuffer(data, SafeCast<wtf_size_t>(size)));
   }

   HAS_STRICTLY_TYPED_ARG
   static scoped_refptr<SharedBuffer> Create(const unsigned char* data,
                                             STRICTLY_TYPED_ARG(size)) {
     ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
     return base::AdoptRef(new SharedBuffer(data, SafeCast<wtf_size_t>(size)));
   }

   static scoped_refptr<SharedBuffer> AdoptVector(Vector<char>&);

   ~SharedBuffer();

   // DEPRECATED: use a segment iterator, FlatData or explicit Copy() instead.
   //
   // Calling this function will force internal segmented buffers to be merged
   // into a flat buffer. Use iterator whenever possible for better performance.
   const char* Data();

   size_t size() const { return size_; }

   bool IsEmpty() const { return !size(); }

   void Append(const SharedBuffer&);

   HAS_STRICTLY_TYPED_ARG
   void Append(const char* data, STRICTLY_TYPED_ARG(size)) {
     ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
     AppendInternal(data, size);
   }
   void Append(const Vector<char>& data) { Append(data.data(), data.size()); }

   void Clear();

   Iterator begin() const;
   Iterator cbegin() const { return begin(); }
   Iterator end() const;
   Iterator cend() const { return end(); }

   // Copies the segmented data into a contiguous buffer.  Use GetSomeData() or
   // iterators if a copy is not required, as they are cheaper.
   // Supported Ts: WTF::Vector<char>, std::vector<char>.
   template <typename T>
   T CopyAs() const;

   // Returns an iterator for the given position of bytes. Returns |cend()| if
   // |position| is greater than or equal to |size()|.
   HAS_STRICTLY_TYPED_ARG
   Iterator GetIteratorAt(STRICTLY_TYPED_ARG(position)) const {
     STRICT_ARG_TYPE(size_t);
     return GetIteratorAtInternal(position);
   }

   // Copies |byteLength| bytes from the beginning of the content data into
   // |dest| as a flat buffer. Returns true on success, otherwise the content of
   // |dest| is not guaranteed.
   HAS_STRICTLY_TYPED_ARG
   WARN_UNUSED_RESULT
   bool GetBytes(void* dest, STRICTLY_TYPED_ARG(byte_length)) const {
     ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
     return GetBytesInternal(dest, byte_length);
   }

   // Creates an SkData and copies this SharedBuffer's contents to that
   // SkData without merging segmented buffers into a flat buffer.
   sk_sp<SkData> GetAsSkData() const;

   void OnMemoryDump(const String& dump_prefix, WebProcessMemoryDump*) const;

   // Helper for providing a contiguous view of the data.  If the SharedBuffer is
   // segmented, this will copy/merge all segments into a temporary buffer.
   // In general, clients should use the efficient/segmented accessors.
   class PLATFORM_EXPORT DeprecatedFlatData {
     STACK_ALLOCATED();

    public:
     explicit DeprecatedFlatData(scoped_refptr<const SharedBuffer>);

     const char* Data() const { return data_; }
     size_t size() const { return buffer_->size(); }

    private:
     scoped_refptr<const SharedBuffer> buffer_;
     Vector<char> flat_buffer_;
     const char* data_;
   };

  private:
   class Segment;

   SharedBuffer();
   explicit SharedBuffer(wtf_size_t);
   SharedBuffer(const char*, wtf_size_t);
   SharedBuffer(const unsigned char*, wtf_size_t);

   // See SharedBuffer::data().
   void MergeSegmentsIntoBuffer();

   void AppendInternal(const char* data, size_t);
   bool GetBytesInternal(void* dest, size_t) const;
   Iterator GetIteratorAtInternal(size_t position) const;
   size_t GetLastSegmentSize() const {
     DCHECK(!segments_.IsEmpty());
     return (size_ - buffer_.size() + kSegmentSize - 1) % kSegmentSize + 1;
   }

   size_t size_;
   Vector<char> buffer_;
   Vector<Segment> segments_;
 };

 // Current CopyAs specializations.
 template <>
 inline Vector<char> SharedBuffer::CopyAs() const {
   Vector<char> buffer;
   buffer.ReserveInitialCapacity(SafeCast<wtf_size_t>(size_));

   for (const auto& span : *this)
     buffer.Append(span.data(), static_cast<wtf_size_t>(span.size()));

   DCHECK_EQ(buffer.size(), size_);
   return buffer;
 }

 template <>
 inline Vector<uint8_t> SharedBuffer::CopyAs() const {
   Vector<uint8_t> buffer;
   buffer.ReserveInitialCapacity(SafeCast<wtf_size_t>(size_));

   for (const auto& span : *this) {
     buffer.Append(reinterpret_cast<const uint8_t*>(span.data()),
                   static_cast<wtf_size_t>(span.size()));
   }

   DCHECK_EQ(buffer.size(), size_);
   return buffer;
 }

 template <>
 inline std::vector<char> SharedBuffer::CopyAs() const {
   std::vector<char> buffer;
   buffer.reserve(size_);

   for (const auto& span : *this)
     buffer.insert(buffer.end(), span.data(), span.data() + span.size());

   DCHECK_EQ(buffer.size(), size_);
   return buffer;
 }

 }  // namespace blink

 #endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_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 THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_H_
	#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_H_

	#include <algorithm>
	#include <utility>
	#include <vector>

	#include "base/containers/span.h"
	#include "third_party/blink/renderer/platform/platform_export.h"
	#include "third_party/blink/renderer/platform/wtf/forward.h"
	#include "third_party/blink/renderer/platform/wtf/ref_counted.h"
	#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
	#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
	#include "third_party/blink/renderer/platform/wtf/vector.h"

	class SkData;
	template <typename T>
	class sk_sp;

	namespace blink {

	class WebProcessMemoryDump;

	class PLATFORM_EXPORT SharedBuffer : public RefCounted<SharedBuffer> {
	public:
	// Iterator for ShreadBuffer contents. An Iterator will get invalid once the
	// associated SharedBuffer is modified (e.g., Append() is called). An Iterator
	// doesn't retain the associated container.
	class PLATFORM_EXPORT Iterator final {
	public:
	~Iterator() = default;

	Iterator& operator++();
	Iterator operator++(int) {
	auto temp = *this;
	++*this;
	return temp;
	}
	bool operator==(const Iterator& that) const {
	return std::equal(value_.begin(), value_.end(), that.value_.begin(),
	that.value_.end()) &&
	buffer_ == that.buffer_;
	}
	bool operator!=(const Iterator& that) const { return !(*this == that); }
	const base::span<const char>& operator*() const {
	DCHECK(!IsEnd());
	return value_;
	}
	const base::span<const char>* operator->() const {
	DCHECK(!IsEnd());
	return &value_;
	}

	private:
	friend class SharedBuffer;
	// for end()
	Iterator(const SharedBuffer* buffer);
	// for the consecutive part
	Iterator(size_t offset, const SharedBuffer* buffer);
	// for the rest
	Iterator(wtf_size_t segment_index,
	size_t offset,
	const SharedBuffer* buffer);

	void Init(size_t offset);
	bool IsEnd() const { return index_ == buffer_->segments_.size() + 1; }

	// It represents \|buffer_->buffer\| if \|index_\| is 0, and
	// \|buffer_->segments[index_ - 1]\| otherwise.
	wtf_size_t index_;
	base::span<const char> value_;
	const SharedBuffer* buffer_;
	};

	static constexpr unsigned kSegmentSize = 0x1000;

	static scoped_refptr<SharedBuffer> Create() {
	return base::AdoptRef(new SharedBuffer);
	}

	HAS_STRICTLY_TYPED_ARG
	static scoped_refptr<SharedBuffer> Create(STRICTLY_TYPED_ARG(size)) {
	ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
	return base::AdoptRef(new SharedBuffer(SafeCast<wtf_size_t>(size)));
	}

	HAS_STRICTLY_TYPED_ARG
	static scoped_refptr<SharedBuffer> Create(const char* data,
	STRICTLY_TYPED_ARG(size)) {
	ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
	return base::AdoptRef(new SharedBuffer(data, SafeCast<wtf_size_t>(size)));
	}

	HAS_STRICTLY_TYPED_ARG
	static scoped_refptr<SharedBuffer> Create(const unsigned char* data,
	STRICTLY_TYPED_ARG(size)) {
	ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
	return base::AdoptRef(new SharedBuffer(data, SafeCast<wtf_size_t>(size)));
	}

	static scoped_refptr<SharedBuffer> AdoptVector(Vector<char>&);

	~SharedBuffer();

	// DEPRECATED: use a segment iterator, FlatData or explicit Copy() instead.
	//
	// Calling this function will force internal segmented buffers to be merged
	// into a flat buffer. Use iterator whenever possible for better performance.
	const char* Data();

	size_t size() const { return size_; }

	bool IsEmpty() const { return !size(); }

	void Append(const SharedBuffer&);

	HAS_STRICTLY_TYPED_ARG
	void Append(const char* data, STRICTLY_TYPED_ARG(size)) {
	ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
	AppendInternal(data, size);
	}
	void Append(const Vector<char>& data) { Append(data.data(), data.size()); }

	void Clear();

	Iterator begin() const;
	Iterator cbegin() const { return begin(); }
	Iterator end() const;
	Iterator cend() const { return end(); }

	// Copies the segmented data into a contiguous buffer. Use GetSomeData() or
	// iterators if a copy is not required, as they are cheaper.
	// Supported Ts: WTF::Vector<char>, std::vector<char>.
	template <typename T>
	T CopyAs() const;

	// Returns an iterator for the given position of bytes. Returns \|cend()\| if
	// \|position\| is greater than or equal to \|size()\|.
	HAS_STRICTLY_TYPED_ARG
	Iterator GetIteratorAt(STRICTLY_TYPED_ARG(position)) const {
	STRICT_ARG_TYPE(size_t);
	return GetIteratorAtInternal(position);
	}

	// Copies \|byteLength\| bytes from the beginning of the content data into
	// \|dest\| as a flat buffer. Returns true on success, otherwise the content of
	// \|dest\| is not guaranteed.
	HAS_STRICTLY_TYPED_ARG
	WARN_UNUSED_RESULT
	bool GetBytes(void* dest, STRICTLY_TYPED_ARG(byte_length)) const {
	ALLOW_NUMERIC_ARG_TYPES_PROMOTABLE_TO(size_t);
	return GetBytesInternal(dest, byte_length);
	}

	// Creates an SkData and copies this SharedBuffer's contents to that
	// SkData without merging segmented buffers into a flat buffer.
	sk_sp<SkData> GetAsSkData() const;

	void OnMemoryDump(const String& dump_prefix, WebProcessMemoryDump*) const;

	// Helper for providing a contiguous view of the data. If the SharedBuffer is
	// segmented, this will copy/merge all segments into a temporary buffer.
	// In general, clients should use the efficient/segmented accessors.
	class PLATFORM_EXPORT DeprecatedFlatData {
	STACK_ALLOCATED();

	public:
	explicit DeprecatedFlatData(scoped_refptr<const SharedBuffer>);

	const char* Data() const { return data_; }
	size_t size() const { return buffer_->size(); }

	private:
	scoped_refptr<const SharedBuffer> buffer_;
	Vector<char> flat_buffer_;
	const char* data_;
	};

	private:
	class Segment;

	SharedBuffer();
	explicit SharedBuffer(wtf_size_t);
	SharedBuffer(const char*, wtf_size_t);
	SharedBuffer(const unsigned char*, wtf_size_t);

	// See SharedBuffer::data().
	void MergeSegmentsIntoBuffer();

	void AppendInternal(const char* data, size_t);
	bool GetBytesInternal(void* dest, size_t) const;
	Iterator GetIteratorAtInternal(size_t position) const;
	size_t GetLastSegmentSize() const {
	DCHECK(!segments_.IsEmpty());
	return (size_ - buffer_.size() + kSegmentSize - 1) % kSegmentSize + 1;
	}

	size_t size_;
	Vector<char> buffer_;
	Vector<Segment> segments_;
	};

	// Current CopyAs specializations.
	template <>
	inline Vector<char> SharedBuffer::CopyAs() const {
	Vector<char> buffer;
	buffer.ReserveInitialCapacity(SafeCast<wtf_size_t>(size_));

	for (const auto& span : *this)
	buffer.Append(span.data(), static_cast<wtf_size_t>(span.size()));

	DCHECK_EQ(buffer.size(), size_);
	return buffer;
	}

	template <>
	inline Vector<uint8_t> SharedBuffer::CopyAs() const {
	Vector<uint8_t> buffer;
	buffer.ReserveInitialCapacity(SafeCast<wtf_size_t>(size_));

	for (const auto& span : *this) {
	buffer.Append(reinterpret_cast<const uint8_t*>(span.data()),
	static_cast<wtf_size_t>(span.size()));
	}

	DCHECK_EQ(buffer.size(), size_);
	return buffer;
	}

	template <>
	inline std::vector<char> SharedBuffer::CopyAs() const {
	std::vector<char> buffer;
	buffer.reserve(size_);

	for (const auto& span : *this)
	buffer.insert(buffer.end(), span.data(), span.data() + span.size());

	DCHECK_EQ(buffer.size(), size_);
	return buffer;
	}

	} // namespace blink

	#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_SHARED_BUFFER_H_