Remove Pickle::WriteSize() now that it has no remaining callers.

base/pickle.h

 // 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__
 #pragma once
 
 #include <string>
 
@@ skipping 13 matching lines @@
   PickleIterator() : read_ptr_(NULL), read_end_ptr_(NULL) {}
   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.
   bool ReadBool(bool* result) WARN_UNUSED_RESULT;
   bool ReadInt(int* result) WARN_UNUSED_RESULT;
   bool ReadLong(long* result) WARN_UNUSED_RESULT;
-  bool ReadSize(size_t* result) WARN_UNUSED_RESULT;
   bool ReadUInt16(uint16* result) WARN_UNUSED_RESULT;
   bool ReadUInt32(uint32* result) WARN_UNUSED_RESULT;
   bool ReadInt64(int64* result) WARN_UNUSED_RESULT;
   bool ReadUInt64(uint64* result) WARN_UNUSED_RESULT;
   bool ReadString(std::string* result) WARN_UNUSED_RESULT;
   bool ReadWString(std::wstring* result) WARN_UNUSED_RESULT;
   bool ReadString16(string16* result) WARN_UNUSED_RESULT;
   bool ReadData(const char** data, int* length) WARN_UNUSED_RESULT;
   bool ReadBytes(const char** data, int length) WARN_UNUSED_RESULT;
 
@@ skipping 96 matching lines @@
   // TODO(jbates) Remove these methods.
   bool ReadBool(PickleIterator* iter, bool* result) const {
     return iter->ReadBool(result);
   }
   bool ReadInt(PickleIterator* iter, int* result) const {
     return iter->ReadInt(result);
   }
   bool ReadLong(PickleIterator* iter, long* result) const {
     return iter->ReadLong(result);
   }
-  bool ReadSize(PickleIterator* iter, size_t* result) const {
-    return iter->ReadSize(result);
-  }
   bool ReadUInt16(PickleIterator* iter, uint16* result) const {
     return iter->ReadUInt16(result);
   }
   bool ReadUInt32(PickleIterator* iter, uint32* result) const {
     return iter->ReadUInt32(result);
   }
   bool ReadInt64(PickleIterator* iter, int64* result) const {
     return iter->ReadInt64(result);
   }
   bool ReadUInt64(PickleIterator* iter, uint64* result) const {
@@ skipping 24 matching lines @@
   // 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.
   bool WriteBool(bool value) {
     return WriteInt(value ? 1 : 0);
   }
   bool WriteInt(int value) {
     return WriteBytes(&value, sizeof(value));
   }
+  // WARNING: DO NOT USE WriteLong() IF PICKLES ARE PERSISTED IN ANY WAY.
+  // WriteLong() writes whatever a "long" is on this architecture. On 32-bit
+  // platforms, it is 32 bits. On 64-bit platforms, it is 64 bits. If persisted
+  // pickles are still around after upgrading to 64-bit, or if they are copied
+  // between dissimilar systems, YOUR PICKLES WILL HAVE GONE BAD.

[jar (doing other things), 2012/03/22 21:08:57]

How about changing the name to something that clarifies that the user should not
be using it?  How about:

WriteLongUsingDangerousNonPortableLessPersistableForm()

This would avoid "using it by accident," and alert reviewers about the issue
that is best(?) avoided.

[Mike Mammarella, 2012/03/22 21:30:52]

I took a look and it turns out that WriteLong() is only used in one place, for
IPC - it just caused tons of compiler errors when I removed it the first time so
I had assumed it was all over the place. I've renamed the method and updated the
use in IPC, since I assume we don't want to add unnecessary overhead there (e.g.
by using 64 bits on 32-bit platforms).

   bool WriteLong(long value) {
     return WriteBytes(&value, sizeof(value));
   }
-  bool WriteSize(size_t value) {
-    return WriteBytes(&value, sizeof(value));
-  }
   bool WriteUInt16(uint16 value) {
     return WriteBytes(&value, sizeof(value));
   }
   bool WriteUInt32(uint32 value) {
     return WriteBytes(&value, sizeof(value));
   }
   bool WriteInt64(int64 value) {
     return WriteBytes(&value, sizeof(value));
   }
   bool WriteUInt64(uint64 value) {
@@ skipping 109 matching lines @@
   // Allocation size of payload (or -1 if allocation is const).
   size_t capacity_;
   size_t variable_buffer_offset_;  // IF non-zero, then offset to a buffer.
 
   FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
 };
 
 #endif  // BASE_PICKLE_H__