Remove base/pickle Change-Id: Ic3897cd4c4e1c2998291e63518ca6da67ef144d0 Reviewed-on: https://gn-review.googlesource.com/1423 Reviewed-by: Brett Wilson <brettw@chromium.org> Commit-Queue: Scott Graham <scottmg@chromium.org>
diff --git a/base/files/file_path.cc b/base/files/file_path.cc index 6221db9..146796b 100644 --- a/base/files/file_path.cc +++ b/base/files/file_path.cc
@@ -9,7 +9,6 @@ #include "base/logging.h" #include "base/macros.h" -#include "base/pickle.h" #include "base/strings/string_piece.h" #include "base/strings/string_util.h" #include "base/strings/sys_string_conversions.h" @@ -667,33 +666,6 @@ #endif // defined(OS_WIN) -void FilePath::WriteToPickle(Pickle* pickle) const { -#if defined(OS_WIN) - pickle->WriteString16(path_); -#elif defined(OS_POSIX) || defined(OS_FUCHSIA) - pickle->WriteString(path_); -#else -#error Unsupported platform -#endif -} - -bool FilePath::ReadFromPickle(PickleIterator* iter) { -#if defined(OS_WIN) - if (!iter->ReadString16(&path_)) - return false; -#elif defined(OS_POSIX) || defined(OS_FUCHSIA) - if (!iter->ReadString(&path_)) - return false; -#else -#error Unsupported platform -#endif - - if (path_.find(kStringTerminator) != StringType::npos) - return false; - - return true; -} - #if defined(OS_WIN) // Windows specific implementation of file string comparisons.
diff --git a/base/files/file_path.h b/base/files/file_path.h index a31253e..340375d 100644 --- a/base/files/file_path.h +++ b/base/files/file_path.h
@@ -384,9 +384,6 @@ // Similar to FromUTF8Unsafe, but accepts UTF-16 instead. static FilePath FromUTF16Unsafe(StringPiece16 utf16); - void WriteToPickle(Pickle* pickle) const; - bool ReadFromPickle(PickleIterator* iter); - // Normalize all path separators to backslash on Windows // (if FILE_PATH_USES_WIN_SEPARATORS is true), or do nothing on POSIX systems. FilePath NormalizePathSeparators() const;
diff --git a/base/pickle.cc b/base/pickle.cc deleted file mode 100644 index 89e2d01..0000000 --- a/base/pickle.cc +++ /dev/null
@@ -1,435 +0,0 @@ -// Copyright (c) 2012 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/pickle.h" - -#include <stdlib.h> - -#include <algorithm> // for max() -#include <limits> - -#include "base/bits.h" -#include "base/macros.h" -#include "base/numerics/safe_conversions.h" -#include "base/numerics/safe_math.h" -#include "build_config.h" - -namespace base { - -// static -const int Pickle::kPayloadUnit = 64; - -static const size_t kCapacityReadOnly = static_cast<size_t>(-1); - -PickleIterator::PickleIterator(const Pickle& pickle) - : payload_(pickle.payload()), - read_index_(0), - end_index_(pickle.payload_size()) { -} - -template <typename Type> -inline bool PickleIterator::ReadBuiltinType(Type* result) { - const char* read_from = GetReadPointerAndAdvance<Type>(); - if (!read_from) - return false; - if (sizeof(Type) > sizeof(uint32_t)) - memcpy(result, read_from, sizeof(*result)); - else - *result = *reinterpret_cast<const Type*>(read_from); - return true; -} - -inline void PickleIterator::Advance(size_t size) { - size_t aligned_size = bits::Align(size, sizeof(uint32_t)); - if (end_index_ - read_index_ < aligned_size) { - read_index_ = end_index_; - } else { - read_index_ += aligned_size; - } -} - -template<typename Type> -inline const char* PickleIterator::GetReadPointerAndAdvance() { - if (sizeof(Type) > end_index_ - read_index_) { - read_index_ = end_index_; - return nullptr; - } - const char* current_read_ptr = payload_ + read_index_; - Advance(sizeof(Type)); - return current_read_ptr; -} - -const char* PickleIterator::GetReadPointerAndAdvance(int num_bytes) { - if (num_bytes < 0 || - end_index_ - read_index_ < static_cast<size_t>(num_bytes)) { - read_index_ = end_index_; - return nullptr; - } - const char* current_read_ptr = payload_ + read_index_; - Advance(num_bytes); - return current_read_ptr; -} - -inline const char* PickleIterator::GetReadPointerAndAdvance( - int num_elements, - size_t size_element) { - // Check for int32_t overflow. - int num_bytes; - if (!CheckMul(num_elements, size_element).AssignIfValid(&num_bytes)) - return nullptr; - return GetReadPointerAndAdvance(num_bytes); -} - -bool PickleIterator::ReadBool(bool* result) { - return ReadBuiltinType(result); -} - -bool PickleIterator::ReadInt(int* result) { - return ReadBuiltinType(result); -} - -bool PickleIterator::ReadLong(long* result) { - // Always read long as a 64-bit value to ensure compatibility between 32-bit - // and 64-bit processes. - int64_t result_int64 = 0; - if (!ReadBuiltinType(&result_int64)) - return false; - // CHECK if the cast truncates the value so that we know to change this IPC - // parameter to use int64_t. - *result = base::checked_cast<long>(result_int64); - return true; -} - -bool PickleIterator::ReadUInt16(uint16_t* result) { - return ReadBuiltinType(result); -} - -bool PickleIterator::ReadUInt32(uint32_t* result) { - return ReadBuiltinType(result); -} - -bool PickleIterator::ReadInt64(int64_t* result) { - return ReadBuiltinType(result); -} - -bool PickleIterator::ReadUInt64(uint64_t* result) { - return ReadBuiltinType(result); -} - -bool PickleIterator::ReadFloat(float* result) { - // crbug.com/315213 - // The source data may not be properly aligned, and unaligned float reads - // cause SIGBUS on some ARM platforms, so force using memcpy to copy the data - // into the result. - const char* read_from = GetReadPointerAndAdvance<float>(); - if (!read_from) - return false; - memcpy(result, read_from, sizeof(*result)); - return true; -} - -bool PickleIterator::ReadDouble(double* result) { - // crbug.com/315213 - // The source data may not be properly aligned, and unaligned double reads - // cause SIGBUS on some ARM platforms, so force using memcpy to copy the data - // into the result. - const char* read_from = GetReadPointerAndAdvance<double>(); - if (!read_from) - return false; - memcpy(result, read_from, sizeof(*result)); - return true; -} - -bool PickleIterator::ReadString(std::string* result) { - int len; - if (!ReadInt(&len)) - return false; - const char* read_from = GetReadPointerAndAdvance(len); - if (!read_from) - return false; - - result->assign(read_from, len); - return true; -} - -bool PickleIterator::ReadStringPiece(StringPiece* result) { - int len; - if (!ReadInt(&len)) - return false; - const char* read_from = GetReadPointerAndAdvance(len); - if (!read_from) - return false; - - *result = StringPiece(read_from, len); - return true; -} - -bool PickleIterator::ReadString16(string16* result) { - int len; - if (!ReadInt(&len)) - return false; - const char* read_from = GetReadPointerAndAdvance(len, sizeof(char16)); - if (!read_from) - return false; - - result->assign(reinterpret_cast<const char16*>(read_from), len); - return true; -} - -bool PickleIterator::ReadStringPiece16(StringPiece16* result) { - int len; - if (!ReadInt(&len)) - return false; - const char* read_from = GetReadPointerAndAdvance(len, sizeof(char16)); - if (!read_from) - return false; - - *result = StringPiece16(reinterpret_cast<const char16*>(read_from), len); - return true; -} - -bool PickleIterator::ReadData(const char** data, int* length) { - *length = 0; - *data = nullptr; - - if (!ReadInt(length)) - return false; - - return ReadBytes(data, *length); -} - -bool PickleIterator::ReadBytes(const char** data, int length) { - const char* read_from = GetReadPointerAndAdvance(length); - if (!read_from) - return false; - *data = read_from; - return true; -} - -Pickle::Attachment::Attachment() = default; - -Pickle::Attachment::~Attachment() = default; - -// Payload is uint32_t aligned. - -Pickle::Pickle() - : header_(nullptr), - header_size_(sizeof(Header)), - capacity_after_header_(0), - write_offset_(0) { - static_assert((Pickle::kPayloadUnit & (Pickle::kPayloadUnit - 1)) == 0, - "Pickle::kPayloadUnit must be a power of two"); - Resize(kPayloadUnit); - header_->payload_size = 0; -} - -Pickle::Pickle(int header_size) - : header_(nullptr), - header_size_(bits::Align(header_size, sizeof(uint32_t))), - capacity_after_header_(0), - write_offset_(0) { - DCHECK_GE(static_cast<size_t>(header_size), sizeof(Header)); - DCHECK_LE(header_size, kPayloadUnit); - Resize(kPayloadUnit); - header_->payload_size = 0; -} - -Pickle::Pickle(const char* data, int data_len) - : header_(reinterpret_cast<Header*>(const_cast<char*>(data))), - header_size_(0), - capacity_after_header_(kCapacityReadOnly), - write_offset_(0) { - if (data_len >= static_cast<int>(sizeof(Header))) - header_size_ = data_len - header_->payload_size; - - if (header_size_ > static_cast<unsigned int>(data_len)) - header_size_ = 0; - - if (header_size_ != bits::Align(header_size_, sizeof(uint32_t))) - header_size_ = 0; - - // If there is anything wrong with the data, we're not going to use it. - if (!header_size_) - header_ = nullptr; -} - -Pickle::Pickle(const Pickle& other) - : header_(nullptr), - header_size_(other.header_size_), - capacity_after_header_(0), - write_offset_(other.write_offset_) { - Resize(other.header_->payload_size); - memcpy(header_, other.header_, header_size_ + other.header_->payload_size); -} - -Pickle::~Pickle() { - if (capacity_after_header_ != kCapacityReadOnly) - free(header_); -} - -Pickle& Pickle::operator=(const Pickle& other) { - if (this == &other) { - return *this; - } - if (capacity_after_header_ == kCapacityReadOnly) { - header_ = nullptr; - capacity_after_header_ = 0; - } - if (header_size_ != other.header_size_) { - free(header_); - header_ = nullptr; - header_size_ = other.header_size_; - } - Resize(other.header_->payload_size); - memcpy(header_, other.header_, - other.header_size_ + other.header_->payload_size); - write_offset_ = other.write_offset_; - return *this; -} - -void Pickle::WriteString(const StringPiece& value) { - WriteInt(static_cast<int>(value.size())); - WriteBytes(value.data(), static_cast<int>(value.size())); -} - -void Pickle::WriteString16(const StringPiece16& value) { - WriteInt(static_cast<int>(value.size())); - WriteBytes(value.data(), static_cast<int>(value.size()) * sizeof(char16)); -} - -void Pickle::WriteData(const char* data, int length) { - DCHECK_GE(length, 0); - WriteInt(length); - WriteBytes(data, length); -} - -void Pickle::WriteBytes(const void* data, int length) { - WriteBytesCommon(data, length); -} - -void Pickle::Reserve(size_t length) { - size_t data_len = bits::Align(length, sizeof(uint32_t)); - DCHECK_GE(data_len, length); -#ifdef ARCH_CPU_64_BITS - DCHECK_LE(data_len, std::numeric_limits<uint32_t>::max()); -#endif - DCHECK_LE(write_offset_, std::numeric_limits<uint32_t>::max() - data_len); - size_t new_size = write_offset_ + data_len; - if (new_size > capacity_after_header_) - Resize(capacity_after_header_ * 2 + new_size); -} - -bool Pickle::WriteAttachment(scoped_refptr<Attachment> attachment) { - return false; -} - -bool Pickle::ReadAttachment(base::PickleIterator* iter, - scoped_refptr<Attachment>* attachment) const { - return false; -} - -bool Pickle::HasAttachments() const { - return false; -} - -void Pickle::Resize(size_t new_capacity) { - CHECK_NE(capacity_after_header_, kCapacityReadOnly); - capacity_after_header_ = bits::Align(new_capacity, kPayloadUnit); - void* p = realloc(header_, GetTotalAllocatedSize()); - CHECK(p); - header_ = reinterpret_cast<Header*>(p); -} - -void* Pickle::ClaimBytes(size_t num_bytes) { - void* p = ClaimUninitializedBytesInternal(num_bytes); - CHECK(p); - memset(p, 0, num_bytes); - return p; -} - -size_t Pickle::GetTotalAllocatedSize() const { - if (capacity_after_header_ == kCapacityReadOnly) - return 0; - return header_size_ + capacity_after_header_; -} - -// static -const char* Pickle::FindNext(size_t header_size, - const char* start, - const char* end) { - size_t pickle_size = 0; - if (!PeekNext(header_size, start, end, &pickle_size)) - return nullptr; - - if (pickle_size > static_cast<size_t>(end - start)) - return nullptr; - - return start + pickle_size; -} - -// static -bool Pickle::PeekNext(size_t header_size, - const char* start, - const char* end, - size_t* pickle_size) { - DCHECK_EQ(header_size, bits::Align(header_size, sizeof(uint32_t))); - DCHECK_GE(header_size, sizeof(Header)); - DCHECK_LE(header_size, static_cast<size_t>(kPayloadUnit)); - - size_t length = static_cast<size_t>(end - start); - if (length < sizeof(Header)) - return false; - - const Header* hdr = reinterpret_cast<const Header*>(start); - if (length < header_size) - return false; - - // If payload_size causes an overflow, we return maximum possible - // pickle size to indicate that. - *pickle_size = ClampAdd(header_size, hdr->payload_size); - return true; -} - -template <size_t length> void Pickle::WriteBytesStatic(const void* data) { - WriteBytesCommon(data, length); -} - -template void Pickle::WriteBytesStatic<2>(const void* data); -template void Pickle::WriteBytesStatic<4>(const void* data); -template void Pickle::WriteBytesStatic<8>(const void* data); - -inline void* Pickle::ClaimUninitializedBytesInternal(size_t length) { - DCHECK_NE(kCapacityReadOnly, capacity_after_header_) - << "oops: pickle is readonly"; - size_t data_len = bits::Align(length, sizeof(uint32_t)); - DCHECK_GE(data_len, length); -#ifdef ARCH_CPU_64_BITS - DCHECK_LE(data_len, std::numeric_limits<uint32_t>::max()); -#endif - DCHECK_LE(write_offset_, std::numeric_limits<uint32_t>::max() - data_len); - size_t new_size = write_offset_ + data_len; - if (new_size > capacity_after_header_) { - size_t new_capacity = capacity_after_header_ * 2; - const size_t kPickleHeapAlign = 4096; - if (new_capacity > kPickleHeapAlign) - new_capacity = bits::Align(new_capacity, kPickleHeapAlign) - kPayloadUnit; - Resize(std::max(new_capacity, new_size)); - } - - char* write = mutable_payload() + write_offset_; - memset(write + length, 0, data_len - length); // Always initialize padding - header_->payload_size = static_cast<uint32_t>(new_size); - write_offset_ = new_size; - return write; -} - -inline void Pickle::WriteBytesCommon(const void* data, size_t length) { - DCHECK_NE(kCapacityReadOnly, capacity_after_header_) - << "oops: pickle is readonly"; - MSAN_CHECK_MEM_IS_INITIALIZED(data, length); - void* write = ClaimUninitializedBytesInternal(length); - memcpy(write, data, length); -} - -} // namespace base
diff --git a/base/pickle.h b/base/pickle.h deleted file mode 100644 index eff2092..0000000 --- a/base/pickle.h +++ /dev/null
@@ -1,345 +0,0 @@ -// Copyright (c) 2012 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 BASE_PICKLE_H_ -#define BASE_PICKLE_H_ - -#include <stddef.h> -#include <stdint.h> - -#include <string> - -#include "base/base_export.h" -#include "base/compiler_specific.h" -#include "base/gtest_prod_util.h" -#include "base/logging.h" -#include "base/memory/ref_counted.h" -#include "base/strings/string16.h" -#include "base/strings/string_piece.h" - -#if defined(OS_POSIX) -#include "base/files/file.h" -#endif - -namespace base { - -class Pickle; - -// PickleIterator reads data from a Pickle. The Pickle object must remain valid -// while the PickleIterator object is in use. -class BASE_EXPORT PickleIterator { - public: - PickleIterator() : payload_(NULL), read_index_(0), end_index_(0) {} - explicit PickleIterator(const Pickle& pickle); - - // Methods for reading the payload of the Pickle. To read from the start of - // the Pickle, create a PickleIterator from a Pickle. If successful, these - // methods return true. Otherwise, false is returned to indicate that the - // result could not be extracted. It is not possible to read from the iterator - // after that. - bool ReadBool(bool* result) WARN_UNUSED_RESULT; - bool ReadInt(int* result) WARN_UNUSED_RESULT; - bool ReadLong(long* result) WARN_UNUSED_RESULT; - bool ReadUInt16(uint16_t* result) WARN_UNUSED_RESULT; - bool ReadUInt32(uint32_t* result) WARN_UNUSED_RESULT; - bool ReadInt64(int64_t* result) WARN_UNUSED_RESULT; - bool ReadUInt64(uint64_t* result) WARN_UNUSED_RESULT; - bool ReadFloat(float* result) WARN_UNUSED_RESULT; - bool ReadDouble(double* result) WARN_UNUSED_RESULT; - bool ReadString(std::string* result) WARN_UNUSED_RESULT; - // The StringPiece data will only be valid for the lifetime of the message. - bool ReadStringPiece(StringPiece* result) WARN_UNUSED_RESULT; - bool ReadString16(string16* result) WARN_UNUSED_RESULT; - // The StringPiece16 data will only be valid for the lifetime of the message. - bool ReadStringPiece16(StringPiece16* result) WARN_UNUSED_RESULT; - - // A pointer to the data will be placed in |*data|, and the length will be - // placed in |*length|. The pointer placed into |*data| points into the - // message's buffer so it will be scoped to the lifetime of the message (or - // until the message data is mutated). Do not keep the pointer around! - bool ReadData(const char** data, int* length) WARN_UNUSED_RESULT; - - // A pointer to the data will be placed in |*data|. The caller specifies the - // number of bytes to read, and ReadBytes will validate this length. The - // pointer placed into |*data| points into the message's buffer so it will be - // scoped to the lifetime of the message (or until the message data is - // mutated). Do not keep the pointer around! - bool ReadBytes(const char** data, int length) WARN_UNUSED_RESULT; - - // A safer version of ReadInt() that checks for the result not being negative. - // Use it for reading the object sizes. - bool ReadLength(int* result) WARN_UNUSED_RESULT { - return ReadInt(result) && *result >= 0; - } - - // Skips bytes in the read buffer and returns true if there are at least - // num_bytes available. Otherwise, does nothing and returns false. - bool SkipBytes(int num_bytes) WARN_UNUSED_RESULT { - return !!GetReadPointerAndAdvance(num_bytes); - } - - private: - // Read Type from Pickle. - template <typename Type> - bool ReadBuiltinType(Type* result); - - // Advance read_index_ but do not allow it to exceed end_index_. - // Keeps read_index_ aligned. - void Advance(size_t size); - - // Get read pointer for Type and advance read pointer. - template<typename Type> - const char* GetReadPointerAndAdvance(); - - // Get read pointer for |num_bytes| and advance read pointer. This method - // checks num_bytes for negativity and wrapping. - const char* GetReadPointerAndAdvance(int num_bytes); - - // Get read pointer for (num_elements * size_element) bytes and advance read - // pointer. This method checks for int overflow, negativity and wrapping. - const char* GetReadPointerAndAdvance(int num_elements, - size_t size_element); - - const char* payload_; // Start of our pickle's payload. - size_t read_index_; // Offset of the next readable byte in payload. - size_t end_index_; // Payload size. - - FRIEND_TEST_ALL_PREFIXES(PickleTest, GetReadPointerAndAdvance); -}; - -// This class provides facilities for basic binary value packing and unpacking. -// -// The Pickle class supports appending primitive values (ints, strings, etc.) -// to a pickle instance. The Pickle instance grows its internal memory buffer -// dynamically to hold the sequence of primitive values. The internal memory -// buffer is exposed as the "data" of the Pickle. This "data" can be passed -// to a Pickle object to initialize it for reading. -// -// When reading from a Pickle object, it is important for the consumer to know -// what value types to read and in what order to read them as the Pickle does -// not keep track of the type of data written to it. -// -// The Pickle's data has a header which contains the size of the Pickle's -// payload. It can optionally support additional space in the header. That -// space is controlled by the header_size parameter passed to the Pickle -// constructor. -// -class BASE_EXPORT Pickle { - public: - // Auxiliary data attached to a Pickle. Pickle must be subclassed along with - // this interface in order to provide a concrete implementation of support - // for attachments. The base Pickle implementation does not accept - // attachments. - class BASE_EXPORT Attachment : public RefCountedThreadSafe<Attachment> { - public: - Attachment(); - - protected: - friend class RefCountedThreadSafe<Attachment>; - virtual ~Attachment(); - - DISALLOW_COPY_AND_ASSIGN(Attachment); - }; - - // Initialize a Pickle object using the default header size. - Pickle(); - - // Initialize a Pickle object with the specified header size in bytes, which - // must be greater-than-or-equal-to sizeof(Pickle::Header). The header size - // will be rounded up to ensure that the header size is 32bit-aligned. - explicit Pickle(int header_size); - - // Initializes a Pickle from a const block of data. The data is not copied; - // instead the data is merely referenced by this Pickle. Only const methods - // should be used on the Pickle when initialized this way. The header - // padding size is deduced from the data length. - Pickle(const char* data, int data_len); - - // Initializes a Pickle as a deep copy of another Pickle. - Pickle(const Pickle& other); - - // Note: There are no virtual methods in this class. This destructor is - // virtual as an element of defensive coding. Other classes have derived from - // this class, and there is a *chance* that they will cast into this base - // class before destruction. At least one such class does have a virtual - // destructor, suggesting at least some need to call more derived destructors. - virtual ~Pickle(); - - // Performs a deep copy. - Pickle& operator=(const Pickle& other); - - // Returns the number of bytes written in the Pickle, including the header. - size_t size() const { return header_size_ + header_->payload_size; } - - // Returns the data for this Pickle. - const void* data() const { return header_; } - - // Returns the effective memory capacity of this Pickle, that is, the total - // number of bytes currently dynamically allocated or 0 in the case of a - // read-only Pickle. This should be used only for diagnostic / profiling - // purposes. - size_t GetTotalAllocatedSize() const; - - // Methods for adding to the payload of the Pickle. These values are - // appended to the end of the Pickle's payload. When reading values from a - // Pickle, it is important to read them in the order in which they were added - // to the Pickle. - - void WriteBool(bool value) { WriteInt(value ? 1 : 0); } - void WriteInt(int value) { WritePOD(value); } - void WriteLong(long value) { - // Always write long as a 64-bit value to ensure compatibility between - // 32-bit and 64-bit processes. - WritePOD(static_cast<int64_t>(value)); - } - void WriteUInt16(uint16_t value) { WritePOD(value); } - void WriteUInt32(uint32_t value) { WritePOD(value); } - void WriteInt64(int64_t value) { WritePOD(value); } - void WriteUInt64(uint64_t value) { WritePOD(value); } - void WriteFloat(float value) { WritePOD(value); } - void WriteDouble(double value) { WritePOD(value); } - void WriteString(const StringPiece& value); - void WriteString16(const StringPiece16& value); - // "Data" is a blob with a length. When you read it out you will be given the - // length. See also WriteBytes. - void WriteData(const char* data, int length); - // "Bytes" is a blob with no length. The caller must specify the length both - // when reading and writing. It is normally used to serialize PoD types of a - // known size. See also WriteData. - void WriteBytes(const void* data, int length); - - // WriteAttachment appends |attachment| to the pickle. It returns - // false iff the set is full or if the Pickle implementation does not support - // attachments. - virtual bool WriteAttachment(scoped_refptr<Attachment> attachment); - - // ReadAttachment parses an attachment given the parsing state |iter| and - // writes it to |*attachment|. It returns true on success. - virtual bool ReadAttachment(base::PickleIterator* iter, - scoped_refptr<Attachment>* attachment) const; - - // Indicates whether the pickle has any attachments. - virtual bool HasAttachments() const; - - // Reserves space for upcoming writes when multiple writes will be made and - // their sizes are computed in advance. It can be significantly faster to call - // Reserve() before calling WriteFoo() multiple times. - void Reserve(size_t additional_capacity); - - // Payload follows after allocation of Header (header size is customizable). - struct Header { - uint32_t payload_size; // Specifies the size of the payload. - }; - - // Returns the header, cast to a user-specified type T. The type T must be a - // subclass of Header and its size must correspond to the header_size passed - // to the Pickle constructor. - template <class T> - T* headerT() { - DCHECK_EQ(header_size_, sizeof(T)); - return static_cast<T*>(header_); - } - template <class T> - const T* headerT() const { - DCHECK_EQ(header_size_, sizeof(T)); - return static_cast<const T*>(header_); - } - - // The payload is the pickle data immediately following the header. - size_t payload_size() const { - return header_ ? header_->payload_size : 0; - } - - const char* payload() const { - return reinterpret_cast<const char*>(header_) + header_size_; - } - - // Returns the address of the byte immediately following the currently valid - // header + payload. - const char* end_of_payload() const { - // This object may be invalid. - return header_ ? payload() + payload_size() : NULL; - } - - protected: - // Returns size of the header, which can have default value, set by user or - // calculated by passed raw data. - size_t header_size() const { return header_size_; } - - char* mutable_payload() { - return reinterpret_cast<char*>(header_) + header_size_; - } - - size_t capacity_after_header() const { - return capacity_after_header_; - } - - // Resize the capacity, note that the input value should not include the size - // of the header. - void Resize(size_t new_capacity); - - // Claims |num_bytes| bytes of payload. This is similar to Reserve() in that - // it may grow the capacity, but it also advances the write offset of the - // pickle by |num_bytes|. Claimed memory, including padding, is zeroed. - // - // Returns the address of the first byte claimed. - void* ClaimBytes(size_t num_bytes); - - // Find the end of the pickled data that starts at range_start. Returns NULL - // if the entire Pickle is not found in the given data range. - static const char* FindNext(size_t header_size, - const char* range_start, - const char* range_end); - - // Parse pickle header and return total size of the pickle. Data range - // doesn't need to contain entire pickle. - // Returns true if pickle header was found and parsed. Callers must check - // returned |pickle_size| for sanity (against maximum message size, etc). - // NOTE: when function successfully parses a header, but encounters an - // overflow during pickle size calculation, it sets |pickle_size| to the - // maximum size_t value and returns true. - static bool PeekNext(size_t header_size, - const char* range_start, - const char* range_end, - size_t* pickle_size); - - // The allocation granularity of the payload. - static const int kPayloadUnit; - - private: - friend class PickleIterator; - - Header* header_; - size_t header_size_; // Supports extra data between header and payload. - // Allocation size of payload (or -1 if allocation is const). Note: this - // doesn't count the header. - size_t capacity_after_header_; - // The offset at which we will write the next field. Note: this doesn't count - // the header. - size_t write_offset_; - - // Just like WriteBytes, but with a compile-time size, for performance. - template<size_t length> void BASE_EXPORT WriteBytesStatic(const void* data); - - // Writes a POD by copying its bytes. - template <typename T> bool WritePOD(const T& data) { - WriteBytesStatic<sizeof(data)>(&data); - return true; - } - - inline void* ClaimUninitializedBytesInternal(size_t num_bytes); - inline void WriteBytesCommon(const void* data, size_t length); - - FRIEND_TEST_ALL_PREFIXES(PickleTest, DeepCopyResize); - FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize); - FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNext); - FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNextOverflow); - FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext); - FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader); - FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextOverflow); -}; - -} // namespace base - -#endif // BASE_PICKLE_H_
diff --git a/build/gen.py b/build/gen.py index 9cca4e9..5f73187 100755 --- a/build/gen.py +++ b/build/gen.py
@@ -281,7 +281,6 @@ 'base/observer_list_threadsafe.cc', 'base/path_service.cc', 'base/pending_task.cc', - 'base/pickle.cc', 'base/process/kill.cc', 'base/process/memory.cc', 'base/process/process_handle.cc',