Implement creation of ByteData objects using the Dart API.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 2056 matching lines @@
                                      const Class& cls,
                                      const String& class_name,
                                      const String& dotted_name,
                                      int num_args);
 
 
 static RawObject* ThrowArgumentError(const char* exception_message) {
   Isolate* isolate = Isolate::Current();
   // Lookup the class ArgumentError in dart:core.
   const String& lib_url = String::Handle(String::New("dart:core"));
-  const String& class_name =
-      String::Handle(String::New("ArgumentError"));
+  const String& class_name = String::Handle(String::New("ArgumentError"));
   const Library& lib =
       Library::Handle(isolate, Library::LookupLibrary(lib_url));
   if (lib.IsNull()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: library '%s' not found.",
                              CURRENT_FUNC, lib_url.ToCString()));
     return ApiError::New(message);
   }
   const Class& cls = Class::Handle(isolate,
                                    lib.LookupClassAllowPrivate(class_name));
   if (cls.IsNull()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: class '%s' not found in library '%s'.",
                              CURRENT_FUNC, class_name.ToCString(),
                              lib_url.ToCString()));
     return ApiError::New(message);
   }
+  Object& result = Object::Handle(isolate);
   String& dot_name = String::Handle(String::New("."));
-  Object& result = Object::Handle(isolate);
-  result = ResolveConstructor(CURRENT_FUNC, cls, class_name, dot_name, 1);
+  String& constr_name = String::Handle(String::Concat(class_name, dot_name));
+  result = ResolveConstructor(CURRENT_FUNC, cls, class_name, constr_name, 1);
   if (result.IsError()) return result.raw();
   ASSERT(result.IsFunction());
   Function& constructor = Function::Handle(isolate);
   constructor ^= result.raw();
   if (!constructor.IsConstructor()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: class '%s' is not a constructor.",
                              CURRENT_FUNC, class_name.ToCString()));
     return ApiError::New(message);
   }
@@ skipping 213 matching lines @@
 }
 
 
 // --- Typed Data ---
 
 
 // Helper method to get the type of a TypedData object.
 static Dart_TypedData_Type GetType(intptr_t class_id) {
   Dart_TypedData_Type type;
   switch (class_id) {
-    case kByteArrayCid :
-      type = kByteData;
-      break;
     case kTypedDataInt8ArrayCid :
     case kExternalTypedDataInt8ArrayCid :
       type = kInt8;
       break;
     case kTypedDataUint8ArrayCid :
     case kExternalTypedDataUint8ArrayCid :
       type = kUint8;
       break;
     case kTypedDataUint8ClampedArrayCid :
     case kExternalTypedDataUint8ClampedArrayCid :
@@ skipping 34 matching lines @@
     default:
       type = kInvalid;
       break;
   }
   return type;
 }
 
 
 DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfTypedData(Dart_Handle object) {
   intptr_t class_id = Api::ClassId(object);
-  if (!RawObject::IsTypedDataClassId(class_id)) {
-    return kInvalid;
+  if (RawObject::IsTypedDataClassId(class_id)) {
+    return GetType(class_id);
   }
-  return GetType(class_id);
+  Isolate* isolate = Isolate::Current();
+  const Library& lib =
+      Library::Handle(isolate->object_store()->typeddata_library());
+  const Class& cls =
+      Class::Handle(isolate,
+                    lib.LookupClassAllowPrivate(Symbols::_ByteDataView()));
+  if (isolate->class_table()->At(class_id) == cls.raw()) {
+    return kByteData;
+  }
+  return kInvalid;
 }
 
 
 DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfExternalTypedData(
     Dart_Handle object) {
   intptr_t class_id = Api::ClassId(object);
-  if (!RawObject::IsExternalTypedDataClassId(class_id)) {
-    return kInvalid;
+  if (RawObject::IsExternalTypedDataClassId(class_id)) {
+    return GetType(class_id);
   }
-  return GetType(class_id);
+  Isolate* isolate = Isolate::Current();
+  const Library& lib =
+      Library::Handle(isolate->object_store()->typeddata_library());
+  const Class& cls =
+      Class::Handle(isolate,
+                    lib.LookupClassAllowPrivate(Symbols::_ByteDataView()));
+  if (isolate->class_table()->At(class_id) == cls.raw()) {
+    return kByteData;
+  }
+  return kInvalid;
+}
+
+
+static RawObject* GetByteDataConstructor(Isolate* isolate,
+                                         const String& constructor_name,
+                                         intptr_t num_args) {
+  const Library& lib =
+      Library::Handle(isolate->object_store()->typeddata_library());
+  ASSERT(!lib.IsNull());
+  const Class& cls =
+      Class::Handle(isolate, lib.LookupClassAllowPrivate(Symbols::ByteData()));
+  ASSERT(!cls.IsNull());
+  return ResolveConstructor(CURRENT_FUNC,
+                            cls,
+                            Symbols::ByteData(),
+                            constructor_name,
+                            num_args);
+}
+
+
+static Dart_Handle NewByteData(Isolate* isolate, intptr_t length) {
+  CHECK_LENGTH(length, TypedData::MaxElements(kTypedDataInt8ArrayCid));
+  Object& result = Object::Handle(isolate);
+  result = GetByteDataConstructor(isolate, Symbols::ByteDataDot(), 1);
+  ASSERT(!result.IsNull());
+  ASSERT(result.IsFunction());
+  const Function& factory = Function::Cast(result);
+  ASSERT(!factory.IsConstructor());
+
+  // Create the argument list.
+  const Array& args = Array::Handle(isolate, Array::New(2));
+  // Factories get type arguments.
+  args.SetAt(0, TypeArguments::Handle(isolate));
+  args.SetAt(1, Smi::Handle(isolate, Smi::New(length)));
+
+  // Invoke the constructor and return the new object.
+  result = DartEntry::InvokeFunction(factory, args);
+  ASSERT(result.IsInstance() || result.IsNull() || result.IsError());
+  return Api::NewHandle(isolate, result.raw());
 }
 
 
 static Dart_Handle NewTypedData(Isolate* isolate,
                                 intptr_t cid,
                                 intptr_t length) {
   CHECK_LENGTH(length, TypedData::MaxElements(cid));
   return Api::NewHandle(isolate, TypedData::New(cid, length));
 }
 
 
 static Dart_Handle NewExternalTypedData(
     intptr_t cid,
     void* data,
     intptr_t length,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   CHECK_LENGTH(length, ExternalTypedData::MaxElements(cid));
   const ExternalTypedData& obj = ExternalTypedData::Handle(
       ExternalTypedData::New(cid,
                              reinterpret_cast<uint8_t*>(data),
                              length));
   return reinterpret_cast<Dart_Handle>(obj.AddFinalizer(peer, callback));
 }
 
 
+static Dart_Handle NewExternalByteData(Isolate* isolate,
+                                       void* data,
+                                       intptr_t length,
+                                       void* peer,
+                                       Dart_WeakPersistentHandleFinalizer cb) {
+  Dart_Handle ext_data = NewExternalTypedData(kExternalTypedDataUint8ArrayCid,
+                                              data,
+                                              length,
+                                              peer,
+                                              cb);
+  if (::Dart_IsError(ext_data)) {
+    return ext_data;
+  }
+  Object& result = Object::Handle(isolate);
+  result = GetByteDataConstructor(isolate, Symbols::ByteDataDotview(), 3);
+  ASSERT(!result.IsNull());
+  ASSERT(result.IsFunction());
+  const Function& factory = Function::Cast(result);
+  ASSERT(!factory.IsConstructor());
+
+  // Create the argument list.
+  const intptr_t num_args = 3;
+  const Array& args = Array::Handle(isolate, Array::New(num_args + 1));
+  // Factories get type arguments.
+  args.SetAt(0, TypeArguments::Handle(isolate));
+  const ExternalTypedData& array =
+      Api::UnwrapExternalTypedDataHandle(isolate, ext_data);
+  args.SetAt(1, array);
+  Smi& smi = Smi::Handle(isolate);
+  smi = Smi::New(0);
+  args.SetAt(2, smi);
+  smi = Smi::New(length);
+  args.SetAt(3, smi);
+
+  // Invoke the constructor and return the new object.
+  result = DartEntry::InvokeFunction(factory, args);
+  ASSERT(result.IsNull() || result.IsInstance() || result.IsError());
+  return Api::NewHandle(isolate, result.raw());
+}
+
+
 DART_EXPORT Dart_Handle Dart_NewTypedData(Dart_TypedData_Type type,
                                           intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   switch (type) {
     case kByteData :
-      // TODO(asiva): Add a new ByteArray::New() method.
-      break;
+      return NewByteData(isolate, length);
     case kInt8 :
       return NewTypedData(isolate, kTypedDataInt8ArrayCid, length);
     case kUint8 :
       return NewTypedData(isolate, kTypedDataUint8ArrayCid, length);
     case kUint8Clamped :
       return NewTypedData(isolate, kTypedDataUint8ClampedArrayCid, length);
     case kInt16 :
       return NewTypedData(isolate, kTypedDataInt16ArrayCid, length);
     case kUint16 :
       return NewTypedData(isolate, kTypedDataUint16ArrayCid, length);
@@ skipping 25 matching lines @@
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
     RETURN_NULL_ERROR(data);
   }
   CHECK_CALLBACK_STATE(isolate);
   switch (type) {
     case kByteData :
-      // TODO(asiva): Allocate external ByteData object.
-      break;
+      return NewExternalByteData(isolate, data, length, peer, callback);
     case kInt8 :
       return NewExternalTypedData(kExternalTypedDataInt8ArrayCid,
                                   data,
                                   length,
                                   peer,
                                   callback);
     case kUint8 :
       return NewExternalTypedData(kExternalTypedDataUint8ArrayCid,
                                   data,
                                   length,
@@ skipping 960 matching lines @@
   return TypeToHandle(isolate, "Dart_TypeVariableUpperBound", bound);
 }
 
 
 // --- Constructors, Methods, and Fields ---
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
-                                     const String& dotted_name,
+                                     const String& constr_name,
                                      int num_args) {
   // The constructor must be present in the interface.
-  String& constr_name = String::Handle(String::Concat(class_name, dotted_name));
   const Function& constructor =
       Function::Handle(cls.LookupFunctionAllowPrivate(constr_name));
   if (constructor.IsNull() ||
       (!constructor.IsConstructor() && !constructor.IsFactory())) {
     const String& lookup_class_name = String::Handle(cls.Name());
     if (!class_name.Equals(lookup_class_name)) {
       // When the class name used to build the constructor name is
       // different than the name of the class in which we are doing
       // the lookup, it can be confusing to the user to figure out
       // what's going on.  Be a little more explicit for these error
@@ skipping 64 matching lines @@
     dot_name = String::Concat(Symbols::Dot(), String::Cast(name_obj));
   } else {
     RETURN_TYPE_ERROR(isolate, constructor_name, String);
   }
   Dart_Handle state = Api::CheckIsolateState(isolate);
   if (::Dart_IsError(state)) {
     return state;
   }
 
   // Resolve the constructor.
-  result = ResolveConstructor(
-      "Dart_New", cls, base_constructor_name, dot_name, number_of_arguments);
+  String& constr_name =
+      String::Handle(String::Concat(base_constructor_name, dot_name));
+  result = ResolveConstructor("Dart_New",
+                              cls,
+                              base_constructor_name,
+                              constr_name,
+                              number_of_arguments);
   if (result.IsError()) {
     return Api::NewHandle(isolate, result.raw());
   }
   ASSERT(result.IsFunction());
   Function& constructor = Function::Handle(isolate);
   constructor ^= result.raw();
 
   Instance& new_object = Instance::Handle(isolate);
   if (constructor.IsRedirectingFactory()) {
     Type& type = Type::Handle(constructor.RedirectionType());
@@ skipping 1119 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart