Version 3.27.34.7 (merged r22223)

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 19527 matching lines @@
         constraints.set_max_old_space_size(4);
         v8::SetResourceConstraints(CcTest::isolate(), &constraints);
         break;
       }
 
       case SetFatalHandler:
         v8::V8::SetFatalErrorHandler(NULL);
         break;
 
       case SetCounterFunction:
-        v8::V8::SetCounterFunction(NULL);
+        CcTest::isolate()->SetCounterFunction(NULL);
         break;
 
       case SetCreateHistogramFunction:
-        v8::V8::SetCreateHistogramFunction(NULL);
+        CcTest::isolate()->SetCreateHistogramFunction(NULL);
         break;
 
       case SetAddHistogramSampleFunction:
-        v8::V8::SetAddHistogramSampleFunction(NULL);
+        CcTest::isolate()->SetAddHistogramSampleFunction(NULL);
         break;
     }
     isolate->Exit();
     isolate->Dispose();
     result_ = true;
   }
 
   bool result() { return result_; }
 
  private:
@@ skipping 1330 matching lines @@
   }
   isolate->RunMicrotasks();
   {
     Context::Scope context_scope(context);
     CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
   }
   isolate->SetAutorunMicrotasks(true);
 }
 
 
+#ifdef DEBUG
 static int probes_counter = 0;
 static int misses_counter = 0;
 static int updates_counter = 0;
 
 
 static int* LookupCounter(const char* name) {
   if (strcmp(name, "c:V8.MegamorphicStubCacheProbes") == 0) {
     return &probes_counter;
   } else if (strcmp(name, "c:V8.MegamorphicStubCacheMisses") == 0) {
     return &misses_counter;
   } else if (strcmp(name, "c:V8.MegamorphicStubCacheUpdates") == 0) {
     return &updates_counter;
   }
   return NULL;
 }
 
 
 static const char* kMegamorphicTestProgram =
     "function ClassA() { };"
     "function ClassB() { };"
     "ClassA.prototype.foo = function() { };"
     "ClassB.prototype.foo = function() { };"
     "function fooify(obj) { obj.foo(); };"
     "var a = new ClassA();"
     "var b = new ClassB();"
     "for (var i = 0; i < 10000; i++) {"
     "  fooify(a);"
     "  fooify(b);"
     "}";
+#endif
 
 
 static void StubCacheHelper(bool primary) {
-  V8::SetCounterFunction(LookupCounter);
-  USE(kMegamorphicTestProgram);
 #ifdef DEBUG
   i::FLAG_native_code_counters = true;
   if (primary) {
     i::FLAG_test_primary_stub_cache = true;
   } else {
     i::FLAG_test_secondary_stub_cache = true;
   }
   i::FLAG_crankshaft = false;
   LocalContext env;
+  env->GetIsolate()->SetCounterFunction(LookupCounter);
   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);
   // 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) {
   StubCacheHelper(false);
 }
 
 
+#ifdef DEBUG
 static int cow_arrays_created_runtime = 0;
 
 
 static int* LookupCounterCOWArrays(const char* name) {
   if (strcmp(name, "c:V8.COWArraysCreatedRuntime") == 0) {
     return &cow_arrays_created_runtime;
   }
   return NULL;
 }
+#endif
 
 
 TEST(CheckCOWArraysCreatedRuntimeCounter) {
-  V8::SetCounterFunction(LookupCounterCOWArrays);
 #ifdef DEBUG
   i::FLAG_native_code_counters = true;
   LocalContext env;
+  env->GetIsolate()->SetCounterFunction(LookupCounterCOWArrays);
   v8::HandleScope scope(env->GetIsolate());
   int initial_cow_arrays = cow_arrays_created_runtime;
   CompileRun("var o = [1, 2, 3];");
   CHECK_EQ(1, cow_arrays_created_runtime - initial_cow_arrays);
   CompileRun("var o = {foo: [4, 5, 6], bar: [3, 0]};");
   CHECK_EQ(3, cow_arrays_created_runtime - initial_cow_arrays);
   CompileRun("var o = {foo: [1, 2, 3, [4, 5, 6]], bar: 'hi'};");
   CHECK_EQ(4, cow_arrays_created_runtime - initial_cow_arrays);
 #endif
 }
@@ skipping 1794 matching lines @@
     call_eval_context = v8::Context::New(isolate);
     v8::Context::Scope scope(call_eval_context);
     call_eval_bound_function =
         Local<Function>::Cast(CompileRun("eval.bind(this, '1')"));
   }
   env->Global()->Set(v8_str("CallEval"),
       v8::FunctionTemplate::New(isolate, CallEval)->GetFunction());
   Local<Value> result = CompileRun("CallEval();");
   CHECK_EQ(result, v8::Integer::New(isolate, 1));
 }