Style Change: NULL->nullptr

src/views/SkWindow.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 "SkWindow.h"
 #include "SkCanvas.h"
 #include "SkOSMenu.h"
 #include "SkSurface.h"
 #include "SkSystemEventTypes.h"
 #include "SkTime.h"
 
 #define SK_EventDelayInval "\xd" "n" "\xa" "l"
 
 SkWindow::SkWindow()
     : fSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType)
-    , fFocusView(NULL)
+    , fFocusView(nullptr)
 {
     fClicks.reset();
     fWaitingOnInval = false;
     fColorType = kN32_SkColorType;
     fMatrix.reset();
 }
 
 SkWindow::~SkWindow() {
     fClicks.deleteAll();
     fMenus.deleteAll();
 }
 
 SkSurface* SkWindow::createSurface() {
     const SkBitmap& bm = this->getBitmap();
     return SkSurface::NewRasterDirect(bm.info(), bm.getPixels(), bm.rowBytes(), &fSurfaceProps);
 }
 
 void SkWindow::setMatrix(const SkMatrix& matrix) {
     if (fMatrix != matrix) {
         fMatrix = matrix;
-        this->inval(NULL);
+        this->inval(nullptr);
     }
 }
 
 void SkWindow::preConcat(const SkMatrix& matrix) {
     SkMatrix m;
     m.setConcat(fMatrix, matrix);
     this->setMatrix(m);
 }
 
 void SkWindow::postConcat(const SkMatrix& matrix) {
     SkMatrix m;
     m.setConcat(matrix, fMatrix);
     this->setMatrix(m);
 }
 
 void SkWindow::setColorType(SkColorType ct) {
     this->resize(fBitmap.width(), fBitmap.height(), ct);
 }
 
 void SkWindow::resize(int width, int height, SkColorType ct) {
     if (ct == kUnknown_SkColorType)
         ct = fColorType;
 
     if (width != fBitmap.width() || height != fBitmap.height() || ct != fColorType) {
         fColorType = ct;
         fBitmap.allocPixels(SkImageInfo::Make(width, height,
                                               ct, kPremul_SkAlphaType));
 
         this->setSize(SkIntToScalar(width), SkIntToScalar(height));
-        this->inval(NULL);
+        this->inval(nullptr);
     }
 }
 
 bool SkWindow::handleInval(const SkRect* localR) {
     SkIRect ir;
 
     if (localR) {
         SkRect devR;
         SkMatrix inverse;
         if (!fMatrix.invert(&inverse)) {
@@ skipping 58 matching lines @@
         return true;
     }
     return false;
 }
 
 bool SkWindow::handleChar(SkUnichar uni) {
     if (this->onHandleChar(uni))
         return true;
 
     SkView* focus = this->getFocusView();
-    if (focus == NULL)
+    if (focus == nullptr)
         focus = this;
 
     SkEvent evt(SK_EventType_Unichar);
     evt.setFast32(uni);
     return focus->doEvent(evt);
 }
 
 bool SkWindow::handleKey(SkKey key) {
     if (key == kNONE_SkKey)
         return false;
 
     if (this->onHandleKey(key))
         return true;
 
     // send an event to the focus-view
     {
         SkView* focus = this->getFocusView();
-        if (focus == NULL)
+        if (focus == nullptr)
             focus = this;
 
         SkEvent evt(SK_EventType_Key);
         evt.setFast32(key);
         if (focus->doEvent(evt))
             return true;
     }
 
     if (key == kUp_SkKey || key == kDown_SkKey) {
-        if (this->moveFocus(key == kUp_SkKey ? kPrev_FocusDirection : kNext_FocusDirection) == NULL)
-            this->onSetFocusView(NULL);
+        if (this->moveFocus(key == kUp_SkKey ? kPrev_FocusDirection : kNext_FocusDirection) == nullptr)
+            this->onSetFocusView(nullptr);
         return true;
     }
     return false;
 }
 
 bool SkWindow::handleKeyUp(SkKey key) {
     if (key == kNONE_SkKey)
         return false;
 
     if (this->onHandleKeyUp(key))
         return true;
 
     //send an event to the focus-view
     {
         SkView* focus = this->getFocusView();
-        if (focus == NULL)
+        if (focus == nullptr)
             focus = this;
 
         //should this one be the same?
         SkEvent evt(SK_EventType_KeyUp);
         evt.setFast32(key);
         if (focus->doEvent(evt))
             return true;
     }
     return false;
 }
 
 void SkWindow::addMenu(SkOSMenu* menu) {
     *fMenus.append() = menu;
     this->onAddMenu(menu);
 }
 
 void SkWindow::setTitle(const char title[]) {
-    if (NULL == title) {
+    if (nullptr == title) {
         title = "";
     }
     fTitle.set(title);
     this->onSetTitle(title);
 }
 
 bool SkWindow::onEvent(const SkEvent& evt) {
     if (evt.isType(SK_EventDelayInval)) {
         for (SkRegion::Iterator iter(fDirtyRgn); !iter.done(); iter.next())
             this->onHandleInval(iter.rect());
@@ skipping 106 matching lines @@
     desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
     desc.fSampleCnt = attachmentInfo.fSampleCount;
     desc.fStencilBits = attachmentInfo.fStencilBits;
     GrGLint buffer;
     GR_GL_GetIntegerv(interface, GR_GL_FRAMEBUFFER_BINDING, &buffer);
     desc.fRenderTargetHandle = buffer;
     return grContext->textureProvider()->wrapBackendRenderTarget(desc);
 }
 
 #endif