Added following dart API changes to enable more efficient access based

runtime/vm/dart_api_impl_test.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 "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
@@ skipping 524 matching lines @@
   uint8_t latin1[] = { 'o', 'n', 'e', 0xC2, 0xA2 };
 
   Dart_Handle latin1str = Dart_NewStringFromUTF8(latin1, ARRAY_SIZE(latin1));
   EXPECT_VALID(latin1str);
   EXPECT(Dart_IsString(latin1str));
   EXPECT(Dart_IsStringLatin1(latin1str));
   EXPECT(!Dart_IsExternalString(latin1str));
   intptr_t len = -1;
   EXPECT_VALID(Dart_StringLength(latin1str, &len));
   EXPECT_EQ(4, len);
+  intptr_t char_size;
+  intptr_t str_len;
+  void* peer;
+  EXPECT_VALID(Dart_StringGetProperties(latin1str,
+                                        &char_size,
+                                        &str_len,
+                                        &peer));
+  EXPECT_EQ(1, char_size);
+  EXPECT_EQ(4, str_len);
+  EXPECT(!peer);
 
   uint8_t data8[] = { 'o', 'n', 'e', 0x7F };
 
   Dart_Handle str8 = Dart_NewStringFromUTF8(data8, ARRAY_SIZE(data8));
   EXPECT_VALID(str8);
   EXPECT(Dart_IsString(str8));
   EXPECT(Dart_IsStringLatin1(str8));
   EXPECT(!Dart_IsExternalString(str8));
 
   uint8_t latin1_array[] = {0, 0, 0, 0, 0};
   len = 5;
   Dart_Handle result = Dart_StringToLatin1(str8, latin1_array, &len);
   EXPECT_VALID(result);
   EXPECT_EQ(4, len);
   EXPECT(latin1_array != NULL);
   for (intptr_t i = 0; i < len; i++) {
     EXPECT_EQ(data8[i], latin1_array[i]);
   }
 
   Dart_Handle ext8 = Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8),
-                                                  NULL, NULL);
+                                                  data8, NULL);
   EXPECT_VALID(ext8);
   EXPECT(Dart_IsString(ext8));
   EXPECT(Dart_IsExternalString(ext8));
+  EXPECT_VALID(Dart_StringGetProperties(ext8,
+                                        &char_size,
+                                        &str_len,
+                                        &peer));
+  EXPECT_EQ(1, char_size);
+  EXPECT_EQ(4, str_len);
+  EXPECT_EQ(data8, peer);
 
   uint16_t data16[] = { 't', 'w', 'o', 0xFFFF };
 
   Dart_Handle str16 = Dart_NewStringFromUTF16(data16, ARRAY_SIZE(data16));
   EXPECT_VALID(str16);
   EXPECT(Dart_IsString(str16));
   EXPECT(!Dart_IsStringLatin1(str16));
   EXPECT(!Dart_IsExternalString(str16));
+  EXPECT_VALID(Dart_StringGetProperties(str16,
+                                        &char_size,
+                                        &str_len,
+                                        &peer));
+  EXPECT_EQ(2, char_size);
+  EXPECT_EQ(4, str_len);
+  EXPECT(!peer);
 
   Dart_Handle ext16 = Dart_NewExternalUTF16String(data16, ARRAY_SIZE(data16),
-                                                  NULL, NULL);
+                                                  data16, NULL);
   EXPECT_VALID(ext16);
   EXPECT(Dart_IsString(ext16));
   EXPECT(Dart_IsExternalString(ext16));
+  EXPECT_VALID(Dart_StringGetProperties(ext16,
+                                        &char_size,
+                                        &str_len,
+                                        &peer));
+  EXPECT_EQ(2, char_size);
+  EXPECT_EQ(4, str_len);
+  EXPECT_EQ(data16, peer);
 
   int32_t data32[] = { 'f', 'o', 'u', 'r', 0x10FFFF };
 
   Dart_Handle str32 = Dart_NewStringFromUTF32(data32, ARRAY_SIZE(data32));
   EXPECT_VALID(str32);
   EXPECT(Dart_IsString(str32));
   EXPECT(!Dart_IsExternalString(str32));
 }
 
 
@@ skipping 6505 matching lines @@
 // Test external strings and optimized code.
 static void ExternalStringDeoptimize_Finalize(void* peer) {
   delete[] reinterpret_cast<char*>(peer);
 }
 
 
 static void A_change_str_native(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle str = Dart_GetNativeArgument(args, 0);
   EXPECT(Dart_IsString(str));
+  void* peer;
+  Dart_Handle str_arg = Dart_GetNativeStringArgument(args, 0, &peer);
+  EXPECT(Dart_IsString(str_arg));
+  EXPECT(!peer);
   intptr_t size = 0;
   EXPECT_VALID(Dart_StringStorageSize(str, &size));
+  intptr_t arg_size = 0;
+  EXPECT_VALID(Dart_StringStorageSize(str_arg, &arg_size));
+  EXPECT_EQ(size, arg_size);
   char* str_data = new char[size];
   Dart_Handle result =
       Dart_MakeExternalString(str,
                               str_data,
                               size,
                               str_data,
                               &ExternalStringDeoptimize_Finalize);
   EXPECT_VALID(result);
   Dart_ExitScope();
 }
@@ skipping 132 matching lines @@
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(8, value);
 }
 
 }  // namespace dart