Fix links in Source/wtf/Allocator.md

third_party/WebKit/Source/wtf/Allocator.md

 # Memory management in Blink
 
 This document gives a high-level overview of the memory management in Blink.
 
 [TOC]
 
 ## Memory allocators
 
 Blink objects are allocated by one of the following four memory allocators.
 
 ### Oilpan
 
 Oilpan is a garbage collection system in Blink.
 The lifetime of objects allocated by Oilpan is automatically managed.
 The following objects are allocated by Oilpan:
 
 * Objects that inherit from GarbageCollected<T> or GarbageCollectedFinalized<T>.
 
 * HeapVector<T>, HeapHashSet<T>, HeapHashMap<T, U> etc
 
 The implementation is in platform/heap/.
-See [BlinkGCDesign.md](platform/heap/BlinkGCDesign.md) to learn the design.
+See [BlinkGCDesign.md](../platform/heap/BlinkGCDesign.md) to learn the design.
 
 ### PartitionAlloc
 
 PartitionAlloc is Blink's default memory allocator.
 PartitionAlloc is highly optimized for performance and security requirements
 in Blink. All Blink objects that don't need a GC or discardable memory should be
 allocated by PartitionAlloc (instead of malloc).
 The following objects are allocated by PartitionAlloc:
 
 * Objects that have a USING_FAST_MALLOC macro.
 
 * Nodes (which will be moved to Oilpan in the near future)
 
 * LayoutObjects
 
 * Strings, Vectors, HashTables, ArrayBuffers and other primitive containers.
 
-The implementation is in wtf/Partition*.
-See [PartitionAlloc.md](wtf/PartitionAlloc.md) to learn the design.
+The implementation is in /base/allocator/partition_allocator.
+See [PartitionAlloc.md](/base/allocator/partition_allocator/PartitionAlloc.md)
+to learn the design.
 
 ### Discardable memory
 
 Discardable memory is a memory allocator that automatically discards
 (not-locked) objects under memory pressure. Currently SharedBuffers
 (which are mainly used as backing storage of Resource objects) are the only
 user of the discardable memory.
 
 The implementation is in src/base/memory/discardable_memory.*.
 See [this document](https://docs.google.com/document/d/1aNdOF_72_eG2KUM_z9kHdbT_fEupWhaDALaZs5D8IAg/edit)
@@ skipping 14 matching lines @@
 
 In summary, Blink objects (except several special objects) should be allocated
 using Oilpan or PartitionAlloc. malloc is discouraged.
 
 The following is a basic rule to determine which of Oilpan or PartitionAlloc
 you should use when allocating a new object:
 
 * Use Oilpan if you want a GC to manage the lifetime of the object.
 You need to make the object inherit from GarbageCollected<T> or
 GarbageCollectedFinalized<T>. See
-[BlinkGCAPIReference.md](platform/heap/BlinkGCAPIReference.md) to learn
+[BlinkGCAPIReference.md](../platform/heap/BlinkGCAPIReference.md) to learn
 programming with Oilpan.
 
 ```c++
 class X : public GarbageCollected<X> {
   ...;
 };
 
 void func() {
   X* x = new X;  // This is allocated by Oilpan.
 }
@@ skipping 89 matching lines @@
 void func() {
   X x;  // This is allowed.
   X* x = new X;  // This is forbidden.
 }
 ```
 
 Note that these macros are inherited. See a comment in wtf/Allocator.h
 for more details about the relationship between the macros and Oilpan.
 
 If you have any question, ask oilpan-reviews@chromium.org.