Adapt code flushing tests to new code aging.

test/cctest/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "compilation-cache.h"
 #include "execution.h"
 #include "factory.h"
 #include "macro-assembler.h"
@@ skipping 1098 matching lines @@
   CHECK(function2->shared()->is_compiled());
 
   // Clear references to functions so that one of them can die.
   { v8::HandleScope scope;
     CompileRun("foo = 0; bar = 0;");
   }
 
   // Bump the code age so that flushing is triggered while the function
   // object is still located in new-space.
   const int kAgingThreshold = 6;
-  function->shared()->set_code_age(kAgingThreshold);
-  function2->shared()->set_code_age(kAgingThreshold);
+  for (int i = 0; i < kAgingThreshold; i++) {
+    function->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
+    function2->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
+  }
 
   // Simulate incremental marking so that the functions are enqueued as
   // code flushing candidates. Then kill one of the functions. Finally
   // perform a scavenge while incremental marking is still running.
   SimulateIncrementalMarking();
   *function2.location() = NULL;
   HEAP->CollectGarbage(NEW_SPACE, "test scavenge while marking");
 
   // Simulate one final GC to make sure the candidate queue is sane.
   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
@@ skipping 28 matching lines @@
   Handle<JSFunction> function(JSFunction::cast(func_value));
   CHECK(function->shared()->is_compiled());
 
   // The code will survive at least two GCs.
   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
   CHECK(function->shared()->is_compiled());
 
   // Bump the code age so that flushing is triggered.
   const int kAgingThreshold = 6;
-  function->shared()->set_code_age(kAgingThreshold);
+  for (int i = 0; i < kAgingThreshold; i++) {
+    function->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
+  }
 
   // Simulate incremental marking so that the function is enqueued as
   // code flushing candidate.
   SimulateIncrementalMarking();
 
   // Enable the debugger and add a breakpoint while incremental marking
   // is running so that incremental marking aborts and code flushing is
   // disabled.
   int position = 0;
   Handle<Object> breakpoint_object(Smi::FromInt(0));
@@ skipping 1317 matching lines @@
   Handle<Object> call_function(call);
 
   // Now we are ready to mess up the heap.
   HEAP->CollectAllGarbage(Heap::kReduceMemoryFootprintMask);
 
   // Either heap verification caught the problem already or we go kaboom once
   // the CallIC is executed the next time.
   USE(global->SetProperty(*name, *call_function, NONE, kNonStrictMode));
   CompileRun("call();");
 }