Style Change: NULL->nullptr

src/views/animated/SkImageView.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 "SkImageView.h"
 #include "SkAnimator.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkImageDecoder.h"
 #include "SkMatrix.h"
 #include "SkSystemEventTypes.h"
 #include "SkTime.h"
 
 SkImageView::SkImageView()
 {
-    fMatrix        = NULL;
+    fMatrix        = nullptr;
     fScaleType    = kMatrix_ScaleType;
 
-    fData.fAnim    = NULL;        // handles initializing the other union values
+    fData.fAnim    = nullptr;        // handles initializing the other union values
     fDataIsAnim    = true;
 
     fUriIsValid    = false;    // an empty string is not valid
 }
 
 SkImageView::~SkImageView()
 {
     if (fMatrix)
         sk_free(fMatrix);
 
@@ skipping 25 matching lines @@
 }
 
 void SkImageView::setScaleType(ScaleType st)
 {
     SkASSERT((unsigned)st <= kFitEnd_ScaleType);
 
     if ((ScaleType)fScaleType != st)
     {
         fScaleType = SkToU8(st);
         if (fUriIsValid)
-            this->inval(NULL);
+            this->inval(nullptr);
     }
 }
 
 bool SkImageView::getImageMatrix(SkMatrix* matrix) const
 {
     if (fMatrix)
     {
         SkASSERT(!fMatrix->isIdentity());
         if (matrix)
             *matrix = *fMatrix;
         return true;
     }
     else
     {
         if (matrix)
             matrix->reset();
         return false;
     }
 }
 
 void SkImageView::setImageMatrix(const SkMatrix* matrix)
 {
     bool changed = false;
 
     if (matrix && !matrix->isIdentity())
     {
-        if (fMatrix == NULL)
+        if (fMatrix == nullptr)
             fMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix));
         *fMatrix = *matrix;
         changed = true;
     }
     else    // set us to identity
     {
         if (fMatrix)
         {
             SkASSERT(!fMatrix->isIdentity());
             sk_free(fMatrix);
-            fMatrix = NULL;
+            fMatrix = nullptr;
             changed = true;
         }
     }
 
     // only redraw if we changed our matrix and we're not in scaleToFit mode
     if (changed && this->getScaleType() == kMatrix_ScaleType && fUriIsValid)
-        this->inval(NULL);
+        this->inval(nullptr);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 bool SkImageView::onEvent(const SkEvent& evt)
 {
     if (evt.isType(SK_EventType_Inval))
     {
         if (fUriIsValid)
-            this->inval(NULL);
+            this->inval(nullptr);
         return true;
     }
     return this->INHERITED::onEvent(evt);
 }
 
 static inline SkMatrix::ScaleToFit scaleTypeToScaleToFit(SkImageView::ScaleType st)
 {
     SkASSERT(st != SkImageView::kMatrix_ScaleType);
     SkASSERT((unsigned)st <= SkImageView::kFitEnd_ScaleType);
 
@@ skipping 33 matching lines @@
 
     if (fDataIsAnim)
     {
         SkMSec    now = SkTime::GetMSecs();
 
         SkAnimator::DifferenceType diff = fData.fAnim->draw(canvas, &paint, now);
 
 SkDEBUGF(("SkImageView : now = %X[%12.3f], diff = %d\n", now, now/1000., diff));
 
         if (diff == SkAnimator::kDifferent)
-            this->inval(NULL);
+            this->inval(nullptr);
         else if (diff == SkAnimator::kPartiallyDifferent)
         {
             SkRect    bounds;
             fData.fAnim->getInvalBounds(&bounds);
             matrix.mapRect(&bounds);    // get the bounds into view coordinates
             this->inval(&bounds);
         }
     }
     else
         canvas->drawBitmap(*fData.fBitmap, 0, 0, &paint);
@@ skipping 12 matching lines @@
         this->setScaleType((ScaleType)index);
 
     // need inflate syntax/reader for matrix
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 
 void SkImageView::onUriChange()
 {
     if (this->freeData())
-        this->inval(NULL);
+        this->inval(nullptr);
     fUriIsValid = true;        // give ensureUriIsLoaded() a shot at the new uri
 }
 
 bool SkImageView::freeData()
 {
     if (fData.fAnim)    // test is valid for all union values
     {
         if (fDataIsAnim)
             delete fData.fAnim;
         else
             delete fData.fBitmap;
 
-        fData.fAnim = NULL;    // valid for all union values
+        fData.fAnim = nullptr;    // valid for all union values
         return true;
     }
     return false;
 }
 
 bool SkImageView::getDataBounds(SkRect* bounds)
 {
     SkASSERT(bounds);
 
     if (this->ensureUriIsLoaded())
@@ skipping 59 matching lines @@
             return false;
         }
         fData.fBitmap = bitmap;
         fDataIsAnim = false;
     #else
         return false;
     #endif
     }
     return true;
 }