Oilpan: move 2D Canvas and WebGL objects to the heap.

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 658 matching lines @@
 
 template<typename T>
 class TraceTrait<OwnPtr<T> > {
 public:
     static void trace(Visitor* visitor, OwnPtr<T>* ptr)
     {
         TraceTrait<T>::trace(visitor, ptr->get());
     }
 };
 
-template<bool needsTracing, typename T>
-struct StdPairHelper;
+template<typename T, bool needsTracing>
+struct TraceIfEnabled;
 
 template<typename T>
-struct StdPairHelper<false, T>  {
+struct TraceIfEnabled<T, false>  {
     static void trace(Visitor*, T*) { }
 };
 
 template<typename T>
-struct StdPairHelper<true, T> {
+struct TraceIfEnabled<T, true> {
     static void trace(Visitor* visitor, T* t)
     {
         visitor->trace(*t);
     }
 };
 
+template <typename T> struct RemoveHeapPointerWrapperTypes {
+    typedef typename WTF::RemoveTemplate<typename WTF::RemoveTemplate<typename WTF::RemoveTemplate<T, Member>::Type, WeakMember>::Type, RawPtr>::Type Type;
+};
+
+template<typename T>
+struct TraceIfNeeded : public TraceIfEnabled<T, WebCore::IsGarbageCollectedType<typename RemoveHeapPointerWrapperTypes<typename WTF::RemovePointer<T>::Type>::Type>::value> { };

[zerny-chromium, 2014/08/01 08:05:15]

I don't think this trait does what we would like it to do. It is used in
Nullable (and ScriptPromiseProperty) to trace a (nullable) value object. So
first of all it is more lax in that it is also defined for non-values (ie, all
GC derived types) when it is only used for part-object allocated collections.
More importantly it is too narrow since it will not identify that a value object
with a trace method should be traced (ie, any object using DISALLOW_ALLOCATION
but with traced fields).

In short, I think we should use the existing NeedsTracing trait here. It is
default defined to be true if the type has a trace method and specialized for
the various other types (eg, Member) already. I'll upload a CL shortly.

+
 // This trace trait for std::pair will null weak members if their referent is
 // collected. If you have a collection that contain weakness it does not remove
 // entries from the collection that contain nulled weak members.
 template<typename T, typename U>
 class TraceTrait<std::pair<T, U> > {
 public:
     static const bool firstNeedsTracing = WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value;
     static const bool secondNeedsTracing = WTF::NeedsTracing<U>::value || WTF::IsWeak<U>::value;
     static void trace(Visitor* visitor, std::pair<T, U>* pair)
     {
-        StdPairHelper<firstNeedsTracing, T>::trace(visitor, &pair->first);
-        StdPairHelper<secondNeedsTracing, U>::trace(visitor, &pair->second);
+        TraceIfEnabled<T, firstNeedsTracing>::trace(visitor, &pair->first);
+        TraceIfEnabled<U, secondNeedsTracing>::trace(visitor, &pair->second);
     }
 };
 
 // WeakMember is similar to Member in that it is used to point to other oilpan
 // heap allocated objects.
 // However instead of creating a strong pointer to the object, the WeakMember creates
 // a weak pointer, which does not keep the pointee alive. Hence if all pointers to
 // to a heap allocated object are weak the object will be garbage collected. At the
 // time of GC the weak pointers will automatically be set to null.
 template<typename T>
@@ skipping 473 matching lines @@
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
 };
 
 } // namespace WTF
 
 #endif