Get rid of NULLs in core/

core/fxge/win32/fx_win32_dwrite.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fxge/include/fx_ge.h"
 
 #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_DESKTOP_
 #include <dwrite.h>
 
 #include "core/fxge/include/fx_ge_win32.h"
 #include "core/fxge/win32/dwrite_int.h"
 
 typedef HRESULT(__stdcall* FuncType_DWriteCreateFactory)(
     __in DWRITE_FACTORY_TYPE,
     __in REFIID,
     __out IUnknown**);
 template <typename InterfaceType>
 inline void SafeRelease(InterfaceType** currentObject) {
   if (*currentObject) {
     (*currentObject)->Release();
-    *currentObject = NULL;
+    *currentObject = nullptr;
   }
 }
 template <typename InterfaceType>
 inline InterfaceType* SafeAcquire(InterfaceType* newObject) {
   if (newObject) {
     newObject->AddRef();
   }
   return newObject;
 }
 class CDwFontFileStream final : public IDWriteFontFileStream {
  public:
   explicit CDwFontFileStream(void const* fontFileReferenceKey,
                              UINT32 fontFileReferenceKeySize);
   virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid,
                                                    void** ppvObject);
   virtual ULONG STDMETHODCALLTYPE AddRef();
   virtual ULONG STDMETHODCALLTYPE Release();
   virtual HRESULT STDMETHODCALLTYPE
   ReadFileFragment(void const** fragmentStart,
                    UINT64 fileOffset,
                    UINT64 fragmentSize,
                    OUT void** fragmentContext);
   virtual void STDMETHODCALLTYPE ReleaseFileFragment(void* fragmentContext);
   virtual HRESULT STDMETHODCALLTYPE GetFileSize(OUT UINT64* fileSize);
   virtual HRESULT STDMETHODCALLTYPE GetLastWriteTime(OUT UINT64* lastWriteTime);
-  bool IsInitialized() { return resourcePtr_ != NULL; }
+  bool IsInitialized() { return !!resourcePtr_; }
 
  private:
   ULONG refCount_;
   void const* resourcePtr_;
   DWORD resourceSize_;
 };
 class CDwFontFileLoader final : public IDWriteFontFileLoader {
  public:
   virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid,
                                                    void** ppvObject);
   virtual ULONG STDMETHODCALLTYPE AddRef();
   virtual ULONG STDMETHODCALLTYPE Release();
   virtual HRESULT STDMETHODCALLTYPE
   CreateStreamFromKey(void const* fontFileReferenceKey,
                       UINT32 fontFileReferenceKeySize,
                       OUT IDWriteFontFileStream** fontFileStream);
 
   static IDWriteFontFileLoader* GetLoader() {
     if (!instance_) {
       instance_ = new CDwFontFileLoader();
     }
     return instance_;
   }
-  static bool IsLoaderInitialized() { return instance_ != NULL; }
+  static bool IsLoaderInitialized() { return !!instance_; }
 
  private:
   CDwFontFileLoader();
   ULONG refCount_;
   static IDWriteFontFileLoader* instance_;
 };
 class CDwFontContext {
  public:
   CDwFontContext(IDWriteFactory* dwriteFactory);
   ~CDwFontContext();
@@ skipping 19 matching lines @@
                                          DWRITE_MEASURING_MODE measuringMode,
                                          __in DWRITE_GLYPH_RUN const* glyphRun,
                                          const COLORREF& textColor);
 
  private:
   CFX_DIBitmap* pBitmap_;
   IDWriteBitmapRenderTarget* pRenderTarget_;
   IDWriteRenderingParams* pRenderingParams_;
 };
 CDWriteExt::CDWriteExt() {
-  m_hModule = NULL;
-  m_pDWriteFactory = NULL;
-  m_pDwFontContext = NULL;
-  m_pDwTextRenderer = NULL;
+  m_hModule = nullptr;
+  m_pDWriteFactory = nullptr;
+  m_pDwFontContext = nullptr;
+  m_pDwTextRenderer = nullptr;
 }
 void CDWriteExt::Load() {}
 void CDWriteExt::Unload() {
   if (m_pDwFontContext) {
     delete (CDwFontContext*)m_pDwFontContext;
-    m_pDwFontContext = NULL;
+    m_pDwFontContext = nullptr;
   }
   SafeRelease((IDWriteFactory**)&m_pDWriteFactory);
 }
 CDWriteExt::~CDWriteExt() {
   Unload();
 }
 LPVOID CDWriteExt::DwCreateFontFaceFromStream(uint8_t* pData,
                                               uint32_t size,
                                               int simulation_style) {
   IDWriteFactory* pDwFactory = (IDWriteFactory*)m_pDWriteFactory;
-  IDWriteFontFile* pDwFontFile = NULL;
-  IDWriteFontFace* pDwFontFace = NULL;
+  IDWriteFontFile* pDwFontFile = nullptr;
+  IDWriteFontFace* pDwFontFace = nullptr;
   BOOL isSupportedFontType = FALSE;
   DWRITE_FONT_FILE_TYPE fontFileType;
   DWRITE_FONT_FACE_TYPE fontFaceType;
   UINT32 numberOfFaces;
   DWRITE_FONT_SIMULATIONS fontStyle =
       (DWRITE_FONT_SIMULATIONS)(simulation_style & 3);
   HRESULT hr = S_OK;
   hr = pDwFactory->CreateCustomFontFileReference(
       (void const*)pData, (UINT32)size, CDwFontFileLoader::GetLoader(),
       &pDwFontFile);
   if (FAILED(hr)) {
     goto failed;
   }
   hr = pDwFontFile->Analyze(&isSupportedFontType, &fontFileType, &fontFaceType,
                             &numberOfFaces);
   if (FAILED(hr) || !isSupportedFontType ||
       fontFaceType == DWRITE_FONT_FACE_TYPE_UNKNOWN) {
     goto failed;
   }
   hr = pDwFactory->CreateFontFace(fontFaceType, 1, &pDwFontFile, 0, fontStyle,
                                   &pDwFontFace);
   if (FAILED(hr)) {
     goto failed;
   }
   SafeRelease(&pDwFontFile);
   return pDwFontFace;
 failed:
   SafeRelease(&pDwFontFile);
-  return NULL;
+  return nullptr;
 }
 FX_BOOL CDWriteExt::DwCreateRenderingTarget(CFX_DIBitmap* pBitmap,
                                             void** renderTarget) {
   if (pBitmap->GetFormat() > FXDIB_Argb) {
     return FALSE;
   }
   IDWriteFactory* pDwFactory = (IDWriteFactory*)m_pDWriteFactory;
-  IDWriteGdiInterop* pGdiInterop = NULL;
-  IDWriteBitmapRenderTarget* pBitmapRenderTarget = NULL;
-  IDWriteRenderingParams* pRenderingParams = NULL;
+  IDWriteGdiInterop* pGdiInterop = nullptr;
+  IDWriteBitmapRenderTarget* pBitmapRenderTarget = nullptr;
+  IDWriteRenderingParams* pRenderingParams = nullptr;
   HRESULT hr = S_OK;
   hr = pDwFactory->GetGdiInterop(&pGdiInterop);
   if (FAILED(hr)) {
     goto failed;
   }
   hr = pGdiInterop->CreateBitmapRenderTarget(
-      NULL, pBitmap->GetWidth(), pBitmap->GetHeight(), &pBitmapRenderTarget);
+      nullptr, pBitmap->GetWidth(), pBitmap->GetHeight(), &pBitmapRenderTarget);
   if (FAILED(hr)) {
     goto failed;
   }
   hr = pDwFactory->CreateCustomRenderingParams(
       1.0f, 0.0f, 1.0f, DWRITE_PIXEL_GEOMETRY_RGB,
       DWRITE_RENDERING_MODE_DEFAULT, &pRenderingParams);
   if (FAILED(hr)) {
     goto failed;
   }
   hr = pBitmapRenderTarget->SetPixelsPerDip(1.0f);
@@ skipping 42 matching lines @@
   }
   glyphRun.fontFace = (IDWriteFontFace*)font;
   glyphRun.fontEmSize = font_size;
   glyphRun.glyphCount = glyph_count;
   glyphRun.glyphIndices = glyph_indices;
   glyphRun.glyphAdvances = glyph_advances;
   glyphRun.glyphOffsets = (DWRITE_GLYPH_OFFSET*)glyph_offsets;
   glyphRun.isSideways = FALSE;
   glyphRun.bidiLevel = 0;
   hr = pTextRenderer->DrawGlyphRun(
-      stringRect, pClipRgn, pMatrix ? &transform : NULL, baselineOriginX,
+      stringRect, pClipRgn, pMatrix ? &transform : nullptr, baselineOriginX,
       baselineOriginY, DWRITE_MEASURING_MODE_NATURAL, &glyphRun,
       RGB(FXARGB_R(text_color), FXARGB_G(text_color), FXARGB_B(text_color)));
   return SUCCEEDED(hr);
 }
 void CDWriteExt::DwDeleteRenderingTarget(void* renderTarget) {
   delete (CDwGdiTextRenderer*)renderTarget;
 }
 void CDWriteExt::DwDeleteFont(void* pFont) {
   if (pFont) {
     SafeRelease((IDWriteFontFace**)&pFont);
   }
 }
 CDwFontFileStream::CDwFontFileStream(void const* fontFileReferenceKey,
                                      UINT32 fontFileReferenceKeySize) {
   refCount_ = 0;
   resourcePtr_ = fontFileReferenceKey;
   resourceSize_ = fontFileReferenceKeySize;
 }
 HRESULT STDMETHODCALLTYPE CDwFontFileStream::QueryInterface(REFIID iid,
                                                             void** ppvObject) {
   if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontFileStream)) {
     *ppvObject = this;
     AddRef();
     return S_OK;
   }
-  *ppvObject = NULL;
+  *ppvObject = nullptr;
   return E_NOINTERFACE;
 }
 ULONG STDMETHODCALLTYPE CDwFontFileStream::AddRef() {
   return InterlockedIncrement((long*)(&refCount_));
 }
 ULONG STDMETHODCALLTYPE CDwFontFileStream::Release() {
   ULONG newCount = InterlockedDecrement((long*)(&refCount_));
   if (newCount == 0) {
     delete this;
   }
   return newCount;
 }
 HRESULT STDMETHODCALLTYPE
 CDwFontFileStream::ReadFileFragment(void const** fragmentStart,
                                     UINT64 fileOffset,
                                     UINT64 fragmentSize,
                                     OUT void** fragmentContext) {
   if (fileOffset <= resourceSize_ &&
       fragmentSize <= resourceSize_ - fileOffset) {
     *fragmentStart = static_cast<uint8_t const*>(resourcePtr_) +
                      static_cast<size_t>(fileOffset);
-    *fragmentContext = NULL;
+    *fragmentContext = nullptr;
     return S_OK;
   }
-  *fragmentStart = NULL;
-  *fragmentContext = NULL;
+  *fragmentStart = nullptr;
+  *fragmentContext = nullptr;
   return E_FAIL;
 }
 void STDMETHODCALLTYPE
 CDwFontFileStream::ReleaseFileFragment(void* fragmentContext) {}
 HRESULT STDMETHODCALLTYPE CDwFontFileStream::GetFileSize(OUT UINT64* fileSize) {
   *fileSize = resourceSize_;
   return S_OK;
 }
 HRESULT STDMETHODCALLTYPE
 CDwFontFileStream::GetLastWriteTime(OUT UINT64* lastWriteTime) {
   *lastWriteTime = 0;
   return E_NOTIMPL;
 }
-IDWriteFontFileLoader* CDwFontFileLoader::instance_ = NULL;
+IDWriteFontFileLoader* CDwFontFileLoader::instance_ = nullptr;
 CDwFontFileLoader::CDwFontFileLoader() : refCount_(0) {}
 HRESULT STDMETHODCALLTYPE CDwFontFileLoader::QueryInterface(REFIID iid,
                                                             void** ppvObject) {
   if (iid == IID_IUnknown || iid == __uuidof(IDWriteFontFileLoader)) {
     *ppvObject = this;
     AddRef();
     return S_OK;
   }
-  *ppvObject = NULL;
+  *ppvObject = nullptr;
   return E_NOINTERFACE;
 }
 ULONG STDMETHODCALLTYPE CDwFontFileLoader::AddRef() {
   return InterlockedIncrement((long*)(&refCount_));
 }
 ULONG STDMETHODCALLTYPE CDwFontFileLoader::Release() {
   ULONG newCount = InterlockedDecrement((long*)(&refCount_));
   if (newCount == 0) {
-    instance_ = NULL;
+    instance_ = nullptr;
     delete this;
   }
   return newCount;
 }
 HRESULT STDMETHODCALLTYPE CDwFontFileLoader::CreateStreamFromKey(
     void const* fontFileReferenceKey,
     UINT32 fontFileReferenceKeySize,
     OUT IDWriteFontFileStream** fontFileStream) {
-  *fontFileStream = NULL;
+  *fontFileStream = nullptr;
   CDwFontFileStream* stream =
       new CDwFontFileStream(fontFileReferenceKey, fontFileReferenceKeySize);
   if (!stream->IsInitialized()) {
     delete stream;
     return E_FAIL;
   }
   *fontFileStream = SafeAcquire(stream);
   return S_OK;
 }
 CDwFontContext::CDwFontContext(IDWriteFactory* dwriteFactory)
@@ skipping 41 matching lines @@
   HDC hDC = pRenderTarget_->GetMemoryDC();
   HBITMAP hBitmap = (HBITMAP)::GetCurrentObject(hDC, OBJ_BITMAP);
   BITMAP bitmap;
   GetObject(hBitmap, sizeof bitmap, &bitmap);
   CFX_DIBitmap dib;
   dib.Create(bitmap.bmWidth, bitmap.bmHeight,
              bitmap.bmBitsPixel == 24 ? FXDIB_Rgb : FXDIB_Rgb32,
              (uint8_t*)bitmap.bmBits);
   dib.CompositeBitmap(text_bbox.left, text_bbox.top, text_bbox.Width(),
                       text_bbox.Height(), pBitmap_, text_bbox.left,
-                      text_bbox.top, FXDIB_BLEND_NORMAL, NULL);
+                      text_bbox.top, FXDIB_BLEND_NORMAL, nullptr);
   hr = pRenderTarget_->DrawGlyphRun(baselineOriginX, baselineOriginY,
                                     measuringMode, glyphRun, pRenderingParams_,
                                     textColor);
   if (FAILED(hr)) {
     return hr;
   }
   pBitmap_->CompositeBitmap(text_bbox.left, text_bbox.top, text_bbox.Width(),
                             text_bbox.Height(), &dib, text_bbox.left,
                             text_bbox.top, FXDIB_BLEND_NORMAL, pClipRgn);
   return hr;
 }
 #endif