Bug 1387134 - out-of-line type-specific Pickle::Write* methods; r=billm

Having these functions declared in the class definition and therefore
inlined means that every call site is bloated by having to store the
argument so its address can be taken and load the sizeof() constant.
There's no good reason that we should be doing this; the Read*
counterparts are also out-of-lined, which hasn't seemed to cause any
problems.  Moving these out-of-line saves about 200K (!) of space on
x86-64 Linux.

ipc/chromium/src/base/pickle.cc

@@ -524,6 +524,109 @@ void Pickle::EndWrite(uint32_t length) {
   }
 }
 
+bool Pickle::WriteBool(bool value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzBool(&value);
+#endif
+  return WriteInt(value ? 1 : 0);
+}
+
+bool Pickle::WriteInt16(int16_t value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzInt16(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteUInt16(uint16_t value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt16(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteInt(int value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzInt(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteLong(long value) {
+  // Always written as a 64-bit value since the size for this type can
+  // differ between architectures.
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzLong(&value);
+#endif
+  return WriteInt64(int64_t(value));
+}
+
+bool Pickle::WriteULong(unsigned long value) {
+  // Always written as a 64-bit value since the size for this type can
+  // differ between architectures.
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzULong(&value);
+#endif
+  return WriteUInt64(uint64_t(value));
+}
+
+bool Pickle::WriteSize(size_t value) {
+  // Always written as a 64-bit value since the size for this type can
+  // differ between architectures.
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzSize(&value);
+#endif
+  return WriteUInt64(uint64_t(value));
+}
+
+bool Pickle::WriteInt32(int32_t value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzInt(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteUInt32(uint32_t value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt32(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteInt64(int64_t value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzInt64(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteUInt64(uint64_t value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt64(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteDouble(double value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzDouble(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
+bool Pickle::WriteIntPtr(intptr_t value) {
+  // Always written as a 64-bit value since the size for this type can
+  // differ between architectures.
+  return WriteInt64(int64_t(value));
+}
+
+bool Pickle::WriteUnsignedChar(unsigned char value) {
+#ifdef FUZZING
+  Singleton<mozilla::ipc::Faulty>::get()->FuzzUChar(&value);
+#endif
+  return WriteBytes(&value, sizeof(value));
+}
+
 bool Pickle::WriteBytes(const void* data, uint32_t data_len, uint32_t alignment) {
   DCHECK(alignment == 4 || alignment == 8);
   DCHECK(intptr_t(header_) % alignment == 0);

ipc/chromium/src/base/pickle.h

@@ -143,95 +143,20 @@ class Pickle {
   // 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) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzBool(&value);
-#endif
-    return WriteInt(value ? 1 : 0);
-  }
-  bool WriteInt16(int16_t value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzInt16(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteUInt16(uint16_t value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt16(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteInt(int value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzInt(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteLong(long value) {
-    // Always written as a 64-bit value since the size for this type can
-    // differ between architectures.
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzLong(&value);
-#endif
-    return WriteInt64(int64_t(value));
-  }
-  bool WriteULong(unsigned long value) {
-    // Always written as a 64-bit value since the size for this type can
-    // differ between architectures.
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzULong(&value);
-#endif
-    return WriteUInt64(uint64_t(value));
-  }
-  bool WriteSize(size_t value) {
-    // Always written as a 64-bit value since the size for this type can
-    // differ between architectures.
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzSize(&value);
-#endif
-    return WriteUInt64(uint64_t(value));
-  }
-  bool WriteInt32(int32_t value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzInt(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteUInt32(uint32_t value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt32(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteInt64(int64_t value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzInt64(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteUInt64(uint64_t value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt64(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteDouble(double value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzDouble(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteIntPtr(intptr_t value) {
-    // Always written as a 64-bit value since the size for this type can
-    // differ between architectures.
-    return WriteInt64(int64_t(value));
-  }
-  bool WriteUnsignedChar(unsigned char value) {
-#ifdef FUZZING
-    Singleton<mozilla::ipc::Faulty>::get()->FuzzUChar(&value);
-#endif
-    return WriteBytes(&value, sizeof(value));
-  }
+  bool WriteBool(bool value);
+  bool WriteInt16(int16_t value);
+  bool WriteUInt16(uint16_t value);
+  bool WriteInt(int value);
+  bool WriteLong(long value);
+  bool WriteULong(unsigned long value);
+  bool WriteSize(size_t value);
+  bool WriteInt32(int32_t value);
+  bool WriteUInt32(uint32_t value);
+  bool WriteInt64(int64_t value);
+  bool WriteUInt64(uint64_t value);
+  bool WriteDouble(double value);
+  bool WriteIntPtr(intptr_t value);
+  bool WriteUnsignedChar(unsigned char value);
   bool WriteString(const std::string& value);
   bool WriteWString(const std::wstring& value);
   bool WriteData(const char* data, uint32_t length);