Realize IWYU pattern for handles.h header.

src/handles.h

 // Copyright 2011 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.
 
 #ifndef V8_HANDLES_H_
 #define V8_HANDLES_H_
 
-#include "src/objects.h"
+#include "include/v8.h"
+#include "src/base/macros.h"
+#include "src/checks.h"
+#include "src/globals.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class DeferredHandles;
 class HandleScopeImplementer;
+class Isolate;
+class Object;
 
 
 // ----------------------------------------------------------------------------
 // Base class for Handle instantiations.  Don't use directly.
 class HandleBase {
  public:
   V8_INLINE explicit HandleBase(Object** location) : location_(location) {}
   V8_INLINE explicit HandleBase(Object* object, Isolate* isolate);
 
   // Check if this handle refers to the exact same object as the other handle.
   V8_INLINE bool is_identical_to(const HandleBase that) const {
     // Dereferencing deferred handles to check object equality is safe.
-    SLOW_DCHECK((this->location_ == NULL ||
+    SLOW_DCHECK((this->location_ == nullptr ||
                  this->IsDereferenceAllowed(NO_DEFERRED_CHECK)) &&
-                (that.location_ == NULL ||
+                (that.location_ == nullptr ||
                  that.IsDereferenceAllowed(NO_DEFERRED_CHECK)));
     if (this->location_ == that.location_) return true;
     if (this->location_ == NULL || that.location_ == NULL) return false;
     return *this->location_ == *that.location_;
   }
 
   V8_INLINE bool is_null() const { return location_ == nullptr; }
 
  protected:
   // Provides the C++ dereference operator.
   V8_INLINE Object* operator*() const {
     SLOW_DCHECK(IsDereferenceAllowed(INCLUDE_DEFERRED_CHECK));
     return *location_;
   }
 
   // Returns the address to where the raw pointer is stored.
   V8_INLINE Object** location() const {
-    SLOW_DCHECK(location_ == NULL ||
+    SLOW_DCHECK(location_ == nullptr ||
                 IsDereferenceAllowed(INCLUDE_DEFERRED_CHECK));
     return location_;
   }
 
   enum DereferenceCheckMode { INCLUDE_DEFERRED_CHECK, NO_DEFERRED_CHECK };
 #ifdef DEBUG
   bool IsDereferenceAllowed(DereferenceCheckMode mode) const;
 #else
   V8_INLINE
   bool IsDereferenceAllowed(DereferenceCheckMode mode) const { return true; }
@@ skipping 284 matching lines @@
   void Initialize() {
     next = limit = NULL;
     level = 0;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HANDLES_H_