Revert of 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 TestingPlatformSupport {
+class MockPlatform final : public Platform {
 public:
-    MockPlatform() { }
+    MockPlatform() : m_oldPlatform(Platform::current()) { }
     ~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)
 {
-    MockPlatform mock;
+    AutoInstallMockPlatform mock;
     OwnPtr<ResourceResponse> response(createTestResourceResponse());
     createTestResourceAndSetCachedMetadata(response.get());
-    EXPECT_EQ(1u, mock.cachedURLs().size());
+    EXPECT_EQ(1u, mock.platform()->cachedURLs().size());
 }
 
 TEST(ResourceTest, SetCachedMetadata_DoesNotSendMetadataToPlatformWhenFetchedViaServiceWorker)
 {
-    MockPlatform mock;
+    AutoInstallMockPlatform mock;
     OwnPtr<ResourceResponse> response(createTestResourceResponse());
     response->setWasFetchedViaServiceWorker(true);
     createTestResourceAndSetCachedMetadata(response.get());
-    EXPECT_EQ(0u, mock.cachedURLs().size());
+    EXPECT_EQ(0u, mock.platform()->cachedURLs().size());
 }
 
 } // namespace blink