C++11 declares a type safe null pointer

content/common/page_state_serialization.cc

 // Copyright 2013 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 "content/common/page_state_serialization.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/pickle.h"
@@ skipping 197 matching lines @@
 void WriteData(const void* data, int length, SerializeObject* obj) {
   obj->pickle.WriteData(static_cast<const char*>(data), length);
 }
 
 void ReadData(SerializeObject* obj, const void** data, int* length) {
   const char* tmp;
   if (obj->pickle.ReadData(&obj->iter, &tmp, length)) {
     *data = tmp;
   } else {
     obj->parse_error = true;
-    *data = NULL;
+    *data = nullptr;
     *length = 0;
   }
 }
 
 void WriteInteger(int data, SerializeObject* obj) {
   obj->pickle.WriteInt(data);
 }
 
 int ReadInteger(SerializeObject* obj) {
   int tmp;
@@ skipping 13 matching lines @@
     return tmp;
   obj->parse_error = true;
   return 0;
 }
 
 void WriteReal(double data, SerializeObject* obj) {
   WriteData(&data, sizeof(double), obj);
 }
 
 double ReadReal(SerializeObject* obj) {
-  const void* tmp = NULL;
+  const void* tmp = nullptr;
   int length = 0;
   double value = 0.0;
   ReadData(obj, &tmp, &length);
   if (length == static_cast<int>(sizeof(double))) {
     // Use memcpy, as tmp may not be correctly aligned.
     memcpy(&value, tmp, sizeof(double));
   } else {
     obj->parse_error = true;
   }
   return value;
@@ skipping 46 matching lines @@
     size_t length_in_bytes = str.string().length() * sizeof(base::char16);
 
     CHECK_LT(length_in_bytes,
              static_cast<size_t>(std::numeric_limits<int>::max()));
     obj->pickle.WriteInt(length_in_bytes);
     obj->pickle.WriteBytes(data, length_in_bytes);
   }
 }
 
 // This reads a serialized NullableString16 from obj. If a string can't be
-// read, NULL is returned.
+// read, nullptr is returned.
 const base::char16* ReadStringNoCopy(SerializeObject* obj, int* num_chars) {
   int length_in_bytes;
   if (!obj->pickle.ReadInt(&obj->iter, &length_in_bytes)) {
     obj->parse_error = true;
-    return NULL;
+    return nullptr;
   }
 
   if (length_in_bytes < 0)
-    return NULL;
+    return nullptr;
 
   const char* data;
   if (!obj->pickle.ReadBytes(&obj->iter, &data, length_in_bytes)) {
     obj->parse_error = true;
-    return NULL;
+    return nullptr;
   }
 
   if (num_chars)
     *num_chars = length_in_bytes / sizeof(base::char16);
   return reinterpret_cast<const base::char16*>(data);
 }
 
 base::NullableString16 ReadString(SerializeObject* obj) {
   int num_chars;
   const base::char16* chars = ReadStringNoCopy(obj, &num_chars);
@@ skipping 397 matching lines @@
     float device_scale_factor,
     ExplodedPageState* exploded) {
   g_device_scale_factor_for_testing = device_scale_factor;
   bool rv = DecodePageState(encoded, exploded);
   g_device_scale_factor_for_testing = 0.0;
   return rv;
 }
 #endif
 
 }  // namespace content