More regular Platform implementations in unit tests (reland.)

third_party/WebKit/Source/core/fetch/ResourceTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/fetch/Resource.h"
 
 #include "core/fetch/ResourcePtr.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
+#include "platform/testing/TestingPlatformSupport.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 namespace {
 
-class MockPlatform final : public Platform {
+class MockPlatform final : public TestingPlatformSupport {
 public:
-    MockPlatform() : m_oldPlatform(Platform::current()) { }
+    MockPlatform() { }
     ~MockPlatform() override { }
 
     // From blink::Platform:
     void cacheMetadata(const WebURL& url, int64, const char*, size_t) override
     {
         m_cachedURLs.append(url);
     }
 
     const Vector<WebURL>& cachedURLs() const
     {
         return m_cachedURLs;
     }
 
-    WebThread* currentThread() override
-    {
-        return m_oldPlatform->currentThread();
-    }
-
-    // These blink::Platform methods must be overriden to make a usable object.
-    void cryptographicallyRandomValues(unsigned char* buffer, size_t length) override
-    {
-        ASSERT_NOT_REACHED();
-    }
-
-    const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) override
-    {
-        static const unsigned char tracingIsDisabled = 0;
-        return &tracingIsDisabled;
-    }
-
 private:
-    Platform* m_oldPlatform; // Not owned.
     Vector<WebURL> m_cachedURLs;
 };
 
-class AutoInstallMockPlatform {
-public:
-    AutoInstallMockPlatform()
-    {
-        m_oldPlatform = Platform::current();
-        Platform::initialize(&m_mockPlatform);
-    }
-    ~AutoInstallMockPlatform()
-    {
-        Platform::initialize(m_oldPlatform);
-    }
-    MockPlatform* platform() { return &m_mockPlatform; }
-private:
-    MockPlatform m_mockPlatform;
-    Platform* m_oldPlatform;
-};
-
 PassOwnPtr<ResourceResponse> createTestResourceResponse()
 {
     OwnPtr<ResourceResponse> response = adoptPtr(new ResourceResponse);
     response->setURL(URLTestHelpers::toKURL("https://example.com/"));
     response->setHTTPStatusCode(200);
     return response.release();
 }
 
 void createTestResourceAndSetCachedMetadata(const ResourceResponse* response)
 {
     const char testData[] = "test data";
     ResourcePtr<Resource> resource = new Resource(ResourceRequest(response->url()), Resource::Raw);
     resource->setResponse(*response);
     resource->cacheHandler()->setCachedMetadata(100, testData, sizeof(testData), CachedMetadataHandler::SendToPlatform);
     return;
 }
 
 } // anonymous namespace
 
 TEST(ResourceTest, SetCachedMetadata_SendsMetadataToPlatform)
 {
-    AutoInstallMockPlatform mock;
+    MockPlatform mock;
     OwnPtr<ResourceResponse> response(createTestResourceResponse());
     createTestResourceAndSetCachedMetadata(response.get());
-    EXPECT_EQ(1u, mock.platform()->cachedURLs().size());
+    EXPECT_EQ(1u, mock.cachedURLs().size());
 }
 
 TEST(ResourceTest, SetCachedMetadata_DoesNotSendMetadataToPlatformWhenFetchedViaServiceWorker)
 {
-    AutoInstallMockPlatform mock;
+    MockPlatform mock;
     OwnPtr<ResourceResponse> response(createTestResourceResponse());
     response->setWasFetchedViaServiceWorker(true);
     createTestResourceAndSetCachedMetadata(response.get());
-    EXPECT_EQ(0u, mock.platform()->cachedURLs().size());
+    EXPECT_EQ(0u, mock.cachedURLs().size());
 }
 
 } // namespace blink