Style Change: NULL->nullptr

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextContext.h"
 #include "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrStencilAndCoverTextContext.h"
 
 #include "batches/GrBatch.h"
 #include "batches/GrDrawAtlasBatch.h"
 #include "batches/GrDrawVerticesBatch.h"
 #include "batches/GrRectBatchFactory.h"
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == fContext)
 #define RETURN_IF_ABANDONED        if (!fDrawTarget) { return; }
 #define RETURN_FALSE_IF_ABANDONED  if (!fDrawTarget) { return false; }
-#define RETURN_NULL_IF_ABANDONED   if (!fDrawTarget) { return NULL; }
+#define RETURN_NULL_IF_ABANDONED   if (!fDrawTarget) { return nullptr; }
 
 class AutoCheckFlush {
 public:
     AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
     ~AutoCheckFlush() { fContext->flushIfNecessary(); }
 
 private:
     GrContext* fContext;
 };
 
 GrDrawContext::GrDrawContext(GrContext* context,
                              GrDrawTarget* drawTarget,
                              const SkSurfaceProps& surfaceProps)
     : fContext(context)
     , fDrawTarget(SkRef(drawTarget))
-    , fTextContext(NULL)
+    , fTextContext(nullptr)
     , fSurfaceProps(surfaceProps) {
 }
 
 GrDrawContext::~GrDrawContext() {
     SkSafeUnref(fDrawTarget);
     delete fTextContext;
 }
 
 void GrDrawContext::copySurface(GrRenderTarget* dst, GrSurface* src,
                                 const SkIRect& srcRect, const SkIPoint& dstPoint) {
@@ skipping 169 matching lines @@
         return;
     }
 
     AutoCheckFlush acf(fContext);
     if (!this->prepareToDraw(rt)) {
         return;
     }
 
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
 
-    SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getWidth();
+    SkScalar width = nullptr == strokeInfo ? -1 : strokeInfo->getWidth();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
     if (width < 0) {
         SkRect rtRect;
         pipelineBuilder.getRenderTarget()->getBoundsRect(&rtRect);
         SkRect clipSpaceRTRect = rtRect;
         bool checkClip = GrClip::kWideOpen_ClipType != clip.clipType();
         if (checkClip) {
             clipSpaceRTRect.offset(SkIntToScalar(clip.origin().fX),
                                    SkIntToScalar(clip.origin().fY));
         }
         // Does the clip contain the entire RT?
         if (!checkClip || clip.quickContains(clipSpaceRTRect)) {
             SkMatrix invM;
             if (!viewMatrix.invert(&invM)) {
                 return;
             }
             // Does the rect bound the RT?
             SkPoint srcSpaceRTQuad[4];
             invM.mapRectToQuad(srcSpaceRTQuad, rtRect);
             if (rect_contains_inclusive(rect, srcSpaceRTQuad[0]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[1]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[2]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[3])) {
                 // Will it blend?
                 GrColor clearColor;
                 if (paint.isConstantBlendedColor(&clearColor)) {
-                    fDrawTarget->clear(NULL, clearColor, true, rt);
+                    fDrawTarget->clear(nullptr, clearColor, true, rt);
                     return;
                 }
             }
         }
     }
 
     GrColor color = paint.getColor();
     bool needAA = paint.isAntiAlias() &&
                   !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
@@ skipping 419 matching lines @@
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     const GrStrokeInfo* strokeInfoPtr = &strokeInfo;
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
     GrPathRenderer* pr = fContext->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr,
                                                     *strokeInfoPtr, false, type);
 
     GrStrokeInfo dashlessStrokeInfo(strokeInfo, false);
-    if (NULL == pr && strokeInfo.isDashed()) {
+    if (nullptr == pr && strokeInfo.isDashed()) {
         // It didn't work above, so try again with dashed stroke converted to a dashless stroke.
         if (!strokeInfo.applyDashToPath(tmpPath.init(), &dashlessStrokeInfo, *pathPtr)) {
             return;
         }
         pathPtr = tmpPath.get();
         if (pathPtr->isEmpty()) {
             return;
         }
         strokeInfoPtr = &dashlessStrokeInfo;
         pr = fContext->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *strokeInfoPtr,
                                        false, type);
     }
 
-    if (NULL == pr) {
-        if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*strokeInfoPtr, viewMatrix, NULL) &&
+    if (nullptr == pr) {
+        if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*strokeInfoPtr, viewMatrix, nullptr) &&
             !strokeInfoPtr->isFillStyle()) {
             // It didn't work above, so try again with stroke converted to a fill.
             if (!tmpPath.isValid()) {
                 tmpPath.init();
             }
             dashlessStrokeInfo.setResScale(SkScalarAbs(viewMatrix.getMaxScale()));
             if (!dashlessStrokeInfo.applyToPath(tmpPath.get(), *pathPtr)) {
                 return;
             }
             pathPtr = tmpPath.get();
             if (pathPtr->isEmpty()) {
                 return;
             }
             dashlessStrokeInfo.setFillStyle();
             strokeInfoPtr = &dashlessStrokeInfo;
         }
 
         // This time, allow SW renderer
         pr = fContext->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *strokeInfoPtr,
                                        true, type);
     }
 
-    if (NULL == pr) {
+    if (nullptr == pr) {
 #ifdef SK_DEBUG
         SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
     GrPathRenderer::DrawPathArgs args;
     args.fTarget = target;
     args.fResourceProvider = fContext->resourceProvider();
     args.fPipelineBuilder = pipelineBuilder;
     args.fColor = color;
     args.fViewMatrix = &viewMatrix;
     args.fPath = pathPtr;
     args.fStroke = strokeInfoPtr;
     args.fAntiAlias = useCoverageAA;
     pr->drawPath(args);
 }
 
 bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     fDrawTarget->drawBatch(*pipelineBuilder, batch);
 }