Pickle::Write* micro-optimizations

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__
 
 #include <string>
 
 #include "base/base_export.h"
@@ skipping 198 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));
+    WriteBytesStatic<sizeof(value)>(&value);
+    return true;
   }
   // WARNING: DO NOT USE THIS METHOD IF PICKLES ARE PERSISTED IN ANY WAY.
   // It will write 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.
   bool WriteLongUsingDangerousNonPortableLessPersistableForm(long value) {
-    return WriteBytes(&value, sizeof(value));
+    WriteBytesStatic<sizeof(value)>(&value);
+    return true;
   }
   bool WriteUInt16(uint16 value) {
-    return WriteBytes(&value, sizeof(value));
+    WriteBytesStatic<sizeof(value)>(&value);
+    return true;
   }
   bool WriteUInt32(uint32 value) {
-    return WriteBytes(&value, sizeof(value));
+    WriteBytesStatic<sizeof(value)>(&value);
+    return true;
   }
   bool WriteInt64(int64 value) {
-    return WriteBytes(&value, sizeof(value));
+    WriteBytesStatic<sizeof(value)>(&value);
+    return true;
   }
   bool WriteUInt64(uint64 value) {
-    return WriteBytes(&value, sizeof(value));
+    WriteBytesStatic<sizeof(value)>(&value);
+    return true;
   }
   bool WriteFloat(float value) {
-    return WriteBytes(&value, sizeof(value));
+    WriteBytesStatic<sizeof(value)>(&value);
+    return true;
   }
   bool WriteString(const std::string& value);
   bool WriteWString(const std::wstring& value);
   bool WriteString16(const string16& value);
   // "Data" is a blob with a length. When you read it out you will be given the
   // length. See also WriteBytes.
   bool WriteData(const char* data, int length);
   // "Bytes" is a blob with no length. The caller must specify the lenght both
   // when reading and writing. It is normally used to serialize PoD types of a
   // known size. See also WriteData.
@@ skipping 13 matching lines @@
   // with BeginWriteData), the Pickle can
   // be 'trimmed' if the amount of data required is less than originally
   // requested.  For example, you may have created a buffer with 10K of data,
   // but decided to only fill 10 bytes of that data.  Use this function
   // to trim the buffer so that we don't send 9990 bytes of unused data.
   // You cannot increase the size of the variable buffer; only shrink it.
   // This function assumes that the length of the variable buffer has
   // not been changed.
   void TrimWriteData(int length);
 
+  void Reserve(size_t size);
+
   // Payload follows after allocation of Header (header size is customizable).
   struct Header {
     uint32 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() {
@@ skipping 61 matching lines @@
   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).
   size_t capacity_;
   size_t variable_buffer_offset_;  // IF non-zero, then offset to a buffer.
+  size_t offset_;
+
+  template<size_t length> void WriteBytesStatic(const void* data);
 
   FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
 };
 
+#if 0
+template <size_t length> void Pickle::WriteBytesStatic(const void* data) {
+  //DCHECK_NE(kCapacityReadOnly, capacity_) << "oops: pickle is readonly";
+#ifdef ARCH_CPU_64_BITS
+  DCHECK_LE(length, kuint32max);

[danakj, 2013/10/22 17:22:05]

how come? and why ifdefed only on 64bit?

[piman, 2013/10/24 06:17:14]

This comes from the original BeginWriteData.
I assume the ifdef is because the DCHECK is always true on 32 bits.

+#endif
+  size_t data_len = AlignInt(length, sizeof(uint32));
+  size_t new_size = offset_ + data_len;
+  if (new_size > capacity_) {
+    Resize(std::max(capacity_ * 2, new_size));
+  }
+
+  char* write = mutable_payload() + offset_;
+  memcpy(write, data, length);
+  memset(write + length, 0, data_len - length);
+  offset_ = new_size;
+  header_->payload_size = new_size;
+}
+#endif
+
 #endif  // BASE_PICKLE_H__