[api] Prototype WeakRef implementation

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 2679 matching lines @@
       break;
     }
     case JS_WEAK_MAP_TYPE: {
       accumulator->Add("<JSWeakMap>");
       break;
     }
     case JS_WEAK_SET_TYPE: {
       accumulator->Add("<JSWeakSet>");
       break;
     }
+    case JS_WEAK_REF_TYPE: {
+      accumulator->Add("<JSWeakRef>");
+      break;
+    }
     case JS_REGEXP_TYPE: {
       accumulator->Add("<JSRegExp");
       JSRegExp* regexp = JSRegExp::cast(this);
       if (regexp->source()->IsString()) {
         accumulator->Add(" ");
         String::cast(regexp->source())->StringShortPrint(accumulator);
       }
       accumulator->Add(">");
 
       break;
@@ skipping 10072 matching lines @@
     case JS_ARGUMENTS_TYPE:
     case JS_PROMISE_TYPE:
     case JS_REGEXP_TYPE:
     case JS_SET_ITERATOR_TYPE:
     case JS_SET_TYPE:
     case JS_SPECIAL_API_OBJECT_TYPE:
     case JS_TYPED_ARRAY_TYPE:
     case JS_VALUE_TYPE:
     case JS_WEAK_MAP_TYPE:
     case JS_WEAK_SET_TYPE:
+    case JS_WEAK_REF_TYPE:
       return true;
 
     case BYTECODE_ARRAY_TYPE:
     case BYTE_ARRAY_TYPE:
     case CELL_TYPE:
     case CODE_TYPE:
     case FILLER_TYPE:
     case FIXED_ARRAY_TYPE:
     case FIXED_DOUBLE_ARRAY_TYPE:
     case FOREIGN_TYPE:
@@ skipping 6391 matching lines @@
           Object* value = table->Lookup(key);
           entries->set(count++, value);
         }
       }
     }
     DCHECK_EQ(max_entries * values_per_entry, count);
   }
   return isolate->factory()->NewJSArrayWithElements(entries);
 }
 
+void JSWeakRef::Initialize(Handle<JSWeakRef> weak_ref,
+                                  Isolate* isolate,
+                                  Handle<JSObject> target,
+                                  Handle<JSFunction> executor,
+                                  Handle<Object> holdings) {
+  isolate->factory()->InitJSWeakRef(weak_ref, target, executor, holdings);
+}
+
+Handle<HeapObject> JSWeakRef::Value(Handle<JSWeakRef> weak_ref,
+                                  Isolate* isolate) {
+  if (weak_ref->target() == nullptr || weak_ref->target()->cleared()) {
+    return isolate->factory()->null_value();
+  }
+  weak_ref->set_held(true);
+  return Handle<HeapObject>(
+    reinterpret_cast<HeapObject*>(weak_ref->target()->value()));
+}
+
+void JSWeakRef::Clear(Handle<JSWeakRef> weak_ref,
+                                  Isolate* isolate) {
+  weak_ref->set_executor(nullptr);
+  weak_ref->set_holdings(nullptr);
+  weak_ref->set_target(nullptr);
+}
+
 // Check if there is a break point at this source position.
 bool DebugInfo::HasBreakPoint(int source_position) {
   // Get the break point info object for this code offset.
   Object* break_point_info = GetBreakPointInfo(source_position);
 
   // If there is no break point info object or no break points in the break
   // point info object there is no break point at this code offset.
   if (break_point_info->IsUndefined(GetIsolate())) return false;
   return BreakPointInfo::cast(break_point_info)->GetBreakPointCount() > 0;
 }
@@ skipping 1459 matching lines @@
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 
 }  // namespace internal
 }  // namespace v8