Remove a bunch of Isolate::UncheckedCurrent calls

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 19477 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 1362 matching lines @@
     CompileRun("var obj = {};"
                "Object.observe(obj, function(changes) { debugger; });"
                "obj.a = 0;");
   }
   isolate->RunMicrotasks();
   isolate->SetAutorunMicrotasks(true);
   v8::Debug::SetDebugEventListener(NULL);
 }
 
 
+#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 1904 matching lines @@
   desc = x->GetOwnPropertyDescriptor(v8_str("p1"));
   Local<Function> set =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("set")));
   Local<Function> get =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("get")));
   CHECK_EQ(v8_num(13), get->Call(x, 0, NULL));
   Handle<Value> args[] = { v8_num(14) };
   set->Call(x, 1, args);
   CHECK_EQ(v8_num(14), get->Call(x, 0, NULL));
 }