Refactor creation of FinalizablePersistentHandle into proper factory.

runtime/vm/dart_api_state.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_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/thread.h"
@@ skipping 172 matching lines @@
   RawObject* raw_;
   DISALLOW_ALLOCATION();  // Allocated through AllocateHandle methods.
   DISALLOW_COPY_AND_ASSIGN(PersistentHandle);
 };
 
 
 // Implementation of persistent handles which are handed out through the
 // dart API.
 class FinalizablePersistentHandle {
  public:
+  static FinalizablePersistentHandle* New(
+      Isolate* isolate,
+      bool is_prologue,
+      const Object& object,
+      void* peer,
+      Dart_WeakPersistentHandleFinalizer callback,
+      intptr_t external_size);
+
   // Accessors.
   RawObject* raw() const { return raw_; }
-  void set_raw(RawObject* raw) { raw_ = raw; }
-  void set_raw(const LocalHandle& ref) { raw_ = ref.raw(); }
-  void set_raw(const Object& object) { raw_ = object.raw(); }
   RawObject** raw_addr() { return &raw_; }
   static intptr_t raw_offset() {
     return OFFSET_OF(FinalizablePersistentHandle, raw_);
   }
   void* peer() const { return peer_; }
-  void set_peer(void* peer) { peer_ = peer; }
   Dart_WeakPersistentHandleFinalizer callback() const { return callback_; }
-  void set_callback(Dart_WeakPersistentHandleFinalizer callback) {
-    callback_ = callback;
-  }
   Dart_WeakPersistentHandle apiHandle() {
     return reinterpret_cast<Dart_WeakPersistentHandle>(this);
   }
 
   void SetExternalSize(intptr_t size, Isolate* isolate) {
     ASSERT(size >= 0);
     set_external_size(Utils::RoundUp(size, kObjectAlignment));
     if (SpaceForExternal() == Heap::kNew) {
       SetExternalNewSpaceBit();
     }
@@ skipping 75 matching lines @@
     SetNext(free_list);
   }
 
   void Clear() {
     raw_ = Object::null();
     peer_ = NULL;
     external_data_ = 0;
     callback_ = NULL;
   }
 
+  void set_raw(RawObject* raw) { raw_ = raw; }
+  void set_raw(const LocalHandle& ref) { raw_ = ref.raw(); }
+  void set_raw(const Object& object) { raw_ = object.raw(); }
+
+  void set_peer(void* peer) { peer_ = peer; }
+
+  void set_callback(Dart_WeakPersistentHandleFinalizer callback) {
+    callback_ = callback;
+  }
+
   intptr_t external_size() const {
     return ExternalSizeBits::decode(external_data_);
   }
 
   void set_external_size(intptr_t size) {
     ASSERT(ExternalSizeBits::is_valid(size));
     external_data_ = ExternalSizeBits::update(size, external_data_);
   }
 
   bool IsSetNewSpaceBit() const {
@@ skipping 622 matching lines @@
   }
 
   ApiState* api_state_;
   Zone* zone_;
 
   friend class ApiState;
   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakReferenceSetBuilder);
 };
 
 
+inline FinalizablePersistentHandle* FinalizablePersistentHandle::New(
+    Isolate* isolate,
+    bool is_prologue,
+    const Object& object,
+    void* peer,
+    Dart_WeakPersistentHandleFinalizer callback,
+    intptr_t external_size) {
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  FinalizablePersistentHandle* ref = is_prologue ?
+      state->prologue_weak_persistent_handles().AllocateHandle() :
+      state->weak_persistent_handles().AllocateHandle();
+  ref->SetPrologueWeakPersistent(is_prologue);
+  ref->set_raw(object);
+  ref->set_peer(peer);
+  ref->set_callback(callback);
+  ref->SetExternalSize(external_size, isolate);
+  return ref;
+}
+
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_