C++11 declares a type safe null pointer

content/common/font_cache_dispatcher_win.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/font_cache_dispatcher_win.h"
 
 #include <map>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 12 matching lines @@
   }
 
   void PreCacheFont(const LOGFONT& font, FontCacheDispatcher* dispatcher) {
     typedef std::map<base::string16, FontCache::CacheElement> FontNameToElement;
 
     base::AutoLock lock(mutex_);
 
     // Fetch the font into memory.
     // No matter the font is cached or not, we load it to avoid GDI swapping out
     // that font file.
-    HDC hdc = GetDC(NULL);
+    HDC hdc = GetDC(nullptr);
     HFONT font_handle = CreateFontIndirect(&font);
-    DCHECK(NULL != font_handle);
+    DCHECK(nullptr != font_handle);
 
     HGDIOBJ old_font = SelectObject(hdc, font_handle);
-    DCHECK(NULL != old_font);
+    DCHECK(nullptr != old_font);
 
     TEXTMETRIC tm;
     BOOL ret = GetTextMetrics(hdc, &tm);
     DCHECK(ret);
 
     base::string16 font_name = font.lfFaceName;
     int ref_count_inc = 1;
     FontNameVector::iterator it =
         std::find(dispatcher_font_map_[dispatcher].begin(),
                   dispatcher_font_map_[dispatcher].end(),
                   font_name);
     if (it == dispatcher_font_map_[dispatcher].end()) {
       // Requested font is new to cache.
       dispatcher_font_map_[dispatcher].push_back(font_name);
     } else {
       ref_count_inc = 0;
     }
 
     if (cache_[font_name].ref_count_ == 0) {  // Requested font is new to cache.
       cache_[font_name].ref_count_ = 1;
     } else {  // Requested font is already in cache, release old handles.
       SelectObject(cache_[font_name].dc_, cache_[font_name].old_font_);
       DeleteObject(cache_[font_name].font_);
-      ReleaseDC(NULL, cache_[font_name].dc_);
+      ReleaseDC(nullptr, cache_[font_name].dc_);
     }
     cache_[font_name].font_ = font_handle;
     cache_[font_name].dc_ = hdc;
     cache_[font_name].old_font_ = old_font;
     cache_[font_name].ref_count_ += ref_count_inc;
   }
 
   void ReleaseCachedFonts(FontCacheDispatcher* dispatcher) {
     typedef std::map<base::string16, FontCache::CacheElement> FontNameToElement;
 
@@ skipping 20 matching lines @@
         cache_.erase(i++);
       } else {
         ++i;
       }
     }
   }
 
  private:
   struct CacheElement {
     CacheElement()
-        : font_(NULL), old_font_(NULL), dc_(NULL), ref_count_(0) {
+        : font_(nullptr), old_font_(nullptr), dc_(nullptr), ref_count_(0) {
     }
 
     ~CacheElement() {
       if (font_) {
         if (dc_ && old_font_) {
           SelectObject(dc_, old_font_);
         }
         DeleteObject(font_);
       }
       if (dc_) {
-        ReleaseDC(NULL, dc_);
+        ReleaseDC(nullptr, dc_);
       }
     }
 
     HFONT font_;
     HGDIOBJ old_font_;
     HDC dc_;
     int ref_count_;
   };
   friend struct DefaultSingletonTraits<FontCache>;
 
   FontCache() {
   }
 
   std::map<base::string16, CacheElement> cache_;
   DispatcherToFontNames dispatcher_font_map_;
   base::Lock mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(FontCache);
 };
 
 }
 
 FontCacheDispatcher::FontCacheDispatcher()
-    : sender_(NULL) {
+    : sender_(nullptr) {
 }
 
 FontCacheDispatcher::~FontCacheDispatcher() {
 }
 
 void FontCacheDispatcher::OnFilterAdded(IPC::Sender* sender) {
   sender_ = sender;
 }
 
 bool FontCacheDispatcher::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(FontCacheDispatcher, message)
     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_PreCacheFont, OnPreCacheFont)
     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ReleaseCachedFonts,
                         OnReleaseCachedFonts)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void FontCacheDispatcher::OnChannelClosing() {
-  sender_ = NULL;
+  sender_ = nullptr;
 }
 
 bool FontCacheDispatcher::Send(IPC::Message* message) {
   if (sender_)
     return sender_->Send(message);
 
   delete message;
   return false;
 }
 
@@ skipping 14 matching lines @@
   FontCache::GetInstance()->PreCacheFont(font, this);
 }
 
 void FontCacheDispatcher::OnReleaseCachedFonts() {
   // Release cached fonts that requested from a pid by decrementing the ref
   // count.  When ref count is zero, the handles are released.
   FontCache::GetInstance()->ReleaseCachedFonts(this);
 }
 
 }  // namespace content