- Add a minimal implementation of Capability.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 873 matching lines @@
   str = lib.PrivateName(public_class_name);
   cls.set_name(str);
   lib.AddClass(cls);
 }
 
 
 RawError* Object::Init(Isolate* isolate) {
   TIMERSCOPE(isolate, time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
-  Class& cls = Class::Handle();
-  Type& type = Type::Handle();
-  Array& array = Array::Handle();
-  Library& lib = Library::Handle();
+  Class& cls = Class::Handle(isolate);
+  Type& type = Type::Handle(isolate);
+  Array& array = Array::Handle(isolate);
+  Library& lib = Library::Handle(isolate);
 
   // All RawArray fields will be initialized to an empty array, therefore
   // initialize array class first.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   // Array and ImmutableArray are the only VM classes that are parameterized.
   // Since they are pre-finalized, CalculateFieldOffsets() is not called, so we
   // need to set the offset of their type_arguments_ field, which is explicitly
   // declared in RawArray.
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
   cls.set_num_type_arguments(1);
   cls.set_num_own_type_arguments(1);
 
   // Set up the growable object array class (Has to be done after the array
   // class is setup as one of its field is an array object).
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
   cls.set_type_arguments_field_offset(
       GrowableObjectArray::type_arguments_offset());
   cls.set_num_type_arguments(1);
   cls.set_num_own_type_arguments(1);
 
   // canonical_type_arguments_ are Smi terminated.
   // Last element contains the count of used slots.
   const intptr_t kInitialCanonicalTypeArgumentsSize = 4;
   array = Array::New(kInitialCanonicalTypeArgumentsSize + 1);
-  array.SetAt(kInitialCanonicalTypeArgumentsSize, Smi::Handle(Smi::New(0)));
+  array.SetAt(kInitialCanonicalTypeArgumentsSize,
+              Smi::Handle(isolate, Smi::New(0)));
   object_store->set_canonical_type_arguments(array);
 
   // Setup type class early in the process.
   cls = Class::New<Type>();
   object_store->set_type_class(cls);
 
   cls = Class::New<TypeRef>();
   object_store->set_type_ref_class(cls);
 
   cls = Class::New<TypeParameter>();
@@ skipping 13 matching lines @@
   object_store->set_one_byte_string_class(cls);
 
   // Pre-allocate the TwoByteString class needed by the symbol table.
   cls = Class::NewStringClass(kTwoByteStringCid);
   object_store->set_two_byte_string_class(cls);
 
   // Setup the symbol table for the symbols created in the isolate.
   Symbols::SetupSymbolTable(isolate);
 
   // Set up the libraries array before initializing the core library.
-  const GrowableObjectArray& libraries =
-      GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
+  const GrowableObjectArray& libraries = GrowableObjectArray::Handle(
+      isolate, GrowableObjectArray::New(Heap::kOld));
   object_store->set_libraries(libraries);
 
   // Pre-register the core library.
   Library::InitCoreLibrary(isolate);
 
   // Basic infrastructure has been setup, initialize the class dictionary.
-  Library& core_lib = Library::Handle(Library::CoreLibrary());
+  const Library& core_lib = Library::Handle(isolate, Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
 
   const GrowableObjectArray& pending_classes =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
+      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
   object_store->set_pending_classes(pending_classes);
 
-  Context& context = Context::Handle(Context::New(0, Heap::kOld));
+  Context& context = Context::Handle(isolate, Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
   // remaining classes and register them by name in the dictionaries.
-  String& name = String::Handle();
+  String& name = String::Handle(isolate);
   cls = object_store->array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::_List(), core_lib);
   pending_classes.Add(cls);
   // We cannot use NewNonParameterizedType(cls), because Array is parameterized.
-  type ^= Type::New(Object::Handle(cls.raw()),
-                    TypeArguments::Handle(),
+  type ^= Type::New(Object::Handle(isolate, cls.raw()),
+                    TypeArguments::Handle(isolate),
                     Scanner::kNoSourcePos);
   type.SetIsFinalized();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::_GrowableList(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Array>(kImmutableArrayCid);
@@ skipping 17 matching lines @@
   cls = Class::NewStringClass(kExternalOneByteStringCid);
   object_store->set_external_one_byte_string_class(cls);
   RegisterPrivateClass(cls, Symbols::ExternalOneByteString(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::NewStringClass(kExternalTwoByteStringCid);
   object_store->set_external_two_byte_string_class(cls);
   RegisterPrivateClass(cls, Symbols::ExternalTwoByteString(), core_lib);
   pending_classes.Add(cls);
 
+  // Pre-register the isolate library so the native class implementations
+  // can be hooked up before compiling it.
+  Library& isolate_lib =
+      Library::Handle(isolate, Library::LookupLibrary(Symbols::DartIsolate()));
+  if (isolate_lib.IsNull()) {
+    isolate_lib = Library::NewLibraryHelper(Symbols::DartIsolate(), true);
+    isolate_lib.Register();
+    isolate->object_store()->set_bootstrap_library(ObjectStore::kIsolate,
+                                                   isolate_lib);
+  }
+  ASSERT(!isolate_lib.IsNull());
+  ASSERT(isolate_lib.raw() == Library::IsolateLibrary());
+
+  cls = Class::New<Capability>();
+  RegisterPrivateClass(cls, Symbols::_CapabilityImpl(), isolate_lib);
+  pending_classes.Add(cls);
+
+  cls = Class::New<ReceivePort>();
+  RegisterPrivateClass(cls, Symbols::_RawReceivePortImpl(), isolate_lib);
+  pending_classes.Add(cls);
+
+  cls = Class::New<SendPort>();
+  RegisterPrivateClass(cls, Symbols::_SendPortImpl(), isolate_lib);
+  pending_classes.Add(cls);
+
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
   RegisterClass(cls, Symbols::StackTrace(), core_lib);
   pending_classes.Add(cls);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
   RegisterPrivateClass(cls, Symbols::JSSyntaxRegExp(), core_lib);
   pending_classes.Add(cls);
@@ skipping 402 matching lines @@
 
   cls = Class::NewStringClass(kExternalTwoByteStringCid);
   object_store->set_external_two_byte_string_class(cls);
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
 
   cls = Class::New<Instance>(kNullCid);
   object_store->set_null_class(cls);
 
+  cls = Class::New<Capability>();
+  cls = Class::New<ReceivePort>();
+  cls = Class::New<SendPort>();
+
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
 
   // Some classes are not stored in the object store. Yet we still need to
   // create their Class object so that they get put into the class_table
   // (as a side effect of Class::New()).
   cls = Class::New<Number>();
@@ skipping 13238 matching lines @@
 }
 
 
 RawInteger* Integer::New(int64_t value, Heap::Space space, const bool silent) {
   if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
     return Smi::New(value);
   }
   if (!silent &&
       FLAG_throw_on_javascript_int_overflow &&
       !IsJavascriptInt(value)) {
-    const Integer &i = Integer::Handle(Mint::New(value));
+    const Integer& i = Integer::Handle(Mint::New(value));
     ThrowJavascriptIntegerOverflow(i);
   }
   return Mint::New(value, space);
 }
 
 
 RawInteger* Integer::NewFromUint64(uint64_t value, Heap::Space space) {
   if (value > static_cast<uint64_t>(Mint::kMaxValue)) {
     if (FLAG_throw_on_javascript_int_overflow) {
       const Integer &i =
@@ skipping 3142 matching lines @@
   return "ExternalTypedData";
 }
 
 
 void ExternalTypedData::PrintToJSONStream(JSONStream* stream,
                                           bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
+RawCapability* Capability::New(uint64_t id, Heap::Space space) {
+  Capability& result = Capability::Handle();
+  {
+    RawObject* raw = Object::Allocate(Capability::kClassId,
+                                      Capability::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.raw_ptr()->id_ = id;
+  return result.raw();
+}
+
+
+const char* Capability::ToCString() const {
+  return "Capability";
+}
+
+
+void Capability::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  Instance::PrintToJSONStream(stream, ref);
+}
+
+
+RawReceivePort* ReceivePort::New(Dart_Port id, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const SendPort& send_port = SendPort::Handle(isolate, SendPort::New(id));
+
+  ReceivePort& result = ReceivePort::Handle(isolate);
+  {
+    RawObject* raw = Object::Allocate(ReceivePort::kClassId,
+                                      ReceivePort::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.raw_ptr()->send_port_ = send_port.raw();
+  PortMap::SetLive(id);
+  return result.raw();
+}
+
+
+const char* ReceivePort::ToCString() const {
+  return "ReceivePort";
+}
+
+
+void ReceivePort::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  Instance::PrintToJSONStream(stream, ref);
+}
+
+
+RawSendPort* SendPort::New(Dart_Port id, Heap::Space space) {
+  SendPort& result = SendPort::Handle();
+  {
+    RawObject* raw = Object::Allocate(SendPort::kClassId,
+                                      SendPort::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.raw_ptr()->id_ = id;
+  return result.raw();
+}
+
+
+const char* SendPort::ToCString() const {
+  return "SendPort";
+}
+
+
+void SendPort::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  Instance::PrintToJSONStream(stream, ref);
+}
+
 
 const char* Closure::ToCString(const Instance& closure) {
   const Function& fun = Function::Handle(Closure::function(closure));
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.UserVisibleSignature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
   const char* format = "Closure: %s%s%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
@@ skipping 587 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart