Enable per thread heap for database thread

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

 /*
  * Copyright (C) 2014 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 392 matching lines @@
     CrossThreadPersistent() : Parent() { }
     CrossThreadPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadPersistent(T* raw) : Parent(raw) { }
     CrossThreadPersistent(T& raw) : Parent(raw) { }
     CrossThreadPersistent(const CrossThreadPersistent& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const CrossThreadPersistent<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const Member<U>& other) : Parent(other) { }
 
+    CrossThreadPersistent(WTF::HashTableDeletedValueType) : Parent(reinterpret_cast<T*>(-1))
+    {
+    }
+
+    bool isHashTableDeletedValue() const { return *this == reinterpret_cast<T*>(-1); }
+
     T* atomicGet() { return Parent::atomicGet(); }
 
     template<typename U>
     CrossThreadPersistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     CrossThreadPersistent& operator=(std::nullptr_t)
@@ skipping 686 matching lines @@
 template <typename T>
 struct WeakMemberHash : MemberHash<T> {
     STATIC_ONLY(WeakMemberHash);
 };
 
 template <typename T>
 struct UntracedMemberHash : MemberHash<T> {
     STATIC_ONLY(UntracedMemberHash);
 };
 
+template <typename T>
+struct CrossThreadPersistentHash : MemberHash<T> {
+    STATIC_ONLY(CrossThreadPersistentHash);
+};
+
 // PtrHash is the default hash for hash tables with members.
 template <typename T>
 struct DefaultHash<blink::Member<T>> {
     STATIC_ONLY(DefaultHash);
     using Hash = MemberHash<T>;
 };
 
 template <typename T>
 struct DefaultHash<blink::WeakMember<T>> {
     STATIC_ONLY(DefaultHash);
     using Hash = WeakMemberHash<T>;
 };
 
 template <typename T>
 struct DefaultHash<blink::UntracedMember<T>> {
     STATIC_ONLY(DefaultHash);
     using Hash = UntracedMemberHash<T>;
 };
 
+template <typename T>
+struct DefaultHash<blink::CrossThreadPersistent<T>> {
+    STATIC_ONLY(DefaultHash);
+    using Hash = CrossThreadPersistentHash<T>;
+};
+
 template<typename T>
 struct NeedsTracing<blink::Member<T>> {
     STATIC_ONLY(NeedsTracing);
     static const bool value = true;
 };
 
 template<typename T>
 struct IsWeak<blink::WeakMember<T>> {
     STATIC_ONLY(IsWeak);
     static const bool value = true;
@@ skipping 65 matching lines @@
     // into it.
     //
     // TODO(sof): remove this hack once wtf/Functional.h can also work with a type like
     // CrossThreadWeakPersistent<>.
     static WeakPtr<T> unwrap(const StorageType& value) { return WeakPtr<T>(WeakReference<T>::create(value.get())); }
 };
 
 } // namespace WTF
 
 #endif