Pickle: don't mark these methods inline when they're not

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()
 
 //------------------------------------------------------------------------------
 
 using base::char16;
 using base::string16;
 
 // static
 const int Pickle::kPayloadUnit = 64;
 
 static const size_t kCapacityReadOnly = static_cast<size_t>(-1);
 
 PickleIterator::PickleIterator(const Pickle& pickle)
     : read_ptr_(pickle.payload()),
       read_end_ptr_(pickle.end_of_payload()) {
 }
 
 template <typename Type>
-inline bool PickleIterator::ReadBuiltinType(Type* result) {
+bool PickleIterator::ReadBuiltinType(Type* result) {
   const char* read_from = GetReadPointerAndAdvance<Type>();
   if (!read_from)
     return false;
   if (sizeof(Type) > sizeof(uint32))
     memcpy(result, read_from, sizeof(*result));
   else
     *result = *reinterpret_cast<const Type*>(read_from);
   return true;
 }
 
 template<typename Type>
-inline const char* PickleIterator::GetReadPointerAndAdvance() {
+const char* PickleIterator::GetReadPointerAndAdvance() {
   const char* current_read_ptr = read_ptr_;
   if (read_ptr_ + sizeof(Type) > read_end_ptr_)
     return NULL;
   if (sizeof(Type) < sizeof(uint32))
     read_ptr_ += AlignInt(sizeof(Type), sizeof(uint32));
   else
     read_ptr_ += sizeof(Type);
   return current_read_ptr;
 }
 
 const char* PickleIterator::GetReadPointerAndAdvance(int num_bytes) {
   if (num_bytes < 0 || read_end_ptr_ - read_ptr_ < num_bytes)
     return NULL;
   const char* current_read_ptr = read_ptr_;
   read_ptr_ += AlignInt(num_bytes, sizeof(uint32));
   return current_read_ptr;
 }
 
-inline const char* PickleIterator::GetReadPointerAndAdvance(int num_elements,
-                                                          size_t size_element) {
+const char* PickleIterator::GetReadPointerAndAdvance(int num_elements,
+                                                     size_t size_element) {
   // Check for int32 overflow.
   int64 num_bytes = static_cast<int64>(num_elements) * size_element;
   int num_bytes32 = static_cast<int>(num_bytes);
   if (num_bytes != static_cast<int64>(num_bytes32))
     return NULL;
   return GetReadPointerAndAdvance(num_bytes32);
 }
 
 bool PickleIterator::ReadBool(bool* result) {
   return ReadBuiltinType(result);
@@ skipping 238 matching lines @@
 }
 
 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::WriteBytesCommon(const void* data, size_t length) {
+void Pickle::WriteBytesCommon(const void* data, size_t length) {
   DCHECK_NE(kCapacityReadOnly, capacity_after_header_)
       << "oops: pickle is readonly";
   size_t data_len = AlignInt(length, sizeof(uint32));
   DCHECK_GE(data_len, length);
 #ifdef ARCH_CPU_64_BITS
   DCHECK_LE(data_len, kuint32max);
 #endif
   DCHECK_LE(write_offset_, kuint32max - data_len);
   size_t new_size = write_offset_ + data_len;
   if (new_size > capacity_after_header_) {
     Resize(std::max(capacity_after_header_ * 2, new_size));
   }
 
   char* write = mutable_payload() + write_offset_;
   memcpy(write, data, length);
   memset(write + length, 0, data_len - length);
   header_->payload_size = static_cast<uint32>(write_offset_ + length);
   write_offset_ = new_size;
 }