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

src/compiler/node.cc

 // Copyright 2013 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/compiler/node.h"
 
 #include <algorithm>
 
 namespace v8 {
 namespace internal {
@@ skipping 21 matching lines @@
     use->from = result;
     to->AppendUse(use);
     ++use;
     ++input;
   }
   return result;
 }
 
 
 void Node::Kill() {
-  DCHECK_NOT_NULL(op());
+  DCHECK(op());
   RemoveAllInputs();
   DCHECK(uses().empty());
 }
 
 
 void Node::AppendInput(Zone* zone, Node* new_to) {
-  DCHECK_NOT_NULL(zone);
-  DCHECK_NOT_NULL(new_to);
+  DCHECK(zone);
+  DCHECK(new_to);
   Use* new_use = new (zone) Use;
   Input new_input;
   new_input.to = new_to;
   new_input.use = new_use;
   if (reserved_input_count() > 0) {
     DCHECK(!has_appendable_inputs());
     set_reserved_input_count(reserved_input_count() - 1);
     inputs_.static_[input_count()] = new_input;
   } else {
     EnsureAppendableInputs(zone);
     inputs_.appendable_->push_back(new_input);
   }
   new_use->input_index = input_count();
   new_use->from = this;
   new_to->AppendUse(new_use);
   set_input_count(input_count() + 1);
 }
 
 
 void Node::InsertInput(Zone* zone, int index, Node* new_to) {
-  DCHECK_NOT_NULL(zone);
+  DCHECK(zone);
   DCHECK_LE(0, index);
   DCHECK_LT(index, InputCount());
   AppendInput(zone, InputAt(InputCount() - 1));
   for (int i = InputCount() - 1; i > index; --i) {
     ReplaceInput(i, InputAt(i - 1));
   }
   ReplaceInput(index, new_to);
 }
 
 
@@ skipping 45 matching lines @@
   }
   return use->from;
 }
 
 
 void Node::ReplaceUses(Node* replace_to) {
   for (Use* use = first_use_; use; use = use->next) {
     use->from->GetInputRecordPtr(use->input_index)->to = replace_to;
   }
   if (!replace_to->last_use_) {
-    DCHECK_EQ(nullptr, replace_to->first_use_);
+    DCHECK(!replace_to->first_use_);
     replace_to->first_use_ = first_use_;
     replace_to->last_use_ = last_use_;
   } else if (first_use_) {
-    DCHECK_NOT_NULL(replace_to->first_use_);
+    DCHECK(replace_to->first_use_);
     replace_to->last_use_->next = first_use_;
     first_use_->prev = replace_to->last_use_;
     replace_to->last_use_ = last_use_;
   }
   first_use_ = nullptr;
   last_use_ = nullptr;
 }
 
 
 void Node::Input::Update(Node* new_to) {
@@ skipping 115 matching lines @@
   ++(*this);
   return result;
 }
 
 
 bool Node::Uses::empty() const { return begin() == end(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8