A64: Synchronize with r19001.

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 444 matching lines @@
 static uint16_t* AsciiToTwoByteString(const char* source) {
   int array_length = i::StrLength(source) + 1;
   uint16_t* converted = i::NewArray<uint16_t>(array_length);
   for (int i = 0; i < array_length; i++) converted[i] = source[i];
   return converted;
 }
 
 
 class TestResource: public String::ExternalStringResource {
  public:
-  explicit TestResource(uint16_t* data, int* counter = NULL)
-    : data_(data), length_(0), counter_(counter) {
+  TestResource(uint16_t* data, int* counter = NULL, bool owning_data = true)
+      : data_(data), length_(0), counter_(counter), owning_data_(owning_data) {
     while (data[length_]) ++length_;
   }
 
   ~TestResource() {
-    i::DeleteArray(data_);
+    if (owning_data_) i::DeleteArray(data_);
     if (counter_ != NULL) ++*counter_;
   }
 
   const uint16_t* data() const {
     return data_;
   }
 
   size_t length() const {
     return length_;
   }
+
  private:
   uint16_t* data_;
   size_t length_;
   int* counter_;
+  bool owning_data_;
 };
 
 
 class TestAsciiResource: public String::ExternalAsciiStringResource {
  public:
-  explicit TestAsciiResource(const char* data, int* counter = NULL)
-    : data_(data), length_(strlen(data)), counter_(counter) { }
+  TestAsciiResource(const char* data, int* counter = NULL, size_t offset = 0)
+      : orig_data_(data),
+        data_(data + offset),
+        length_(strlen(data) - offset),
+        counter_(counter) { }
 
   ~TestAsciiResource() {
-    i::DeleteArray(data_);
+    i::DeleteArray(orig_data_);
     if (counter_ != NULL) ++*counter_;
   }
 
   const char* data() const {
     return data_;
   }
 
   size_t length() const {
     return length_;
   }
+
  private:
+  const char* orig_data_;
   const char* data_;
   size_t length_;
   int* counter_;
 };
 
 
 THREADED_TEST(ScriptUsingStringResource) {
   int dispose_count = 0;
   const char* c_source = "1 + 2 * 3";
   uint16_t* two_byte_source = AsciiToTwoByteString(c_source);
@@ skipping 209 matching lines @@
 
   // Trigger GCs so that the newly allocated string moves to old gen.
   SimulateFullSpace(CcTest::heap()->old_pointer_space());
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
 
   // Turn into external string with unaligned resource data.
   int dispose_count = 0;
   const char* c_cons = "_abcdefghijklmnopqrstuvwxyz";
   bool success = cons->MakeExternal(
-      new TestAsciiResource(i::StrDup(c_cons) + 1, &dispose_count));
+      new TestAsciiResource(i::StrDup(c_cons), &dispose_count, 1));
   CHECK(success);
   const char* c_slice = "_bcdefghijklmnopqrstuvwxyz";
   success = slice->MakeExternal(
-      new TestAsciiResource(i::StrDup(c_slice) + 1, &dispose_count));
+      new TestAsciiResource(i::StrDup(c_slice), &dispose_count, 1));
   CHECK(success);
 
   // Trigger GCs and force evacuation.
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
   CcTest::heap()->CollectAllGarbage(i::Heap::kReduceMemoryFootprintMask);
 }
 
 
 THREADED_TEST(UsingExternalString) {
   i::Factory* factory = CcTest::i_isolate()->factory();
@@ skipping 5855 matching lines @@
   Script::Compile(v8_str("JSNI_Log('LOG')"))->Run();
 }
 
 
 static const char* kSimpleExtensionSource =
   "function Foo() {"
   "  return 4;"
   "}";
 
 
-THREADED_TEST(SimpleExtensions) {
+TEST(SimpleExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("simpletest", kSimpleExtensionSource));
   const char* extension_names[] = { "simpletest" };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("Foo()"))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 4));
 }
 
 
-THREADED_TEST(NullExtensions) {
+TEST(NullExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("nulltest", NULL));
   const char* extension_names[] = { "nulltest" };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("1+3"))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 4));
 }
 
 
 static const char* kEmbeddedExtensionSource =
     "function Ret54321(){return 54321;}~~@@$"
     "$%% THIS IS A SERIES OF NON-NULL-TERMINATED STRINGS.";
 static const int kEmbeddedExtensionSourceValidLen = 34;
 
 
-THREADED_TEST(ExtensionMissingSourceLength) {
+TEST(ExtensionMissingSourceLength) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("srclentest_fail",
                                       kEmbeddedExtensionSource));
   const char* extension_names[] = { "srclentest_fail" };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   CHECK_EQ(0, *context);
 }
 
 
-THREADED_TEST(ExtensionWithSourceLength) {
+TEST(ExtensionWithSourceLength) {
   for (int source_len = kEmbeddedExtensionSourceValidLen - 1;
        source_len <= kEmbeddedExtensionSourceValidLen + 1; ++source_len) {
     v8::HandleScope handle_scope(CcTest::isolate());
     i::ScopedVector<char> extension_name(32);
     i::OS::SNPrintF(extension_name, "ext #%d", source_len);
     v8::RegisterExtension(new Extension(extension_name.start(),
                                         kEmbeddedExtensionSource, 0, 0,
                                         source_len));
     const char* extension_names[1] = { extension_name.start() };
     v8::ExtensionConfiguration extensions(1, extension_names);
@@ skipping 21 matching lines @@
 static const char* kEvalExtensionSource2 =
   "(function() {"
   "  var x = 42;"
   "  function e() {"
   "    return eval('x');"
   "  }"
   "  this.UseEval2 = e;"
   "})()";
 
 
-THREADED_TEST(UseEvalFromExtension) {
+TEST(UseEvalFromExtension) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("evaltest1", kEvalExtensionSource1));
   v8::RegisterExtension(new Extension("evaltest2", kEvalExtensionSource2));
   const char* extension_names[] = { "evaltest1", "evaltest2" };
   v8::ExtensionConfiguration extensions(2, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("UseEval1()"))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 42));
@@ skipping 13 matching lines @@
 static const char* kWithExtensionSource2 =
   "(function() {"
   "  var x = 42;"
   "  function e() {"
   "    with ({x:87}) { return x; }"
   "  }"
   "  this.UseWith2 = e;"
   "})()";
 
 
-THREADED_TEST(UseWithFromExtension) {
+TEST(UseWithFromExtension) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("withtest1", kWithExtensionSource1));
   v8::RegisterExtension(new Extension("withtest2", kWithExtensionSource2));
   const char* extension_names[] = { "withtest1", "withtest2" };
   v8::ExtensionConfiguration extensions(2, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("UseWith1()"))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 87));
   result = Script::Compile(v8_str("UseWith2()"))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 87));
 }
 
 
-THREADED_TEST(AutoExtensions) {
+TEST(AutoExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   Extension* extension = new Extension("autotest", kSimpleExtensionSource);
   extension->set_auto_enable(true);
   v8::RegisterExtension(extension);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate());
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("Foo()"))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 4));
 }
 
 
 static const char* kSyntaxErrorInExtensionSource =
     "[";
 
 
 // Test that a syntax error in an extension does not cause a fatal
 // error but results in an empty context.
-THREADED_TEST(SyntaxErrorExtensions) {
+TEST(SyntaxErrorExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("syntaxerror",
                                       kSyntaxErrorInExtensionSource));
   const char* extension_names[] = { "syntaxerror" };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 static const char* kExceptionInExtensionSource =
     "throw 42";
 
 
 // Test that an exception when installing an extension does not cause
 // a fatal error but results in an empty context.
-THREADED_TEST(ExceptionExtensions) {
+TEST(ExceptionExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("exception",
                                       kExceptionInExtensionSource));
   const char* extension_names[] = { "exception" };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 static const char* kNativeCallInExtensionSource =
     "function call_runtime_last_index_of(x) {"
     "  return %StringLastIndexOf(x, 'bob', 10);"
     "}";
 
 
 static const char* kNativeCallTest =
     "call_runtime_last_index_of('bobbobboellebobboellebobbob');";
 
 // Test that a native runtime calls are supported in extensions.
-THREADED_TEST(NativeCallInExtensions) {
+TEST(NativeCallInExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("nativecall",
                                       kNativeCallInExtensionSource));
   const char* extension_names[] = { "nativecall" };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str(kNativeCallTest))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 3));
@@ skipping 15 matching lines @@
   }
 
   static void Echo(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() >= 1) args.GetReturnValue().Set(args[0]);
   }
  private:
   v8::FunctionCallback function_;
 };
 
 
-THREADED_TEST(NativeFunctionDeclaration) {
+TEST(NativeFunctionDeclaration) {
   v8::HandleScope handle_scope(CcTest::isolate());
   const char* name = "nativedecl";
   v8::RegisterExtension(new NativeFunctionExtension(name,
                                                     "native function foo();"));
   const char* extension_names[] = { name };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("foo(42);"))->Run();
   CHECK_EQ(result, v8::Integer::New(CcTest::isolate(), 42));
 }
 
 
-THREADED_TEST(NativeFunctionDeclarationError) {
+TEST(NativeFunctionDeclarationError) {
   v8::HandleScope handle_scope(CcTest::isolate());
   const char* name = "nativedeclerr";
   // Syntax error in extension code.
   v8::RegisterExtension(new NativeFunctionExtension(name,
                                                     "native\nfunction foo();"));
   const char* extension_names[] = { name };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
       Context::New(CcTest::isolate(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
-THREADED_TEST(NativeFunctionDeclarationErrorEscape) {
+TEST(NativeFunctionDeclarationErrorEscape) {
   v8::HandleScope handle_scope(CcTest::isolate());
   const char* name = "nativedeclerresc";
   // Syntax error in extension code - escape code in "native" means that
   // it's not treated as a keyword.
   v8::RegisterExtension(new NativeFunctionExtension(
       name,
       "nativ\\u0065 function foo();"));
   const char* extension_names[] = { name };
   v8::ExtensionConfiguration extensions(1, extension_names);
   v8::Handle<Context> context =
@@ skipping 241 matching lines @@
         ->Set(v8_str("next"), obj);
     prev.SetWeak<Value, Snorkel<Value> >(new Snorkel<Value>(&prev.As<Value>()),
                                          &HandleWeakReference);
   }
   whammy->objects_[whammy->cursor_].Reset(info.GetIsolate(), obj);
   whammy->cursor_ = (whammy->cursor_ + 1) % Whammy::kObjectCount;
   info.GetReturnValue().Set(whammy->getScript()->Run());
 }
 
 
-THREADED_TEST(WeakReference) {
+TEST(WeakReference) {
   i::FLAG_expose_gc = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> templ= v8::ObjectTemplate::New(isolate);
   Whammy* whammy = new Whammy(CcTest::isolate());
   templ->SetNamedPropertyHandler(WhammyPropertyGetter,
                                  0, 0, 0, 0,
                                  v8::External::New(CcTest::isolate(), whammy));
   const char* extension_list[] = { "v8/gc" };
   v8::ExtensionConfiguration extensions(1, extension_list);
@@ skipping 3512 matching lines @@
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   templ->SetClassName(v8_str("Fun"));
   Local<Function> cons = templ->GetFunction();
   context->Global()->Set(v8_str("Fun"), cons);
   Local<Value> value = CompileRun(
     "function test() {"
     "  try {"
     "    (new Fun()).blah()"
     "  } catch (e) {"
     "    var str = String(e);"
-    "    if (str.indexOf('TypeError') == -1) return 1;"
-    "    if (str.indexOf('[object Fun]') != -1) return 2;"
-    "    if (str.indexOf('#<Fun>') == -1) return 3;"
+    // "    if (str.indexOf('TypeError') == -1) return 1;"
+    // "    if (str.indexOf('[object Fun]') != -1) return 2;"
+    // "    if (str.indexOf('#<Fun>') == -1) return 3;"
     "    return 0;"
     "  }"
     "  return 4;"
     "}"
     "test();");
   CHECK_EQ(0, value->Int32Value());
 }
 
 
 THREADED_TEST(EvalAliasedDynamic) {
@@ skipping 254 matching lines @@
     context->Global()->Set(v8_str("obj2"), instance);
     v8::TryCatch try_catch;
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     // Call an object without call-as-function handler through the JS
     value = CompileRun("obj2(28)");
     CHECK(value.IsEmpty());
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value1(try_catch.Exception());
-    CHECK_EQ("TypeError: Property 'obj2' of object #<Object> is not a function",
+    // TODO(verwaest): Better message
+    CHECK_EQ("TypeError: object is not a function",
              *exception_value1);
     try_catch.Reset();
 
     // Call an object without call-as-function handler through the API
     value = CompileRun("obj2(28)");
     v8::Handle<Value> args[] = { v8_num(28) };
     value = instance->CallAsFunction(instance, 1, args);
     CHECK(value.IsEmpty());
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value2(try_catch.Exception());
@@ skipping 1362 matching lines @@
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = 333;"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
-  CHECK_EQ(v8_str("TypeError: Object 333 has no method 'method'"),
+  // TODO(verwaest): Adjust message.
+  CHECK_EQ(v8_str("TypeError: undefined is not a function"),
            try_catch.Exception()->ToString());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
   CHECK_GE(interceptor_call_count, 50);
 }
 
 
 THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_TypeError) {
   int interceptor_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
@@ skipping 153 matching lines @@
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = 333;"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
-  CHECK_EQ(v8_str("TypeError: Object 333 has no method 'method'"),
+  // TODO(verwaest): Adjust message.
+  CHECK_EQ(v8_str("TypeError: undefined is not a function"),
            try_catch.Exception()->ToString());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
 }
 
 
 THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature_TypeError) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Handle<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
@@ skipping 2690 matching lines @@
   const char* ascii_sources[] = {
     "0.5",
     "-0.5",   // This mainly testes PushBack in the Scanner.
     "--0.5",  // This mainly testes PushBack in the Scanner.
     NULL
   };
 
   // Compile the sources as external two byte strings.
   for (int i = 0; ascii_sources[i] != NULL; i++) {
     uint16_t* two_byte_string = AsciiToTwoByteString(ascii_sources[i]);
-    UC16VectorResource uc16_resource(
-        i::Vector<const uint16_t>(two_byte_string,
-                                  i::StrLength(ascii_sources[i])));
+    TestResource* uc16_resource = new TestResource(two_byte_string);
     v8::Local<v8::String> source =
-        v8::String::NewExternal(context->GetIsolate(), &uc16_resource);
+        v8::String::NewExternal(context->GetIsolate(), uc16_resource);
     v8::Script::Compile(source);
-    i::DeleteArray(two_byte_string);
   }
 }
 
 
 #ifndef V8_INTERPRETED_REGEXP
 
 struct RegExpInterruptionData {
   int loop_count;
   UC16VectorResource* string_resource;
   v8::Persistent<v8::String> string;
@@ skipping 2626 matching lines @@
 
 TEST(VisitExternalStrings) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   const char* string = "Some string";
   uint16_t* two_byte_string = AsciiToTwoByteString(string);
   TestResource* resource[4];
   resource[0] = new TestResource(two_byte_string);
   v8::Local<v8::String> string0 =
       v8::String::NewExternal(env->GetIsolate(), resource[0]);
-  resource[1] = new TestResource(two_byte_string);
+  resource[1] = new TestResource(two_byte_string, NULL, false);
   v8::Local<v8::String> string1 =
       v8::String::NewExternal(env->GetIsolate(), resource[1]);
 
   // Externalized symbol.
-  resource[2] = new TestResource(two_byte_string);
+  resource[2] = new TestResource(two_byte_string, NULL, false);
   v8::Local<v8::String> string2 = v8::String::NewFromUtf8(
       env->GetIsolate(), string, v8::String::kInternalizedString);
   CHECK(string2->MakeExternal(resource[2]));
 
   // Symbolized External.
   resource[3] = new TestResource(AsciiToTwoByteString("Some other string"));
   v8::Local<v8::String> string3 =
       v8::String::NewExternal(env->GetIsolate(), resource[3]);
   CcTest::heap()->CollectAllAvailableGarbage();  // Tenure string.
   // Turn into a symbol.
@@ skipping 1055 matching lines @@
   i::SmartArrayPointer<uintptr_t>
   aligned_contents(new uintptr_t[aligned_length]);
   uint16_t* string_contents =
       reinterpret_cast<uint16_t*>(aligned_contents.get());
   // Set to contain only one byte.
   for (int i = 0; i < length-1; i++) {
     string_contents[i] = 0x41;
   }
   string_contents[length-1] = 0;
   // Simple case.
-  Handle<String> string;
-  string = String::NewExternal(isolate, new TestResource(string_contents));
+  Handle<String> string =
+      String::NewExternal(isolate,
+                          new TestResource(string_contents, NULL, false));
   CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
   // Counter example.
   string = String::NewFromTwoByte(isolate, string_contents);
   CHECK(string->IsOneByte() && string->ContainsOnlyOneByte());
   // Test left right and balanced cons strings.
   Handle<String> base = String::NewFromUtf8(isolate, "a");
   Handle<String> left = base;
   Handle<String> right = base;
   for (int i = 0; i < 1000; i++) {
     left = String::Concat(base, left);
     right = String::Concat(right, base);
   }
   Handle<String> balanced = String::Concat(left, base);
   balanced = String::Concat(balanced, right);
   Handle<String> cons_strings[] = {left, balanced, right};
   Handle<String> two_byte =
-      String::NewExternal(isolate, new TestResource(string_contents));
+      String::NewExternal(isolate,
+                          new TestResource(string_contents, NULL, false));
+  USE(two_byte); USE(cons_strings);
   for (size_t i = 0; i < ARRAY_SIZE(cons_strings); i++) {
     // Base assumptions.
     string = cons_strings[i];
     CHECK(string->IsOneByte() && string->ContainsOnlyOneByte());
     // Test left and right concatentation.
     string = String::Concat(two_byte, cons_strings[i]);
     CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
     string = String::Concat(cons_strings[i], two_byte);
     CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
   }
   // Set bits in different positions
   // for strings of different lengths and alignments.
   for (int alignment = 0; alignment < 7; alignment++) {
     for (int size = 2; alignment + size < length; size *= 2) {
       int zero_offset = size + alignment;
       string_contents[zero_offset] = 0;
       for (int i = 0; i < size; i++) {
         int shift = 8 + (i % 7);
         string_contents[alignment + i] = 1 << shift;
         string = String::NewExternal(
-            isolate, new TestResource(string_contents + alignment));
+            isolate,
+            new TestResource(string_contents + alignment, NULL, false));
         CHECK_EQ(size, string->Length());
         CHECK(!string->ContainsOnlyOneByte());
         string_contents[alignment + i] = 0x41;
       }
       string_contents[zero_offset] = 0x41;
     }
   }
 }
 
 
@@ skipping 1587 matching lines @@
   v8::HandleScope scope(env->GetIsolate());
   int initial_probes = probes_counter;
   int initial_misses = misses_counter;
   int initial_updates = updates_counter;
   CompileRun(kMegamorphicTestProgram);
   int probes = probes_counter - initial_probes;
   int misses = misses_counter - initial_misses;
   int updates = updates_counter - initial_updates;
   CHECK_LT(updates, 10);
   CHECK_LT(misses, 10);
-  CHECK_GE(probes, 10000);
+  // TODO(verwaest): Update this test to overflow the degree of polymorphism
+  // before megamorphism. The number of probes will only work once we teach the
+  // serializer to embed references to counters in the stubs, given that the
+  // megamorphic_stub_cache_probes is updated in a snapshot-generated stub.
+  CHECK_GE(probes, 0);
 #endif
 }
 
 
 TEST(SecondaryStubCache) {
   StubCacheHelper(true);
 }
 
 
 TEST(PrimaryStubCache) {
@@ skipping 1225 matching lines @@
   context->Global()->Set(v8_str("P"), templ->NewInstance());
   CompileRun(
       "function C1() {"
       "  this.x = 23;"
       "};"
       "C1.prototype = P;"
       "for (var i = 0; i < 4; i++ ) {"
       "  new C1();"
       "}");
 }
+
+
+class ApiCallOptimizationChecker {
+ private:
+  static Local<Object> data;
+  static Local<Object> receiver;
+  static Local<Object> holder;
+  static Local<Object> callee;
+  static int count;
+
+  static void OptimizationCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info) {
+    CHECK(callee == info.Callee());
+    CHECK(data == info.Data());
+    CHECK(receiver == info.This());
+    CHECK(holder == info.Holder());
+    count++;
+  }
+
+  public:
+    void Run(bool use_signature, bool global) {
+      v8::Isolate* isolate = CcTest::isolate();
+      v8::HandleScope scope(isolate);
+      // Build a template for signature checks.
+      Local<v8::ObjectTemplate> signature_template;
+      Local<v8::Signature> signature;
+      {
+        Local<v8::FunctionTemplate> parent_template =
+          FunctionTemplate::New(isolate);
+        parent_template->SetHiddenPrototype(true);
+        Local<v8::FunctionTemplate> function_template
+            = FunctionTemplate::New(isolate);
+        function_template->Inherit(parent_template);
+        if (use_signature) {
+          signature = v8::Signature::New(isolate, parent_template);
+        }
+        signature_template = function_template->InstanceTemplate();
+      }
+      // Global object must pass checks.
+      Local<v8::Context> context =
+          v8::Context::New(isolate, NULL, signature_template);
+      v8::Context::Scope context_scope(context);
+      // Install regular object that can pass signature checks.
+      Local<Object> function_receiver = signature_template->NewInstance();
+      context->Global()->Set(v8_str("function_receiver"), function_receiver);
+      // Get the holder objects.
+      Local<Object> inner_global =
+          Local<Object>::Cast(context->Global()->GetPrototype());
+      Local<Object> function_holder =
+          Local<Object>::Cast(function_receiver->GetPrototype());
+      // Install function on hidden prototype object.
+      data = Object::New(isolate);
+      Local<FunctionTemplate> function_template = FunctionTemplate::New(
+          isolate, OptimizationCallback, data, signature);
+      Local<Function> function = function_template->GetFunction();
+      Local<Object>::Cast(
+          inner_global->GetPrototype())->Set(v8_str("global_f"), function);
+      function_holder->Set(v8_str("f"), function);
+      // Initialize expected values.
+      callee = function;
+      count = 0;
+      if (global) {
+        receiver = context->Global();
+        holder = inner_global;
+      } else {
+        holder = function_receiver;
+        // If not using a signature, add something else to the prototype chain
+        // to test the case that holder != receiver
+        if (!use_signature) {
+          receiver = Local<Object>::Cast(CompileRun(
+              "var receiver_subclass = {};\n"
+              "receiver_subclass.__proto__ = function_receiver;\n"
+              "receiver_subclass"));
+        } else {
+          receiver = Local<Object>::Cast(CompileRun(
+            "var receiver_subclass = function_receiver;\n"
+            "receiver_subclass"));
+        }
+      }
+      // With no signature, the holder is not set.
+      if (!use_signature) holder = receiver;
+      // build wrap_function
+      int key = (use_signature ? 1 : 0) + 2 * (global ? 1 : 0);
+      i::ScopedVector<char> wrap_function(100);
+      if (global) {
+        i::OS::SNPrintF(
+            wrap_function,
+           "function wrap_%d() { var f = global_f; return f(); }\n",
+            key);
+      } else {
+        i::OS::SNPrintF(
+            wrap_function,
+            "function wrap_%d() { return receiver_subclass.f(); }\n",
+            key);
+      }
+      // build source string
+      i::ScopedVector<char> source(500);
+      i::OS::SNPrintF(
+          source,
+          "%s\n"  // wrap_function
+          "function wrap2() { wrap_%d(); }\n"
+          "wrap2();\n"
+          "wrap2();\n"
+          "%%OptimizeFunctionOnNextCall(wrap_%d);\n"
+          "wrap2();\n",
+          wrap_function.start(), key, key);
+      v8::TryCatch try_catch;
+      CompileRun(source.start());
+      ASSERT(!try_catch.HasCaught());
+      CHECK_EQ(3, count);
+    }
+};
+
+
+Local<Object> ApiCallOptimizationChecker::data;
+Local<Object> ApiCallOptimizationChecker::receiver;
+Local<Object> ApiCallOptimizationChecker::holder;
+Local<Object> ApiCallOptimizationChecker::callee;
+int ApiCallOptimizationChecker::count = 0;
+
+
+TEST(TestFunctionCallOptimization) {
+  i::FLAG_allow_natives_syntax = true;
+  ApiCallOptimizationChecker checker;
+  checker.Run(true, true);
+  checker.Run(false, true);
+  checker.Run(true, false);
+  checker.Run(false, false);
+}