Style Change: NULL->nullptr

src/ports/SkImageDecoder_WIC.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 
@@ skipping 42 matching lines @@
     enum WICModes {
         kDecodeFormat_WICMode,
         kDecodeBounds_WICMode,
         kDecodePixels_WICMode,
     };
 
     /**
      *  Helper function to decode an SkStream.
      *  @param stream SkStream to decode. Must be at the beginning.
      *  @param bm   SkBitmap to decode into. Only used if wicMode is kDecodeBounds_WICMode or
-     *      kDecodePixels_WICMode, in which case it must not be NULL.
+     *      kDecodePixels_WICMode, in which case it must not be nullptr.
      *  @param format Out parameter for the SkImageDecoder::Format of the SkStream. Only used if
      *      wicMode is kDecodeFormat_WICMode.
      */
     bool decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode, Format* format) const;
 
 protected:
     Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) override;
 };
 
 struct FormatConversion {
@@ skipping 21 matching lines @@
 SkImageDecoder::Result SkImageDecoder_WIC::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     WICModes wicMode;
     switch (mode) {
         case SkImageDecoder::kDecodeBounds_Mode:
             wicMode = kDecodeBounds_WICMode;
             break;
         case SkImageDecoder::kDecodePixels_Mode:
             wicMode = kDecodePixels_WICMode;
             break;
     }
-    return this->decodeStream(stream, bm, wicMode, NULL) ? kSuccess : kFailure;
+    return this->decodeStream(stream, bm, wicMode, nullptr) ? kSuccess : kFailure;
 }
 
 bool SkImageDecoder_WIC::decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode,
                                       Format* format) const {
     //Initialize COM.
     SkAutoCoInitialize scopedCo;
     if (!scopedCo.succeeded()) {
         return false;
     }
 
     HRESULT hr = S_OK;
 
     //Create Windows Imaging Component ImagingFactory.
     SkTScopedComPtr<IWICImagingFactory> piImagingFactory;
     if (SUCCEEDED(hr)) {
         hr = CoCreateInstance(
             CLSID_WICImagingFactory
-            , NULL
+            , nullptr
             , CLSCTX_INPROC_SERVER
             , IID_PPV_ARGS(&piImagingFactory)
         );
     }
 
     //Convert SkStream to IStream.
     SkTScopedComPtr<IStream> piStream;
     if (SUCCEEDED(hr)) {
         hr = SkIStream::CreateFromSkStream(stream, false, &piStream);
     }
 
     //Make sure we're at the beginning of the stream.
     if (SUCCEEDED(hr)) {
         LARGE_INTEGER liBeginning = { 0 };
-        hr = piStream->Seek(liBeginning, STREAM_SEEK_SET, NULL);
+        hr = piStream->Seek(liBeginning, STREAM_SEEK_SET, nullptr);
     }
 
     //Create the decoder from the stream content.
     SkTScopedComPtr<IWICBitmapDecoder> piBitmapDecoder;
     if (SUCCEEDED(hr)) {
         hr = piImagingFactory->CreateDecoderFromStream(
             piStream.get()                    //Image to be decoded
-            , NULL                            //No particular vendor
+            , nullptr                            //No particular vendor
             , WICDecodeMetadataCacheOnDemand  //Cache metadata when needed
             , &piBitmapDecoder                //Pointer to the decoder
         );
     }
 
     if (kDecodeFormat_WICMode == wicMode) {
-        SkASSERT(format != NULL);
+        SkASSERT(format != nullptr);
         //Get the format
         if (SUCCEEDED(hr)) {
             GUID guidFormat;
             hr = piBitmapDecoder->GetContainerFormat(&guidFormat);
             if (SUCCEEDED(hr)) {
                 *format = GuidContainerFormat_to_Format(guidFormat);
                 return true;
             }
         }
         return false;
@@ skipping 19 matching lines @@
     if (SUCCEEDED(hr)) {
         hr = piBitmapSourceOriginal->GetSize(&width, &height);
     }
 
     //Exit early if we're only looking for the bitmap bounds.
     if (SUCCEEDED(hr)) {
         bm->setInfo(SkImageInfo::MakeN32Premul(width, height));
         if (kDecodeBounds_WICMode == wicMode) {
             return true;
         }
-        if (!this->allocPixelRef(bm, NULL)) {
+        if (!this->allocPixelRef(bm, nullptr)) {
             return false;
         }
     }
 
     //Create a format converter.
     SkTScopedComPtr<IWICFormatConverter> piFormatConverter;
     if (SUCCEEDED(hr)) {
         hr = piImagingFactory->CreateFormatConverter(&piFormatConverter);
     }
 
     GUID destinationPixelFormat;
     if (this->getRequireUnpremultipliedColors()) {
         destinationPixelFormat = GUID_WICPixelFormat32bppBGRA;
     } else {
         destinationPixelFormat = GUID_WICPixelFormat32bppPBGRA;
     }
 
     if (SUCCEEDED(hr)) {
         hr = piFormatConverter->Initialize(
             piBitmapSourceOriginal.get()      //Input bitmap to convert
             , destinationPixelFormat          //Destination pixel format
             , WICBitmapDitherTypeNone         //Specified dither patterm
-            , NULL                            //Specify a particular palette
+            , nullptr                            //Specify a particular palette
             , 0.f                             //Alpha threshold
             , WICBitmapPaletteTypeCustom      //Palette translation type
         );
     }
 
     //Get the BitmapSource interface of the format converter.
     SkTScopedComPtr<IWICBitmapSource> piBitmapSourceConverted;
     if (SUCCEEDED(hr)) {
         hr = piFormatConverter->QueryInterface(
             IID_PPV_ARGS(&piBitmapSourceConverted)
         );
     }
 
     //Copy the pixels into the bitmap.
     if (SUCCEEDED(hr)) {
         SkAutoLockPixels alp(*bm);
         bm->eraseColor(SK_ColorTRANSPARENT);
         const UINT stride = (UINT) bm->rowBytes();
         hr = piBitmapSourceConverted->CopyPixels(
-            NULL,                             //Get all the pixels
+            nullptr,                             //Get all the pixels
             stride,
             stride * height,
             reinterpret_cast<BYTE *>(bm->getPixels())
         );
 
         // Note: we don't need to premultiply here since we specified PBGRA
         if (SkBitmap::ComputeIsOpaque(*bm)) {
             bm->setAlphaType(kOpaque_SkAlphaType);
         }
     }
 
     return SUCCEEDED(hr);
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 extern SkImageDecoder* image_decoder_from_stream(SkStreamRewindable*);
 
 SkImageDecoder* SkImageDecoder::Factory(SkStreamRewindable* stream) {
     SkImageDecoder* decoder = image_decoder_from_stream(stream);
-    if (NULL == decoder) {
+    if (nullptr == decoder) {
         // If no image decoder specific to the stream exists, use SkImageDecoder_WIC.
         return new SkImageDecoder_WIC;
     } else {
         return decoder;
     }
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 SkMovie* SkMovie::DecodeStream(SkStreamRewindable* stream) {
-    return NULL;
+    return nullptr;
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 class SkImageEncoder_WIC : public SkImageEncoder {
 public:
     SkImageEncoder_WIC(Type t) : fType(t) {}
 
 protected:
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality);
@@ skipping 59 matching lines @@
         return false;
     }
 
     HRESULT hr = S_OK;
 
     //Create Windows Imaging Component ImagingFactory.
     SkTScopedComPtr<IWICImagingFactory> piImagingFactory;
     if (SUCCEEDED(hr)) {
         hr = CoCreateInstance(
             CLSID_WICImagingFactory
-            , NULL
+            , nullptr
             , CLSCTX_INPROC_SERVER
             , IID_PPV_ARGS(&piImagingFactory)
         );
     }
 
     //Convert the SkWStream to an IStream.
     SkTScopedComPtr<IStream> piStream;
     if (SUCCEEDED(hr)) {
         hr = SkWIStream::CreateFromSkWStream(stream, &piStream);
     }
 
     //Create an encode of the appropriate type.
     SkTScopedComPtr<IWICBitmapEncoder> piEncoder;
     if (SUCCEEDED(hr)) {
-        hr = piImagingFactory->CreateEncoder(type, NULL, &piEncoder);
+        hr = piImagingFactory->CreateEncoder(type, nullptr, &piEncoder);
     }
 
     if (SUCCEEDED(hr)) {
         hr = piEncoder->Initialize(piStream.get(), WICBitmapEncoderNoCache);
     }
 
     //Create a the frame.
     SkTScopedComPtr<IWICBitmapFrameEncode> piBitmapFrameEncode;
     SkTScopedComPtr<IPropertyBag2> piPropertybag;
     if (SUCCEEDED(hr)) {
@@ skipping 64 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkImageEncoder* sk_imageencoder_wic_factory(SkImageEncoder::Type t) {
     switch (t) {
         case SkImageEncoder::kBMP_Type:
         case SkImageEncoder::kICO_Type:
         case SkImageEncoder::kJPEG_Type:
         case SkImageEncoder::kPNG_Type:
             break;
         default:
-            return NULL;
+            return nullptr;
     }
     return new SkImageEncoder_WIC(t);
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_imageencoder_wic_factory);
 
 static SkImageDecoder::Format get_format_wic(SkStreamRewindable* stream) {
     SkImageDecoder::Format format;
     SkImageDecoder_WIC codec;
-    if (!codec.decodeStream(stream, NULL, SkImageDecoder_WIC::kDecodeFormat_WICMode, &format)) {
+    if (!codec.decodeStream(stream, nullptr, SkImageDecoder_WIC::kDecodeFormat_WICMode, &format)) {
         format = SkImageDecoder::kUnknown_Format;
     }
     return format;
 }
 
 static SkImageDecoder_FormatReg gFormatReg(get_format_wic);