- Add Dart_EmptyString to return the canonical empty string similar to how

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 33 matching lines @@
 DEFINE_FLAG(bool, check_function_fingerprints, false,
             "Check function fingerprints");
 DEFINE_FLAG(bool, trace_api, false,
             "Trace invocation of API calls (debug mode only)");
 DEFINE_FLAG(bool, load_async, true, "load source code asynchronously");
 
 ThreadLocalKey Api::api_native_key_ = Thread::kUnsetThreadLocalKey;
 Dart_Handle Api::true_handle_ = NULL;
 Dart_Handle Api::false_handle_ = NULL;
 Dart_Handle Api::null_handle_ = NULL;
+Dart_Handle Api::empty_string_handle_ = NULL;
 
 
 const char* CanonicalFunction(const char* func) {
   if (strncmp(func, "dart::", 6) == 0) {
     return func + 6;
   } else {
     return func;
   }
 }
 
@@ skipping 301 matching lines @@
 
 Dart_Handle Api::AcquiredError(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* acquired_error_handle = state->AcquiredError();
   return reinterpret_cast<Dart_Handle>(acquired_error_handle);
 }
 
 
-Dart_Handle Api::Null() {
-  return null_handle_;
-}
-
-
-Dart_Handle Api::True() {
-  return true_handle_;
-}
-
-
-Dart_Handle Api::False() {
-  return false_handle_;
-}
-
-
 ApiLocalScope* Api::TopScope(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope;
 }
 
 
@@ skipping 11 matching lines @@
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ASSERT(true_handle_ == NULL);
   true_handle_ = Api::InitNewHandle(isolate, Bool::True().raw());
 
   ASSERT(false_handle_ == NULL);
   false_handle_ = Api::InitNewHandle(isolate, Bool::False().raw());
 
   ASSERT(null_handle_ == NULL);
   null_handle_ = Api::InitNewHandle(isolate, Object::null());
+
+  ASSERT(empty_string_handle_ == NULL);
+  empty_string_handle_ = Api::InitNewHandle(isolate, Symbols::Empty().raw());
 }
 
 
 bool Api::StringGetPeerHelper(NativeArguments* arguments,
                               int arg_index,
                               void** peer) {
   NoGCScope no_gc_scope;
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (!raw_obj->IsHeapObject()) {
     return false;
@@ skipping 1235 matching lines @@
     if (scope == NULL) return NULL;
     zone = scope->zone();
   }
   return reinterpret_cast<uint8_t*>(zone->AllocUnsafe(size));
 }
 
 
 // --- Objects ----
 
 DART_EXPORT Dart_Handle Dart_Null() {
-  Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
+  ASSERT(Isolate::Current() != NULL);
   return Api::Null();
 }
 
 
+DART_EXPORT Dart_Handle Dart_EmptyString() {
+  ASSERT(Isolate::Current() != NULL);
+  return Api::EmptyString();
+}
+
+
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
   return Api::UnwrapHandle(object) == Object::null();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
@@ skipping 357 matching lines @@
     RETURN_TYPE_ERROR(isolate, double_obj, Double);
   }
   *value = obj.value();
   return Api::Success();
 }
 
 
 // --- Booleans ----
 
 DART_EXPORT Dart_Handle Dart_True() {
-  Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
+  ASSERT(Isolate::Current() != NULL);
   return Api::True();
 }
 
 
 DART_EXPORT Dart_Handle Dart_False() {
-  Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
+  ASSERT(Isolate::Current() != NULL);
   return Api::False();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewBoolean(bool value) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return value ? Api::True() : Api::False();
 }
 
@@ skipping 3003 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart