Replace blink::WebDiscardableMemory with base::DiscardableMemory.

third_party/WebKit/Source/platform/PurgeableVectorTest.cpp

Index: third_party/WebKit/Source/platform/PurgeableVectorTest.cpp
diff --git a/third_party/WebKit/Source/platform/PurgeableVectorTest.cpp b/third_party/WebKit/Source/platform/PurgeableVectorTest.cpp
index f2fbcd8c3acdc8d9d0eab946199ab809512668a9..30fe98c6cf8e599db703b8acf23e8f65a9adcbf3 100644
--- a/third_party/WebKit/Source/platform/PurgeableVectorTest.cpp
+++ b/third_party/WebKit/Source/platform/PurgeableVectorTest.cpp
@@ -30,8 +30,6 @@
 
 #include "platform/PurgeableVector.h"
 
-#include "platform/testing/TestingPlatformSupport.h"
-#include "public/platform/WebDiscardableMemory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Vector.h"
 #include <algorithm>
@@ -41,49 +39,24 @@ namespace blink {
 
 const size_t kTestSize = 32 * 1024;
 
-enum DiscardableMemorySupport {
-    DontSupportDiscardableMemory,
-    SupportDiscardableMemory,
+class PurgeableVectorTestWithDiscardableMemory : public testing::TestWithParam<PurgeableVector::PurgeableOption> {
 };
 
-class PurgeableVectorTestWithPlatformSupport : public testing::TestWithParam<DiscardableMemorySupport> {
-public:
-    PurgeableVectorTestWithPlatformSupport() : m_testingPlatformSupport(makeTestingPlatformSupportConfig()) { }
-
-protected:
-    bool isDiscardableMemorySupported() const { return GetParam() == SupportDiscardableMemory; }
-
-    TestingPlatformSupport::Config makeTestingPlatformSupportConfig() const
-    {
-        TestingPlatformSupport::Config config;
-        config.hasDiscardableMemorySupport = isDiscardableMemorySupported();
-        return config;
-    }
-
-    PurgeableVector::PurgeableOption makePurgeableOption() const
-    {
-        return isDiscardableMemorySupported() ? PurgeableVector::Purgeable : PurgeableVector::NotPurgeable;
-    }
-
-private:
-    TestingPlatformSupport m_testingPlatformSupport;
-};
-
-TEST_P(PurgeableVectorTestWithPlatformSupport, grow)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, grow)
 {
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     purgeableVector.grow(kTestSize);
     ASSERT_EQ(kTestSize, purgeableVector.size());
     // Make sure the underlying buffer was actually (re)allocated.
     memset(purgeableVector.data(), 0, purgeableVector.size());
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, clear)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, clear)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
 
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     purgeableVector.append(testData.data(), testData.size());
     EXPECT_EQ(testData.size(), purgeableVector.size());
 
@@ -92,29 +65,29 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, clear)
     EXPECT_EQ(0, purgeableVector.data());
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, clearDoesNotResetLockCounter)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, clearDoesNotResetLockCounter)
 {
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     purgeableVector.clear();
     EXPECT_TRUE(purgeableVector.isLocked());
     purgeableVector.unlock();
     EXPECT_FALSE(purgeableVector.isLocked());
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, reserveCapacityDoesNotChangeSize)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, reserveCapacityDoesNotChangeSize)
 {
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     EXPECT_EQ(0U, purgeableVector.size());
     purgeableVector.reserveCapacity(kTestSize);
     EXPECT_EQ(0U, purgeableVector.size());
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, multipleAppends)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, multipleAppends)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
 
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     // Force an allocation.
     const char kSmallString[] = "hello";
     purgeableVector.append(kSmallString, sizeof(kSmallString));
@@ -135,12 +108,12 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, multipleAppends)
     EXPECT_EQ(0, memcmp(purgeableVector.data() + sizeof(kSmallString), testData.data(), testData.size()));
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, multipleAppendsAfterReserveCapacity)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, multipleAppendsAfterReserveCapacity)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
 
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     purgeableVector.reserveCapacity(testData.size());
     const char* const data = purgeableVector.data();
 
@@ -159,12 +132,12 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, multipleAppendsAfterReserveCapaci
     EXPECT_EQ(0, memcmp(purgeableVector.data(), testData.data(), testData.size()));
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, reserveCapacityUsesExactCapacityWhenVectorIsEmpty)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, reserveCapacityUsesExactCapacityWhenVectorIsEmpty)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
 
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     purgeableVector.reserveCapacity(kTestSize);
     const char* const data = purgeableVector.data();
 
@@ -175,7 +148,7 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, reserveCapacityUsesExactCapacityW
     // This test is not reliable if the PurgeableVector uses a plain WTF::Vector
     // for storage, as it does if discardable memory is not supported; the vectors
     // capacity will always be expanded to fill the PartitionAlloc bucket.
-    if (isDiscardableMemorySupported()) {
+    if (GetParam() == PurgeableVector::Purgeable) {
         // Appending one extra byte should cause a reallocation since the first
         // allocation happened while the purgeable vector was empty. This behavior
         // helps us guarantee that there is no memory waste on very small vectors
@@ -185,12 +158,12 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, reserveCapacityUsesExactCapacityW
     }
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, appendReservesCapacityIfNeeded)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, appendReservesCapacityIfNeeded)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
 
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     // No reserveCapacity().
     ASSERT_FALSE(purgeableVector.data());
 
@@ -199,20 +172,20 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, appendReservesCapacityIfNeeded)
     ASSERT_EQ(0, memcmp(purgeableVector.data(), testData.data(), testData.size()));
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, adopt)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, adopt)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
     const Vector<char> testDataCopy(testData);
     const char* const testDataPtr = testData.data();
 
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     purgeableVector.adopt(testData);
     EXPECT_TRUE(testData.isEmpty());
     EXPECT_EQ(kTestSize, purgeableVector.size());
     ASSERT_EQ(0, memcmp(purgeableVector.data(), testDataCopy.data(), testDataCopy.size()));
 
-    if (isDiscardableMemorySupported()) {
+    if (GetParam() == PurgeableVector::Purgeable) {
         // An extra discardable memory allocation + memcpy() should have happened.
         EXPECT_NE(testDataPtr, purgeableVector.data());
     } else {
@@ -221,14 +194,14 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, adopt)
     }
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, adoptEmptyVector)
+TEST_P(PurgeableVectorTestWithDiscardableMemory, adoptEmptyVector)
 {
     Vector<char> testData;
-    PurgeableVector purgeableVector(makePurgeableOption());
+    PurgeableVector purgeableVector(GetParam());
     purgeableVector.adopt(testData);
 }
 
-TEST(PurgeableVectorTestWithPlatformSupport, adoptDiscardsPreviousData)
+TEST(PurgeableVectorTest, adoptDiscardsPreviousData)
 {
     Vector<char> testData;
     std::generate(testData.begin(), testData.end(), &std::rand);
@@ -243,7 +216,7 @@ TEST(PurgeableVectorTestWithPlatformSupport, adoptDiscardsPreviousData)
     ASSERT_EQ(0, memcmp(purgeableVector.data(), testData.data(), testData.size()));
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, unlockWithoutHintAtConstruction)
+TEST(PurgeableVectorTest, unlockWithoutHintAtConstruction)
 {
     Vector<char> testData(30000);
     std::generate(testData.begin(), testData.end(), &std::rand);
@@ -258,17 +231,12 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, unlockWithoutHintAtConstruction)
 
     // Note that the purgeable vector must be locked before calling data().
     const bool wasPurged = !purgeableVector.lock();
-    if (isDiscardableMemorySupported()) {
-        // The implementation of purgeable memory used for testing always purges data upon unlock().
-        EXPECT_TRUE(wasPurged);
-    }
 
-    if (isDiscardableMemorySupported()) {
-        // The data should have been moved from the heap-allocated vector to a purgeable buffer.
-        ASSERT_NE(data, purgeableVector.data());
-    } else {
-        ASSERT_EQ(data, purgeableVector.data());
-    }
+    // The implementation of purgeable memory used for testing always purges data upon unlock().
+    EXPECT_TRUE(wasPurged);
+
+    // The data should have been moved from the heap-allocated vector to a purgeable buffer.
+    ASSERT_NE(data, purgeableVector.data());
 
     if (!wasPurged)
         ASSERT_EQ(0, memcmp(purgeableVector.data(), testData.data(), length));
@@ -282,7 +250,7 @@ TEST(PurgeableVectorTest, unlockOnEmptyPurgeableVector)
     ASSERT_FALSE(purgeableVector.isLocked());
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, unlockOnPurgeableVectorWithPurgeableHint)
+TEST(PurgeableVectorTest, unlockOnPurgeableVectorWithPurgeableHint)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
@@ -300,7 +268,7 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, unlockOnPurgeableVectorWithPurgea
     EXPECT_EQ(data, purgeableVector.data());
 }
 
-TEST_P(PurgeableVectorTestWithPlatformSupport, lockingUsesACounter)
+TEST(PurgeableVectorTest, lockingUsesACounter)
 {
     Vector<char> testData(kTestSize);
     std::generate(testData.begin(), testData.end(), &std::rand);
@@ -309,7 +277,7 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, lockingUsesACounter)
     purgeableVector.append(testData.data(), testData.size());
     ASSERT_EQ(testData.size(), purgeableVector.size());
 
-    ASSERT_TRUE(purgeableVector.isLocked()); // SharedBuffer is locked at creation.
+    ASSERT_TRUE(purgeableVector.isLocked()); // PurgeableVector is locked at creation.
     ASSERT_TRUE(purgeableVector.lock()); // Add an extra lock.
     ASSERT_TRUE(purgeableVector.isLocked());
 
@@ -323,9 +291,9 @@ TEST_P(PurgeableVectorTestWithPlatformSupport, lockingUsesACounter)
         ASSERT_EQ(0, memcmp(purgeableVector.data(), testData.data(), testData.size()));
 }
 
-// Instantiates all the unit tests using the SharedBufferTestWithPlatformSupport fixture both with
-// and without discardable memory support.
-INSTANTIATE_TEST_CASE_P(testsWithPlatformSetUp, PurgeableVectorTestWithPlatformSupport,
-    ::testing::Values(DontSupportDiscardableMemory, SupportDiscardableMemory));
+// Instantiates all the unit tests using the PurgeableVectorTestWithDiscardableMemory
+// fixture both with and without using discardable memory support.
+INSTANTIATE_TEST_CASE_P(, PurgeableVectorTestWithDiscardableMemory,
+    ::testing::Values(PurgeableVector::NotPurgeable, PurgeableVector::Purgeable));
 
 } // namespace blink