Simplify partitionReallocGeneric() implementation

Source/wtf/PartitionAllocTest.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 646 matching lines @@
 
     // realloc(0, size) should be equivalent to malloc().
     void* ptr = partitionReallocGeneric(genericAllocator.root(), 0, kTestAllocSize);
     memset(ptr, 'A', kTestAllocSize);
     WTF::PartitionPage* page = WTF::partitionPointerToPage(WTF::partitionCookieFreePointerAdjust(ptr));
     // realloc(ptr, 0) should be equivalent to free().
     void* ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, 0);
     EXPECT_EQ(0, ptr2);
     EXPECT_EQ(WTF::partitionCookieFreePointerAdjust(ptr), page->freelistHead);
 
+    // Test that growing an allocation with realloc() copies everything from the
+    // old allocation.
+    size_t size = WTF::kSystemPageSize - kExtraAllocSize;
+    EXPECT_EQ(size, partitionAllocActualSize(genericAllocator.root(), size));
+    ptr = partitionAllocGeneric(genericAllocator.root(), size);
+    memset(ptr, 'A', size);
+    ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, size + 1);
+    EXPECT_NE(ptr, ptr2);
+    char* charPtr2 = static_cast<char*>(ptr2);
+    EXPECT_EQ('A', charPtr2[0]);
+    EXPECT_EQ('A', charPtr2[size - 1]);
+#ifndef NDEBUG
+    EXPECT_EQ(WTF::kUninitializedByte, static_cast<unsigned char>(charPtr2[size]));
+#endif
+
+    // Test that shrinking an allocation with realloc() also copies everything
+    // from the old allocation.
+    ptr = partitionReallocGeneric(genericAllocator.root(), ptr2, size - 1);
+    EXPECT_NE(ptr2, ptr);
+    char* charPtr = static_cast<char*>(ptr);
+    EXPECT_EQ('A', charPtr[0]);
+    EXPECT_EQ('A', charPtr[size - 2]);
+#ifndef NDEBUG
+    EXPECT_EQ(WTF::kUninitializedByte, static_cast<unsigned char>(charPtr[size - 1]));

[Chris Evans, 2014/02/26 20:56:55]

I think "size - 1" is technically out of bounds here.
It's going to work out because of bucket sizing and the fact we only write debug
cookies at well-aligned addresses.

Feel free to leave it in or remove it.

[Jens Widell, 2014/02/27 07:18:13]

The test sets 'size' to be a "perfect fit" (and checks that it is using
partitionAllocActualSize().) I think it makes sense for the test to assume that
requesting 'size - 1' bytes then will actually give 'size' bytes, given the
basic design of the allocator.

The cookies are not just written at well-aligned addresses, they are written
inside the outer edges of the slot (as opposed to outside the outer edges of the
allocation.) This is in fact a requirement for partitionAllocGetSize()'s
returned size to be safe to use without trampling the cookies.
I'll leave it in, then. :-)

+#endif
+
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+
     TestShutdown();
 }
 
 // Tests the handing out of freelists for partial pages.
 TEST(WTF_PartitionAlloc, PartialPageFreelists)
 {
     TestSetup();
 
     size_t bigSize = allocator.root()->maxAllocation - kExtraAllocSize;
     EXPECT_EQ(WTF::kSystemPageSize - WTF::kAllocationGranularity, bigSize + kExtraAllocSize);
@@ skipping 447 matching lines @@
     EXPECT_EQ(32u, WTF::countLeadingZerosSizet(0));
     EXPECT_EQ(31u, WTF::countLeadingZerosSizet(1));
     EXPECT_EQ(1u, WTF::countLeadingZerosSizet(1 << 30));
     EXPECT_EQ(0u, WTF::countLeadingZerosSizet(1 << 31));
 #endif
 }
 
 } // namespace
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)