The dart version of typeddata library has changed to be compatible with the dart2js implementation

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 "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 1837 matching lines @@
   // different signature classes for closures.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ReusableObjectHandleScope reused_obj_handle(isolate);
   const Instance& closure_obj =
       Api::UnwrapInstanceHandle(reused_obj_handle, object);
   return (!closure_obj.IsNull() && closure_obj.IsClosure());
 }
 
 
+DART_EXPORT bool Dart_IsTypedData(Dart_Handle handle) {
+  TRACE_API_CALL(CURRENT_FUNC);
+  intptr_t cid = Api::ClassId(handle);
+  return RawObject::IsTypedDataClassId(cid) ||
+      RawObject::IsExternalTypedDataClassId(cid);
+}
+
+
+DART_EXPORT bool Dart_IsByteBuffer(Dart_Handle handle) {
+  TRACE_API_CALL(CURRENT_FUNC);
+  return Api::ClassId(handle) == kByteBufferCid;
+}
+
+
 // --- Instances ----
 
 DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(instance));
   if (obj.IsNull()) {
     return Api::NewHandle(isolate, isolate->object_store()->null_type());
   }
   if (!obj.IsInstance()) {
@@ skipping 1211 matching lines @@
   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(0, Object::null_type_arguments());
   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,
@@ skipping 29 matching lines @@
   result = GetByteDataConstructor(isolate, Symbols::ByteDataDot_view(), 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));
+  args.SetAt(0, Object::null_type_arguments());
   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.
@@ skipping 119 matching lines @@
                                   length);
     default:
       return Api::NewError("%s expects argument 'type' to be of"
                            " 'external TypedData'", CURRENT_FUNC);
   }
   UNREACHABLE();
   return Api::Null();
 }
 
 
+static RawObject* GetByteBufferConstructor(Isolate* isolate,
+                                           const String& class_name,
+                                           const String& constructor_name,
+                                           intptr_t num_args) {
+  const Library& lib =
+      Library::Handle(isolate->object_store()->typed_data_library());
+  ASSERT(!lib.IsNull());
+  const Class& cls = Class::Handle(
+      isolate, lib.LookupClassAllowPrivate(class_name));
+  ASSERT(!cls.IsNull());
+  return ResolveConstructor(CURRENT_FUNC,
+                            cls,
+                            class_name,
+                            constructor_name,
+                            num_args);
+}
+
+
+DART_EXPORT Dart_Handle Dart_NewByteBuffer(Dart_Handle typed_data) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  intptr_t class_id = Api::ClassId(typed_data);
+  if (!RawObject::IsExternalTypedDataClassId(class_id) &&
+      !RawObject::IsTypedDataViewClassId(class_id) &&
+      !RawObject::IsTypedDataClassId(class_id)) {
+    RETURN_TYPE_ERROR(isolate, typed_data, 'TypedData');
+  }
+  Object& result = Object::Handle(isolate);
+  result = GetByteBufferConstructor(isolate,
+                                    Symbols::_ByteBuffer(),
+                                    Symbols::_ByteBufferDot_New(),
+                                    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, Object::null_type_arguments());
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(typed_data));
+  args.SetAt(1, obj);
+
+  // Invoke the factory constructor and return the new object.
+  result = DartEntry::InvokeFunction(factory, args);
+  ASSERT(result.IsInstance() || result.IsNull() || result.IsError());
+  return Api::NewHandle(isolate, result.raw());
+}
+
+
 DART_EXPORT Dart_Handle Dart_TypedDataAcquireData(Dart_Handle object,
                                                   Dart_TypedData_Type* type,
                                                   void** data,
                                                   intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
       !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
@@ skipping 60 matching lines @@
     RETURN_TYPE_ERROR(isolate, object, 'TypedData');
   }
   if (!RawObject::IsExternalTypedDataClassId(class_id)) {
     isolate->DecrementNoGCScopeDepth();
     END_NO_CALLBACK_SCOPE(isolate);
   }
   return Api::Success();
 }
 
 
+DART_EXPORT Dart_Handle Dart_GetDataFromByteBuffer(Dart_Handle object) {
+  Isolate* isolate = Isolate::Current();
+  CHECK_ISOLATE(isolate);
+  intptr_t class_id = Api::ClassId(object);
+  if (class_id != kByteBufferCid) {
+    RETURN_TYPE_ERROR(isolate, object, 'ByteBuffer');
+  }
+  const Instance& instance = Api::UnwrapInstanceHandle(isolate, object);
+  ASSERT(!instance.IsNull());
+  return Api::NewHandle(isolate, ByteBuffer::Data(instance));
+}
+
+
 // ---  Invoking Constructors, Methods, and Field accessors ---
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& constr_name,
                                      int num_args) {
   // The constructor must be present in the interface.
   const Function& constructor =
       Function::Handle(cls.LookupFunctionAllowPrivate(constr_name));
@@ skipping 1839 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart