Initial switch to Chromium-style CHECK_* and DCHECK_* macros.

test/cctest/compiler/test-loop-analysis.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.h"
@@ skipping 118 matching lines @@
       }
       Zone zone;
       loop_tree = LoopFinder::BuildLoopTree(&graph, &zone);
     }
     return loop_tree;
   }
 
   void CheckLoop(Node** header, int header_count, Node** body, int body_count) {
     LoopTree* tree = GetLoopTree();
     LoopTree::Loop* loop = tree->ContainingLoop(header[0]);
-    CHECK_NE(NULL, loop);
+    CHECK(loop);
 
     CHECK(header_count == static_cast<int>(loop->HeaderSize()));
     for (int i = 0; i < header_count; i++) {
       // Each header node should be in the loop.
       CHECK_EQ(loop, tree->ContainingLoop(header[i]));
       CheckRangeContains(tree->HeaderNodes(loop), header[i]);
     }
 
     CHECK_EQ(body_count, static_cast<int>(loop->BodySize()));
     // TODO(turbofan): O(n^2) set equivalence in this test.
     for (int i = 0; i < body_count; i++) {
       // Each body node should be contained in the loop.
       CHECK(tree->Contains(loop, body[i]));
       CheckRangeContains(tree->BodyNodes(loop), body[i]);
     }
   }
 
   void CheckRangeContains(NodeRange range, Node* node) {
     CHECK_NE(range.end(), std::find(range.begin(), range.end(), node));
   }
 
   void CheckNestedLoops(Node** chain, int chain_count) {
     LoopTree* tree = GetLoopTree();
     for (int i = 0; i < chain_count; i++) {
       Node* header = chain[i];
       // Each header should be in a loop.
       LoopTree::Loop* loop = tree->ContainingLoop(header);
-      CHECK_NE(NULL, loop);
+      CHECK(loop);
       // Check parentage.
       LoopTree::Loop* parent =
           i == 0 ? NULL : tree->ContainingLoop(chain[i - 1]);
       CHECK_EQ(parent, loop->parent());
       for (int j = i - 1; j >= 0; j--) {
         // This loop should be nested inside all the outer loops.
         Node* outer_header = chain[j];
         LoopTree::Loop* outer = tree->ContainingLoop(outer_header);
         CHECK(tree->Contains(outer, header));
         CHECK(!tree->Contains(loop, outer_header));
@@ skipping 790 matching lines @@
 TEST(LaManyChained_64) { RunManyChainedLoops_i(64); }
 
 TEST(LaManyNested_30) { RunManyNestedLoops_i(30); }
 TEST(LaManyNested_31) { RunManyNestedLoops_i(31); }
 TEST(LaManyNested_32) { RunManyNestedLoops_i(32); }
 TEST(LaManyNested_33) { RunManyNestedLoops_i(33); }
 TEST(LaManyNested_34) { RunManyNestedLoops_i(34); }
 TEST(LaManyNested_62) { RunManyNestedLoops_i(62); }
 TEST(LaManyNested_63) { RunManyNestedLoops_i(63); }
 TEST(LaManyNested_64) { RunManyNestedLoops_i(64); }