TestingPlatformSupport: register Platform instance correctly

third_party/WebKit/Source/core/loader/resource/ImageResourceTest.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 1107 matching lines @@
   EXPECT_EQ(Resource::Pending, image->getStatus());
   EXPECT_FALSE(image->isPlaceholder());
   EXPECT_EQ(nullAtom, image->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(static_cast<int>(WebCachePolicy::UseProtocolCachePolicy),
             static_cast<int>(image->resourceRequest().getCachePolicy()));
 
   image->loader()->cancel();
 }
 
 TEST(ImageResourceTest, PeriodicFlushTest) {
-  TestingPlatformSupportWithMockScheduler platform;
+  ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
+      platform(new TestingPlatformSupportWithMockScheduler);
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html",
                                         "text/html");
   ResourceRequest request = ResourceRequest(testURL);
   ImageResource* cachedImage = ImageResource::create(request);
   cachedImage->setStatus(Resource::Pending);
 
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(cachedImage);
 
   // Send the image response.
   ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage2),
                                     nullAtom, String());
   resourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
   cachedImage->responseReceived(resourceResponse, nullptr);
 
   // This is number is sufficiently large amount of bytes necessary for the
   // image to be created (since the size is known). This was determined by
   // appending one byte at a time (with flushes) until the image was decoded.
   size_t meaningfulImageSize = 280;
   cachedImage->appendData(reinterpret_cast<const char*>(kJpegImage2),
                           meaningfulImageSize);
   size_t bytesSent = meaningfulImageSize;
 
   EXPECT_FALSE(cachedImage->errorOccurred());
   EXPECT_TRUE(cachedImage->getContent()->hasImage());
   EXPECT_EQ(1, client->imageChangedCount());
 
-  platform.runForPeriodSeconds(1.);
-  platform.advanceClockSeconds(1.);
+  platform->runForPeriodSeconds(1.);
+  platform->advanceClockSeconds(1.);
 
   // Sanity check that we created an image after appending |meaningfulImageSize|
   // bytes just once.
   EXPECT_FALSE(cachedImage->errorOccurred());
   ASSERT_TRUE(cachedImage->getContent()->hasImage());
   EXPECT_EQ(1, client->imageChangedCount());
 
   for (int flushCount = 1; flushCount <= 3; ++flushCount) {
     // For each of the iteration that appends data, we don't expect
     // |imageChangeCount()| to change, since the time is adjusted by 0.2001
     // seconds (it's greater than 0.2 to avoid double precision problems).
     // After 5 appends, we breach the flush interval and the flush count
     // increases.
     for (int i = 0; i < 5; ++i) {
       SCOPED_TRACE(i);
       cachedImage->appendData(
           reinterpret_cast<const char*>(kJpegImage2) + bytesSent, 1);
 
       EXPECT_FALSE(cachedImage->errorOccurred());
       ASSERT_TRUE(cachedImage->getContent()->hasImage());
       EXPECT_EQ(flushCount, client->imageChangedCount());
 
       ++bytesSent;
-      platform.runForPeriodSeconds(0.2001);
+      platform->runForPeriodSeconds(0.2001);
     }
   }
 
   // Increasing time by a large number only causes one extra flush.
-  platform.runForPeriodSeconds(10.);
-  platform.advanceClockSeconds(10.);
+  platform->runForPeriodSeconds(10.);
+  platform->advanceClockSeconds(10.);
   EXPECT_FALSE(cachedImage->errorOccurred());
   ASSERT_TRUE(cachedImage->getContent()->hasImage());
   EXPECT_FALSE(cachedImage->getContent()->getImage()->isNull());
   EXPECT_EQ(4, client->imageChangedCount());
 
   // Append the rest of the data and finish (which causes another flush).
   cachedImage->appendData(
       reinterpret_cast<const char*>(kJpegImage2) + bytesSent,
       sizeof(kJpegImage2) - bytesSent);
   cachedImage->finish();
 
   EXPECT_FALSE(cachedImage->errorOccurred());
   ASSERT_TRUE(cachedImage->getContent()->hasImage());
   EXPECT_FALSE(cachedImage->getContent()->getImage()->isNull());
   EXPECT_EQ(5, client->imageChangedCount());
   EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_TRUE(cachedImage->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(50, cachedImage->getContent()->getImage()->width());
   EXPECT_EQ(50, cachedImage->getContent()->getImage()->height());
 
   WTF::setTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink