Avoid duplicate null checks when calling SetRaw from InitializeHandle

vm/object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 132 matching lines @@
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class StackFrame;                                                     \
 
 class Object {
  public:
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
-  void operator=(RawObject* value) { SetRaw(value); }
+  void operator=(RawObject* value) {
+    initializeHandle(this, value);
+  }
 
   void set_tags(intptr_t value) const {
     // TODO(asiva): Remove the capability of setting tags in general. The mask
     // here only allows for canonical and from_snapshot flags to be set.
     ASSERT(!IsNull());
     uword tags = raw()->ptr()->tags_ & ~0x0000000c;
     raw()->ptr()->tags_ = tags | (value & 0x0000000c);
   }
   void SetCreatedFromSnapshot() const {
     ASSERT(!IsNull());
@@ skipping 41 matching lines @@
   void Print() const;
 
   bool IsZoneHandle() const {
     return VMHandles::IsZoneHandle(reinterpret_cast<uword>(this));
   }
 
   static RawObject* Clone(const Object& src, Heap::Space space = Heap::kNew);
 
   static Object& Handle(Isolate* isolate, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(VMHandles::AllocateHandle(isolate));
-    obj->SetRaw(raw_ptr);
+    initializeHandle(obj, raw_ptr);
     return *obj;
   }
 
   static Object& Handle() {
     return Handle(Isolate::Current(), null_);
   }
 
   static Object& Handle(Isolate* isolate) {
     return Handle(isolate, null_);
   }
 
   static Object& Handle(RawObject* raw_ptr) {
     return Handle(Isolate::Current(), raw_ptr);
   }
 
   static Object& ZoneHandle(Isolate* isolate, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(
         VMHandles::AllocateZoneHandle(isolate));
-    obj->SetRaw(raw_ptr);
+    initializeHandle(obj, raw_ptr);
     return *obj;
   }
 
   static Object& ZoneHandle() {
     return ZoneHandle(Isolate::Current(), null_);
   }
 
   static Object& ZoneHandle(RawObject* raw_ptr) {
     return ZoneHandle(Isolate::Current(), raw_ptr);
   }
@@ skipping 119 matching lines @@
   static RawClass* CreateAndRegisterInterface(const char* cname,
                                               const Script& script,
                                               const Library& lib);
   static void RegisterClass(const Class& cls,
                             const String& name,
                             const Library& lib);
   static void RegisterPrivateClass(const Class& cls,
                                    const String& name,
                                    const Library& lib);
 
+  /* Initialize the handle based on the raw_ptr in the presence of null. */
+  static void initializeHandle(Object* obj, RawObject* raw_ptr) {
+    if (raw_ptr != Object::null()) {
+      obj->SetRaw(raw_ptr);
+    } else {
+      obj->raw_ = Object::null();
+      Object fake_object;
+      obj->set_vtable(fake_object.vtable());
+    }
+  }
+
   cpp_vtable* vtable_address() const {
     uword vtable_addr = reinterpret_cast<uword>(this);
     return reinterpret_cast<cpp_vtable*>(vtable_addr);
   }
 
   static cpp_vtable handle_vtable_;
   static cpp_vtable builtin_vtables_[kNumPredefinedCids];
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
@@ skipping 5385 matching lines @@
 
 
 void Object::SetRaw(RawObject* value) {
   // NOTE: The assignment "raw_ = value" should be the first statement in
   // this function. Also do not use 'value' in this function after the
   // assignment (use 'raw_' instead).
   raw_ = value;
   if ((reinterpret_cast<uword>(raw_) & kSmiTagMask) == kSmiTag) {
     set_vtable(Smi::handle_vtable_);
     return;
-  } else if (raw_ == null_) {
-    set_vtable(handle_vtable_);
-    return;
   }
-
+  intptr_t cid = raw_->GetClassId();
+  if (cid >= kNumPredefinedCids) {
+      cid = kInstanceCid;
+  }
+  set_vtable(builtin_vtables_[cid]);
 #if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   if (FLAG_verify_handles) {
     Heap* isolate_heap = isolate->heap();
     Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
     ASSERT(isolate_heap->Contains(reinterpret_cast<uword>(raw_->ptr())) ||
            vm_isolate_heap->Contains(reinterpret_cast<uword>(raw_->ptr())));
   }
+  ASSERT(builtin_vtables_[cid] ==
+         isolate->class_table()->At(cid)->ptr()->handle_vtable_);
 #endif
-  intptr_t cid = raw_->GetClassId();
-  if (cid < kNumPredefinedCids) {
-#if defined(DEBUG)
-    ASSERT(builtin_vtables_[cid] ==
-           isolate->class_table()->At(cid)->ptr()->handle_vtable_);
-#endif
-    set_vtable(builtin_vtables_[cid]);
-  } else {
-    set_vtable(builtin_vtables_[kInstanceCid]);
-  }
 }
 
 
 bool Function::HasCode() const {
   return raw_ptr()->code_ != Code::null();
 }
 
 
 intptr_t Field::Offset() const {
   ASSERT(!is_static());  // Offset is valid only for instance fields.
@@ skipping 37 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_