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

src/serialize.cc

 // Copyright 2012 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/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 77 matching lines @@
       return;
   }
   Add(address, type, id, name);
 }
 
 
 void ExternalReferenceTable::Add(Address address,
                                  TypeCode type,
                                  uint16_t id,
                                  const char* name) {
-  DCHECK_NE(NULL, address);
+  DCHECK_NOT_NULL(address);
   ExternalReferenceEntry entry;
   entry.address = address;
   entry.code = EncodeExternal(type, id);
   entry.name = name;
-  DCHECK_NE(0, entry.code);
+  DCHECK_NE(0u, entry.code);
   // Assert that the code is added in ascending order to rule out duplicates.
   DCHECK((size() == 0) || (code(size() - 1) < entry.code));
   refs_.Add(entry);
   if (id > max_id_[type]) max_id_[type] = id;
 }
 
 
 void ExternalReferenceTable::PopulateTable(Isolate* isolate) {
   for (int type_code = 0; type_code < kTypeCodeCount; type_code++) {
     max_id_[type_code] = 0;
@@ skipping 526 matching lines @@
 #endif  // DEBUG
   if (!isolate_->heap()->ReserveSpace(reservations_)) return false;
   for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
     high_water_[i] = reservations_[i][0].start;
   }
   return true;
 }
 
 
 void Deserializer::Initialize(Isolate* isolate) {
-  DCHECK_EQ(NULL, isolate_);
-  DCHECK_NE(NULL, isolate);
+  DCHECK_NULL(isolate_);
+  DCHECK_NOT_NULL(isolate);
   isolate_ = isolate;
-  DCHECK_EQ(NULL, external_reference_decoder_);
+  DCHECK_NULL(external_reference_decoder_);
   external_reference_decoder_ = new ExternalReferenceDecoder(isolate);
 }
 
 
 void Deserializer::Deserialize(Isolate* isolate) {
   Initialize(isolate);
   if (!ReserveSpace()) FatalProcessOutOfMemory("deserializing context");
   // No active threads.
-  DCHECK_EQ(NULL, isolate_->thread_manager()->FirstThreadStateInUse());
+  DCHECK_NULL(isolate_->thread_manager()->FirstThreadStateInUse());
   // No active handles.
   DCHECK(isolate_->handle_scope_implementer()->blocks()->is_empty());
   isolate_->heap()->IterateSmiRoots(this);
   isolate_->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
   isolate_->heap()->RepairFreeListsAfterDeserialization();
   isolate_->heap()->IterateWeakRoots(this, VISIT_ALL);
 
   isolate_->heap()->set_native_contexts_list(
       isolate_->heap()->undefined_value());
   isolate_->heap()->set_array_buffers_list(
@@ skipping 245 matching lines @@
     AlwaysAllocateScope scope(isolate_);
     LargeObjectSpace* lo_space = isolate_->heap()->lo_space();
     Executability exec = static_cast<Executability>(source_.Get());
     AllocationResult result = lo_space->AllocateRaw(size, exec);
     HeapObject* obj = HeapObject::cast(result.ToObjectChecked());
     deserialized_large_objects_.Add(obj);
     return obj->address();
   } else {
     DCHECK(space_index < kNumberOfPreallocatedSpaces);
     Address address = high_water_[space_index];
-    DCHECK_NE(NULL, address);
+    DCHECK_NOT_NULL(address);
     high_water_[space_index] += size;
 #ifdef DEBUG
     // Assert that the current reserved chunk is still big enough.
     const Heap::Reservation& reservation = reservations_[space_index];
     int chunk_index = current_chunk_[space_index];
     CHECK_LE(high_water_[space_index], reservation[chunk_index].end);
 #endif
     return address;
   }
 }
@@ skipping 420 matching lines @@
 
 Serializer::~Serializer() {
   delete external_reference_encoder_;
   if (code_address_map_ != NULL) delete code_address_map_;
 }
 
 
 void StartupSerializer::SerializeStrongReferences() {
   Isolate* isolate = this->isolate();
   // No active threads.
-  CHECK_EQ(NULL, isolate->thread_manager()->FirstThreadStateInUse());
+  CHECK_NULL(isolate->thread_manager()->FirstThreadStateInUse());
   // No active or weak handles.
   CHECK(isolate->handle_scope_implementer()->blocks()->is_empty());
   CHECK_EQ(0, isolate->global_handles()->NumberOfWeakHandles());
   CHECK_EQ(0, isolate->eternal_handles()->NumberOfHandles());
   // We don't support serializing installed extensions.
   CHECK(!isolate->has_installed_extensions());
   isolate->heap()->IterateSmiRoots(this);
   isolate->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG);
 }
 
@@ skipping 1168 matching lines @@
   return GetHeaderValue(kNumInternalizedStringsOffset);
 }
 
 Vector<const uint32_t> SerializedCodeData::CodeStubKeys() const {
   int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
   const byte* start = data_ + kHeaderSize + reservations_size;
   return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
                                 GetHeaderValue(kNumCodeStubKeysOffset));
 }
 } }  // namespace v8::internal