Oilpan: avoid ODR warning when linking heap unit tests.

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 713 matching lines @@
     static int s_destructorCalls;
 
     DEFINE_INLINE_TRACE() { }
 
 private:
     SimpleFinalizedObject() { }
 };
 
 int SimpleFinalizedObject::s_destructorCalls = 0;
 
-class Node : public GarbageCollected<Node> {
+class IntNode : public GarbageCollected<IntNode> {
 public:
-    static Node* create(int i)
+    static IntNode* create(int i)
     {
-        return new Node(i);
+        return new IntNode(i);
     }
 
     DEFINE_INLINE_TRACE() { }
 
     int value() { return m_value; }
 
 private:
-    Node(int i) : m_value(i) { }
+    IntNode(int i) : m_value(i) { }
     int m_value;
 };
 
+// IntNode is used to test typed heap allocation. Instead of
+// redefining blink::Node to our test version, we keep it separate
+// so as to avoid possible warnings about linker duplicates.
+// Provide a HeapIndexTrait<> specialization to assign the test
+// object to Node's typed heap instead.
+//
+// FIXME: untangling the heap unit tests from Blink would simplify
+// and avoid running into this problem - http://crbug.com/425381
+template<>
+struct HeapIndexTrait<IntNode> {
+    static int index() { return NodeHeapIndex; }
+};
+
 class Bar : public GarbageCollectedFinalized<Bar> {
 public:
     static Bar* create()
     {
         return new Bar();
     }
 
     void finalizeGarbageCollectedObject()
     {
         EXPECT_TRUE(m_magic == magic);
@@ skipping 1081 matching lines @@
     // Destructors not called again when GCing again.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGCForTesting);
     EXPECT_EQ(2, HeapTestSubClass::s_destructorCalls);
     EXPECT_EQ(3, HeapTestSuperClass::s_destructorCalls);
 }
 
 TEST(HeapTest, TypedHeapSanity)
 {
     // We use TraceCounter for allocating an object on the general heap.
     Persistent<TraceCounter> generalHeapObject = TraceCounter::create();
-    Persistent<Node> typedHeapObject = Node::create(0);
+    Persistent<IntNode> typedHeapObject = IntNode::create(0);
     EXPECT_NE(pageFromObject(generalHeapObject.get()),
         pageFromObject(typedHeapObject.get()));
 }
 
 TEST(HeapTest, NoAllocation)
 {
     ThreadState* state = ThreadState::current();
     EXPECT_TRUE(state->isAllocationAllowed());
     {
         // Disallow allocation
@@ skipping 3532 matching lines @@
 {
     AllocInSuperConstructorArgument* object = new AllocInSuperConstructorArgument();
     EXPECT_TRUE(object);
     Heap::collectAllGarbage();
 }
 
 class NonNodeAllocatingNodeInDestructor : public GarbageCollectedFinalized<NonNodeAllocatingNodeInDestructor> {
 public:
     ~NonNodeAllocatingNodeInDestructor()
     {
-        s_node = new Persistent<Node>(Node::create(10));
+        s_node = new Persistent<IntNode>(IntNode::create(10));
     }
 
     DEFINE_INLINE_TRACE() { }
 
-    static Persistent<Node>* s_node;
+    static Persistent<IntNode>* s_node;
 };
 
-Persistent<Node>* NonNodeAllocatingNodeInDestructor::s_node = 0;
+Persistent<IntNode>* NonNodeAllocatingNodeInDestructor::s_node = 0;
 
 TEST(HeapTest, NonNodeAllocatingNodeInDestructor)
 {
     new NonNodeAllocatingNodeInDestructor();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::GCWithSweep, Heap::ForcedGCForTesting);
     EXPECT_EQ(10, (*NonNodeAllocatingNodeInDestructor::s_node)->value());
     delete NonNodeAllocatingNodeInDestructor::s_node;
     NonNodeAllocatingNodeInDestructor::s_node = 0;
 }
 
@@ skipping 252 matching lines @@
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 } // namespace blink