Remove foo != NULL checks in xfa/src/fxbarcode.

xfa/src/fxbarcode/pdf417/BC_PDF417Detector.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
 // Original code is licensed as follows:
 /*
  * Copyright 2009 ZXing authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ skipping 106 matching lines @@
         if (vertices) {
           delete (vertices);
         }
         break;
       }
       foundBarcodeInRow = FALSE;
       column = 0;
       for (int32_t i = 0; i < barcodeCoordinates->GetSize(); i++) {
         CFX_PtrArray* barcodeCoordinate =
             (CFX_PtrArray*)barcodeCoordinates->GetAt(i);
-        if (barcodeCoordinate->GetAt(1) != NULL) {
+        if (barcodeCoordinate->GetAt(1)) {
           row = row > ((CBC_ResultPoint*)barcodeCoordinate->GetAt(1))->GetY();
         }
-        if (barcodeCoordinate->GetAt(3) != NULL) {
+        if (barcodeCoordinate->GetAt(3)) {
           row = row > ((CBC_ResultPoint*)barcodeCoordinate->GetAt(3))->GetY();
         }
       }
       row += ROW_STEP;
       if (vertices) {
         delete (vertices);
       }
       continue;
     }
     foundBarcodeInRow = TRUE;
     barcodeCoordinates->Add(vertices);
     if (!multiple) {
       break;
     }
-    if (vertices->GetAt(2) != NULL) {
+    if (vertices->GetAt(2)) {
       column = (int32_t)((CBC_ResultPoint*)vertices->GetAt(2))->GetX();
       row = (int32_t)((CBC_ResultPoint*)vertices->GetAt(2))->GetY();
     } else {
       column = (int32_t)((CBC_ResultPoint*)vertices->GetAt(4))->GetX();
       row = (int32_t)((CBC_ResultPoint*)vertices->GetAt(4))->GetY();
     }
   }
   return barcodeCoordinates;
 }
 CFX_PtrArray* CBC_Detector::findVertices(CBC_CommonBitMatrix* matrix,
                                          int32_t startRow,
                                          int32_t startColumn) {
   int32_t height = matrix->GetHeight();
   int32_t width = matrix->GetWidth();
   CFX_PtrArray* result = new CFX_PtrArray;
   result->SetSize(8);
   CFX_PtrArray* startptr = findRowsWithPattern(
       matrix, height, width, startRow, startColumn, START_PATTERN,
       sizeof(START_PATTERN) / sizeof(START_PATTERN[0]));
   copyToResult(
       result, startptr, INDEXES_START_PATTERN,
       sizeof(INDEXES_START_PATTERN) / sizeof(INDEXES_START_PATTERN[0]));
   startptr->RemoveAll();
   delete startptr;
-  if (result->GetAt(4) != NULL) {
+  if (result->GetAt(4)) {
     startColumn = (int32_t)((CBC_ResultPoint*)result->GetAt(4))->GetX();
     startRow = (int32_t)((CBC_ResultPoint*)result->GetAt(4))->GetY();
   }
   CFX_PtrArray* stopptr = findRowsWithPattern(
       matrix, height, width, startRow, startColumn, STOP_PATTERN,
       sizeof(STOP_PATTERN) / sizeof(STOP_PATTERN[0]));
   copyToResult(result, stopptr, INDEXES_STOP_PATTERN,
                sizeof(INDEXES_STOP_PATTERN) / sizeof(INDEXES_STOP_PATTERN[0]));
   stopptr->RemoveAll();
   delete stopptr;
@@ skipping 16 matching lines @@
                                                 int32_t patternLength) {
   CFX_PtrArray* result = new CFX_PtrArray;
   result->SetSize(4);
   FX_BOOL found = FALSE;
   CFX_Int32Array counters;
   counters.SetSize(patternLength);
   for (; startRow < height; startRow += ROW_STEP) {
     CFX_Int32Array* loc =
         findGuardPattern(matrix, startColumn, startRow, width, FALSE, pattern,
                          patternLength, counters);
-    if (loc != NULL) {
+    if (loc) {
       while (startRow > 0) {
         CFX_Int32Array* previousRowLoc =
             findGuardPattern(matrix, startColumn, --startRow, width, FALSE,
                              pattern, patternLength, counters);
-        if (previousRowLoc != NULL) {
+        if (previousRowLoc) {
           delete loc;
           loc = previousRowLoc;
         } else {
           startRow++;
           break;
         }
       }
       result->SetAt(
           0, new CBC_ResultPoint((FX_FLOAT)loc->GetAt(0), (FX_FLOAT)startRow));
       result->SetAt(
           1, new CBC_ResultPoint((FX_FLOAT)loc->GetAt(1), (FX_FLOAT)startRow));
       found = TRUE;
       delete loc;
       break;
     }
   }
   int32_t stopRow = startRow + 1;
   if (found) {
     int32_t skippedRowCount = 0;
     CFX_Int32Array previousRowLoc;
     previousRowLoc.Add((int32_t)((CBC_ResultPoint*)result->GetAt(0))->GetX());
     previousRowLoc.Add((int32_t)((CBC_ResultPoint*)result->GetAt(1))->GetX());
     for (; stopRow < height; stopRow++) {
       CFX_Int32Array* loc =
           findGuardPattern(matrix, previousRowLoc[0], stopRow, width, FALSE,
                            pattern, patternLength, counters);
-      if (loc != NULL &&
-          abs(previousRowLoc[0] - loc->GetAt(0)) < MAX_PATTERN_DRIFT &&
+      if (loc && abs(previousRowLoc[0] - loc->GetAt(0)) < MAX_PATTERN_DRIFT &&
           abs(previousRowLoc[1] - loc->GetAt(1)) < MAX_PATTERN_DRIFT) {
         previousRowLoc.Copy(*loc);
         skippedRowCount = 0;
       } else {
         if (skippedRowCount > SKIPPED_ROW_COUNT_MAX) {
           delete loc;
           break;
         } else {
           skippedRowCount++;
         }
@@ skipping 93 matching lines @@
     int32_t scaledPattern = pattern[x] * unitBarWidth;
     int32_t variance = counter > scaledPattern ? counter - scaledPattern
                                                : scaledPattern - counter;
     if (variance > maxIndividualVariance) {
       return INTEGER_MAX;
     }
     totalVariance += variance;
   }
   return totalVariance / total;
 }