C++11 declares a type safe null pointer

content/common/cursors/webcursor.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 "content/common/cursors/webcursor.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "third_party/WebKit/public/platform/WebImage.h"
 
 using blink::WebCursorInfo;
 
 static const int kMaxCursorDimension = 1024;
 
 namespace content {
 
 WebCursor::WebCursor()
     : type_(WebCursorInfo::TypePointer),
       custom_scale_(1) {
 #if defined(OS_WIN)
-  external_cursor_ = NULL;
+  external_cursor_ = nullptr;
 #endif
   InitPlatformData();
 }
 
 WebCursor::WebCursor(const CursorInfo& cursor_info)
     : type_(WebCursorInfo::TypePointer) {
 #if defined(OS_WIN)
-  external_cursor_ = NULL;
+  external_cursor_ = nullptr;
 #endif
   InitPlatformData();
   InitFromCursorInfo(cursor_info);
 }
 
 WebCursor::~WebCursor() {
   Clear();
 }
 
 WebCursor::WebCursor(const WebCursor& other) {
@@ skipping 94 matching lines @@
 
 bool WebCursor::Serialize(Pickle* pickle) const {
   if (!pickle->WriteInt(type_) ||
       !pickle->WriteInt(hotspot_.x()) ||
       !pickle->WriteInt(hotspot_.y()) ||
       !pickle->WriteInt(custom_size_.width()) ||
       !pickle->WriteInt(custom_size_.height()) ||
       !pickle->WriteFloat(custom_scale_))
     return false;
 
-  const char* data = NULL;
+  const char* data = nullptr;
   if (!custom_data_.empty())
     data = &custom_data_[0];
   if (!pickle->WriteData(data, custom_data_.size()))
     return false;
 
   return SerializePlatformData(pickle);
 }
 
 bool WebCursor::IsCustom() const {
   return type_ == WebCursorInfo::TypeCustom;
@@ skipping 12 matching lines @@
          custom_data_ == other.custom_data_;
 }
 
 #if defined(OS_WIN)
 
 static WebCursorInfo::Type ToCursorType(HCURSOR cursor) {
   static struct {
     HCURSOR cursor;
     WebCursorInfo::Type type;
   } kStandardCursors[] = {
-    { LoadCursor(NULL, IDC_ARROW),       WebCursorInfo::TypePointer },
-    { LoadCursor(NULL, IDC_CROSS),       WebCursorInfo::TypeCross },
-    { LoadCursor(NULL, IDC_HAND),        WebCursorInfo::TypeHand },
-    { LoadCursor(NULL, IDC_IBEAM),       WebCursorInfo::TypeIBeam },
-    { LoadCursor(NULL, IDC_WAIT),        WebCursorInfo::TypeWait },
-    { LoadCursor(NULL, IDC_HELP),        WebCursorInfo::TypeHelp },
-    { LoadCursor(NULL, IDC_SIZENESW),    WebCursorInfo::TypeNorthEastResize },
-    { LoadCursor(NULL, IDC_SIZENWSE),    WebCursorInfo::TypeNorthWestResize },
-    { LoadCursor(NULL, IDC_SIZENS),      WebCursorInfo::TypeNorthSouthResize },
-    { LoadCursor(NULL, IDC_SIZEWE),      WebCursorInfo::TypeEastWestResize },
-    { LoadCursor(NULL, IDC_SIZEALL),     WebCursorInfo::TypeMove },
-    { LoadCursor(NULL, IDC_APPSTARTING), WebCursorInfo::TypeProgress },
-    { LoadCursor(NULL, IDC_NO),          WebCursorInfo::TypeNotAllowed },
+    { LoadCursor(nullptr, IDC_ARROW),       WebCursorInfo::TypePointer },
+    { LoadCursor(nullptr, IDC_CROSS),       WebCursorInfo::TypeCross },
+    { LoadCursor(nullptr, IDC_HAND),        WebCursorInfo::TypeHand },
+    { LoadCursor(nullptr, IDC_IBEAM),       WebCursorInfo::TypeIBeam },
+    { LoadCursor(nullptr, IDC_WAIT),        WebCursorInfo::TypeWait },
+    { LoadCursor(nullptr, IDC_HELP),        WebCursorInfo::TypeHelp },
+    { LoadCursor(nullptr, IDC_SIZENESW),
+      WebCursorInfo::TypeNorthEastResize },
+    { LoadCursor(nullptr, IDC_SIZENWSE),
+      WebCursorInfo::TypeNorthWestResize },
+    { LoadCursor(nullptr, IDC_SIZENS),
+      WebCursorInfo::TypeNorthSouthResize },
+    { LoadCursor(nullptr, IDC_SIZEWE),      WebCursorInfo::TypeEastWestResize },
+    { LoadCursor(nullptr, IDC_SIZEALL),     WebCursorInfo::TypeMove },
+    { LoadCursor(nullptr, IDC_APPSTARTING), WebCursorInfo::TypeProgress },
+    { LoadCursor(nullptr, IDC_NO),          WebCursorInfo::TypeNotAllowed },
   };
   for (int i = 0; i < arraysize(kStandardCursors); ++i) {
     if (cursor == kStandardCursors[i].cursor)
       return kStandardCursors[i].type;
   }
   return WebCursorInfo::TypeCustom;
 }
 
 void WebCursor::InitFromExternalCursor(HCURSOR cursor) {
   WebCursorInfo::Type cursor_type = ToCursorType(cursor);
@@ skipping 53 matching lines @@
     return;
 
   // Clamp the hotspot to the custom image's dimensions.
   hotspot_.set_x(std::max(0,
                           std::min(custom_size_.width() - 1, hotspot_.x())));
   hotspot_.set_y(std::max(0,
                           std::min(custom_size_.height() - 1, hotspot_.y())));
 }
 
 }  // namespace content