CrossThreadPersistent invalidation: add missing orphaned check.

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 5654 matching lines @@
     }
 
     static volatile IntWrapper* s_workerObjectPointer;
 };
 
 TEST(HeapTest, RecursiveMutex)
 {
     RecursiveLockingTester::test();
 }
 
+class CrossThreadPersistentOnMainThreadTester {
+public:
+    static void test()
+    {
+        MutexLocker locker(mainThreadMutex());
+        OwnPtr<WebThread> workerThread = adoptPtr(Platform::current()->createThread("Test Worker Thread"));
+        workerThread->postTask(FROM_HERE, new Task(threadSafeBind(workerThreadMain)));
+
+        parkMainThread();
+
+        // (Temporarily) detach main thread and wake the worker thread, so that it
+        // can do its detach().
+        ThreadState::detachMainThread();
+        wakeWorkerThread();
+
+        parkMainThread();
+        ThreadState::attachMainThread();
+    }
+
+private:
+
+    static void workerThreadMain()
+    {
+        MutexLocker locker(workerThreadMutex());
+
+        // Start up a worker thread and have it detach after the main thread has.
+        // Do this to verify that CrossThreadPersistent<>s referring to objects
+        // on one of the main thread's heaps does not upset the CTP invalidation
+        // pass that ThreadState::detach() performs.
+        ThreadState::attach();
+
+        CrossThreadPersistent<IntWrapper> persistent(IntWrapper::create(43));
+
+        // Wait for the main thread to detach.
+        wakeMainThread();
+        parkWorkerThread();
+
+        ThreadState::detach();
+        wakeMainThread();
+    }
+};
+
+TEST(HeapTest, CrossThreadPersistentOnMainThread)
+{
+    CrossThreadPersistent<IntWrapper> persistent(IntWrapper::create(42));
+    CrossThreadPersistentOnMainThreadTester::test();
+}
+
 template<typename T>
 class TraceIfNeededTester : public GarbageCollectedFinalized<TraceIfNeededTester<T>> {
 public:
     static TraceIfNeededTester<T>* create() { return new TraceIfNeededTester<T>(); }
     static TraceIfNeededTester<T>* create(const T& obj) { return new TraceIfNeededTester<T>(obj); }
     DEFINE_INLINE_TRACE() { TraceIfNeeded<T>::trace(visitor, m_obj); }
     T& obj() { return m_obj; }
     ~TraceIfNeededTester() { }
 private:
     TraceIfNeededTester() { }
@@ skipping 622 matching lines @@
     Persistent<IntWrapper> object = new IntWrapper(20);
     OwnPtr<WeakPersistentHolder> holder = adoptPtr(new WeakPersistentHolder(object));
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
     EXPECT_TRUE(holder->object());
     object = nullptr;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGC);
     EXPECT_FALSE(holder->object());
 }
 
 } // namespace blink