IPC::Message -> base::Pickle

base/pickle.cc

 // 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>
@@ skipping 190 matching lines @@
 }
 
 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() {}
+
+Pickle::Attachment::~Attachment() {}
+
 // Payload is uint32_t aligned.
 
 Pickle::Pickle()
     : header_(NULL),
       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);
@@ skipping 94 matching lines @@
   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);
@@ skipping 84 matching lines @@
 
 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