Enable per thread heap for database thread

third_party/WebKit/Source/platform/heap/Heap.h

 /*
  * 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 187 matching lines @@
         // The strongification of collections relies on the fact that once a
         // collection has been strongified, there is no way that it can contain
         // non-live entries, so no entries will be removed. Since you can't set
         // the mark bit on a null pointer, that means that null pointers are
         // always 'alive'.
         if (!object)
             return true;
         // TODO(keishi): some tests create CrossThreadPersistent on non attached threads.
         if (!ThreadState::current())
             return true;
-        DCHECK(&ThreadState::current()->heap() == &pageFromObject(object)->arena()->getThreadState()->heap());
+        if (&ThreadState::current()->heap() == &pageFromObject(object)->arena()->getThreadState()->heap())

[keishi, 2016/06/02 02:01:02]

During the code review, I changed this to a DCHECK but now I remember why this
was necessary.
PersistentBase::checkPointer calls isHeapObjectAlive even when it is a
CrossThreadPersistent.
We want to check if the pointer is an on-heap object even for
CrossThreadPersistent, so I think we should change it this way.
I missed this because checkPointer only runs in ASAN builds.

[haraken, 2016/06/02 02:23:31]

I don't quite understand why you want to unconditionally return true.

Won't it end up with returning true almost always? We want to return true only
when the heap object is *alive*.

[keishi, 2016/06/02 02:58:53]

Sorry forgot to flip the expression.

Cross thread references will return true here because we can't tell if its alive
or not.
Off heap objects crash here so its still useful for
PersistnetBase::checkPointer.

+            return true;
         return ObjectAliveTrait<T>::isHeapObjectAlive(object);
     }
     template<typename T>
     static inline bool isHeapObjectAlive(const Member<T>& member)
     {
         return isHeapObjectAlive(member.get());
     }
     template<typename T>
     static inline bool isHeapObjectAlive(const WeakMember<T>& member)
     {
@@ skipping 401 matching lines @@
 void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* object)
 {
     T** cell = reinterpret_cast<T**>(object);
     if (*cell && !ObjectAliveTrait<T>::isHeapObjectAlive(*cell))
         *cell = nullptr;
 }
 
 } // namespace blink
 
 #endif // Heap_h