Blink Platform: Remove time functions from Platform.

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

 /*
  * Copyright (c) 2014, 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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/RawResource.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "platform/network/ResourceRequest.h"
-#include "platform/testing/TestingPlatformSupport.h"
-#include "public/platform/Platform.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 // An URL for the original request.
 const char kResourceURL[] = "http://resource.com/";
 
 // The origin time of our first request.
@@ skipping 14 matching lines @@
 
     bool allowImage(bool imagesEnabled, const KURL&) const override { return true; }
     bool canRequest(Resource::Type, const ResourceRequest&, const KURL&, const ResourceLoaderOptions&, bool forPreload, FetchRequest::OriginRestriction) const override { return true; }
 
 private:
     MockFetchContext() { }
 };
 
 class CachingCorrectnessTest : public ::testing::Test {
 protected:
-    void advanceClock(double seconds)
+    static void advanceClock(double seconds)
     {
-        m_proxyPlatform.advanceClock(seconds);
+        s_timeElapsed += seconds;
     }
 
     PassRefPtrWillBeRawPtr<Resource> resourceFromResourceResponse(ResourceResponse response, Resource::Type type = Resource::Raw)
     {
         if (response.url().isNull())
             response.setURL(KURL(ParsedURLString, kResourceURL));
         RefPtrWillBeRawPtr<Resource> resource = nullptr;
         switch (type) {
         case Resource::Raw:
             resource = Resource::create(ResourceRequest(response.url()), type);
@@ skipping 31 matching lines @@
 
     PassRefPtrWillBeRawPtr<Resource> fetchImage()
     {
         FetchRequest fetchRequest(ResourceRequest(KURL(ParsedURLString, kResourceURL)), FetchInitiatorInfo());
         return ImageResource::fetch(fetchRequest, fetcher());
     }
 
     ResourceFetcher* fetcher() const { return m_fetcher.get(); }
 
 private:
-    // A simple platform that mocks out the clock, for cache freshness testing.
-    class ProxyPlatform : public TestingPlatformSupport {
-    public:
-        ProxyPlatform() : m_elapsedSeconds(0.) { }
-
-        void advanceClock(double seconds)
-        {
-            m_elapsedSeconds += seconds;
-        }
-
-    private:
-        // From blink::Platform:
-        double currentTimeSeconds() override
-        {
-            return kOriginalRequestDateAsDouble + m_elapsedSeconds;
-        }
-
-        double m_elapsedSeconds;
-    };
+    static double returnMockTime()
+    {
+        return kOriginalRequestDateAsDouble + s_timeElapsed;
+    }
 
     virtual void SetUp()
     {
         // Save the global memory cache to restore it upon teardown.
         m_globalMemoryCache = replaceMemoryCacheForTesting(MemoryCache::create());
 
         m_fetcher = ResourceFetcher::create(MockFetchContext::create());
+
+        s_timeElapsed = 0.0;
+        m_originalTimeFunction = setTimeFunctionsForTesting(returnMockTime);
     }
 
     virtual void TearDown()
     {
         memoryCache()->evictResources();
 
         // Yield the ownership of the global memory cache back.
         replaceMemoryCacheForTesting(m_globalMemoryCache.release());
+
+        setTimeFunctionsForTesting(m_originalTimeFunction);
     }
 
-    ProxyPlatform m_proxyPlatform;
-
     Persistent<MemoryCache> m_globalMemoryCache;
     Persistent<ResourceFetcher> m_fetcher;
+    TimeFunction m_originalTimeFunction;
+    static double s_timeElapsed;
 };
 
+double CachingCorrectnessTest::s_timeElapsed;
+
 TEST_F(CachingCorrectnessTest, FreshFromLastModified)
 {
     ResourceResponse fresh200Response;
     fresh200Response.setHTTPStatusCode(200);
     fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString);
     fresh200Response.setHTTPHeaderField("Last-Modified", kOneDayBeforeOriginalRequest);
 
     RefPtrWillBeRawPtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Response);
 
     // Advance the clock within the implicit freshness period of this resource before we make a request.
@@ skipping 380 matching lines @@
     firstResource->setResponse(fresh200Response);
     memoryCache()->add(firstResource.get());
 
     advanceClock(500.);
 
     RefPtrWillBeRawPtr<Resource> fetched = fetch();
     EXPECT_EQ(firstResource, fetched);
 }
 
 } // namespace blink