Reapply: [oilpan]: Change marking to do precise roots first and conservative

Source/platform/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 4654 matching lines @@
 
             // Nothing should have been collected/destructed.
             EXPECT_EQ(0, CrossThreadObject::s_destructorCalls);
             EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 
             // Put cto into a stack value. This is used to check that a conservative
             // GC succeeds even though we are tracing the other thread heap after
             // shutting it down.
             stackPtrValue = reinterpret_cast<uintptr_t>(cto.get());
         }
-        RELEASE_ASSERT(stackPtrValue);
-
         // At this point it is "programatically" okay to shut down the worker thread
         // since the cto object should be dead. However out stackPtrValue will cause a
         // trace of the object when doing a conservative GC.
         // The worker thread's thread local GC's should just add the worker thread's
         // pages to the heap after finalizing IntWrapper.
         wakeWorkerThread();
 
         // Wait for the worker to shutdown.
         parkMainThread();
 
         // After the worker thread has detached it should have finalized the
         // IntWrapper object on its heaps. Since there has been no global GC
         // the cto object should not have been finalized.
         EXPECT_EQ(0, CrossThreadObject::s_destructorCalls);
         EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 
         // Now do a conservative GC. The stackPtrValue should keep cto alive
         // and will also cause the orphaned page of the other thread to be
         // traced. At this point cto should still not be finalized.
         Heap::collectGarbage(ThreadState::HeapPointersOnStack);
         EXPECT_EQ(0, CrossThreadObject::s_destructorCalls);
         EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 
+        // This release assert is here to ensure the stackValuePtr is not
+        // optimized away before doing the above conservative GC. If the
+        // EXPECT_EQ(0, CrossThreadObject::s_destructorCalls) call above
+        // starts failing it means we have to find a better way to ensure
+        // the stackPtrValue is not optimized away.
+        RELEASE_ASSERT(stackPtrValue);
+
         // Do a GC with no pointers on the stack to see the cto being collected.
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(1, CrossThreadObject::s_destructorCalls);
         EXPECT_EQ(1, IntWrapper::s_destructorCalls);
     }
 
 private:
     static void workerThreadMain(void* data)
     {
         MutexLocker locker(workerThreadMutex());
@@ skipping 328 matching lines @@
     {
         TraceIfNeededTester<HeapVector<Member<SimpleObject> > >* m_vec = TraceIfNeededTester<HeapVector<Member<SimpleObject> > >::create();
         m_vec->obj().append(SimpleObject::create());
         visitor.reset();
         m_vec->trace(&visitor);
         EXPECT_EQ(2u, visitor.count());
     }
 }
 
 } // namespace blink