Remove Resource::create() to ensure proper subclasses of Resource are created

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 65 matching lines @@
  protected:
   static void advanceClock(double seconds) { s_timeElapsed += seconds; }
 
   Resource* resourceFromResourceResponse(ResourceResponse response,
                                          Resource::Type type = Resource::Raw) {
     if (response.url().isNull())
       response.setURL(KURL(ParsedURLString, kResourceURL));
     Resource* resource = nullptr;
     switch (type) {
       case Resource::Raw:
-        resource = Resource::create(ResourceRequest(response.url()), type);
+        resource = RawResource::create(ResourceRequest(response.url()), type);
         break;
       case Resource::Image:
         resource = ImageResource::create(ResourceRequest(response.url()));
         break;
       default:
         EXPECT_TRUE(false) << "'Unreachable' code was reached";
         return nullptr;
     }
     resource->setResponse(response);
     resource->finish();
     // Because we didn't give any real data, an image will have set its status
     // to DecodeError. Override it so the resource is cacaheable for testing
     // purposes.
     if (type == Resource::Image)
       resource->setStatus(Resource::Cached);
     memoryCache()->add(resource);
 
     return resource;
   }
 
-  Resource* resourceFromResourceRequest(ResourceRequest request,
-                                        Resource::Type type = Resource::Raw) {
+  Resource* resourceFromResourceRequest(ResourceRequest request) {
     if (request.url().isNull())
       request.setURL(KURL(ParsedURLString, kResourceURL));
-    Resource* resource = Resource::create(request, type);
+    Resource* resource = RawResource::create(request, Resource::Raw);
     resource->setResponse(ResourceResponse(KURL(ParsedURLString, kResourceURL),
                                            "text/html", 0, nullAtom, String()));
     resource->finish();
     memoryCache()->add(resource);
 
     return resource;
   }
 
   Resource* fetch() {
     ResourceRequest resourceRequest(KURL(ParsedURLString, kResourceURL));
@@ skipping 267 matching lines @@
   Resource* fetched = fetch();
   EXPECT_NE(fresh200MustRevalidate, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, FreshWithFreshRedirect) {
   KURL redirectUrl(ParsedURLString, kResourceURL);
   const char redirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
   Resource* firstResource =
-      Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+      RawResource::create(ResourceRequest(redirectUrl), Resource::Raw);
 
   ResourceResponse fresh301Response;
   fresh301Response.setURL(redirectUrl);
   fresh301Response.setHTTPStatusCode(301);
   fresh301Response.setHTTPHeaderField(HTTPNames::Date,
                                       kOriginalRequestDateAsString);
   fresh301Response.setHTTPHeaderField(HTTPNames::Location,
                                       redirectTargetUrlString);
   fresh301Response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=600");
 
@@ skipping 19 matching lines @@
   Resource* fetched = fetch();
   EXPECT_EQ(firstResource, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, FreshWithStaleRedirect) {
   KURL redirectUrl(ParsedURLString, kResourceURL);
   const char redirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
   Resource* firstResource =
-      Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+      RawResource::create(ResourceRequest(redirectUrl), Resource::Raw);
 
   ResourceResponse stale301Response;
   stale301Response.setURL(redirectUrl);
   stale301Response.setHTTPStatusCode(301);
   stale301Response.setHTTPHeaderField(HTTPNames::Date,
                                       kOriginalRequestDateAsString);
   stale301Response.setHTTPHeaderField(HTTPNames::Location,
                                       redirectTargetUrlString);
 
   // Add the redirect to our request.
@@ skipping 16 matching lines @@
   advanceClock(500.);
 
   Resource* fetched = fetch();
   EXPECT_NE(firstResource, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, PostToSameURLTwice) {
   ResourceRequest request1(KURL(ParsedURLString, kResourceURL));
   request1.setHTTPMethod(HTTPNames::POST);
   Resource* resource1 =
-      Resource::create(ResourceRequest(request1.url()), Resource::Raw);
+      RawResource::create(ResourceRequest(request1.url()), Resource::Raw);
   resource1->setStatus(Resource::Pending);
   memoryCache()->add(resource1);
 
   ResourceRequest request2(KURL(ParsedURLString, kResourceURL));
   request2.setHTTPMethod(HTTPNames::POST);
   FetchRequest fetch2(request2, FetchInitiatorInfo());
   Resource* resource2 = RawResource::fetchSynchronously(fetch2, fetcher());
 
   EXPECT_EQ(resource2, memoryCache()->resourceForURL(request2.url()));
   EXPECT_NE(resource1, resource2);
 }
 
 TEST_F(CachingCorrectnessTest, 302RedirectNotImplicitlyFresh) {
   KURL redirectUrl(ParsedURLString, kResourceURL);
   const char redirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
   Resource* firstResource =
-      Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+      RawResource::create(ResourceRequest(redirectUrl), Resource::Raw);
 
   ResourceResponse fresh302Response;
   fresh302Response.setURL(redirectUrl);
   fresh302Response.setHTTPStatusCode(302);
   fresh302Response.setHTTPHeaderField(HTTPNames::Date,
                                       kOriginalRequestDateAsString);
   fresh302Response.setHTTPHeaderField(HTTPNames::Last_Modified,
                                       kOneDayBeforeOriginalRequest);
   fresh302Response.setHTTPHeaderField(HTTPNames::Location,
                                       redirectTargetUrlString);
@@ skipping 20 matching lines @@
   Resource* fetched = fetch();
   EXPECT_NE(firstResource, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshMaxAge) {
   KURL redirectUrl(ParsedURLString, kResourceURL);
   const char redirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
   Resource* firstResource =
-      Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+      RawResource::create(ResourceRequest(redirectUrl), Resource::Raw);
 
   ResourceResponse fresh302Response;
   fresh302Response.setURL(redirectUrl);
   fresh302Response.setHTTPStatusCode(302);
   fresh302Response.setHTTPHeaderField(HTTPNames::Date,
                                       kOriginalRequestDateAsString);
   fresh302Response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=600");
   fresh302Response.setHTTPHeaderField(HTTPNames::Location,
                                       redirectTargetUrlString);
 
@@ skipping 19 matching lines @@
   Resource* fetched = fetch();
   EXPECT_EQ(firstResource, fetched);
 }
 
 TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshExpires) {
   KURL redirectUrl(ParsedURLString, kResourceURL);
   const char redirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString);
 
   Resource* firstResource =
-      Resource::create(ResourceRequest(redirectUrl), Resource::Raw);
+      RawResource::create(ResourceRequest(redirectUrl), Resource::Raw);
 
   ResourceResponse fresh302Response;
   fresh302Response.setURL(redirectUrl);
   fresh302Response.setHTTPStatusCode(302);
   fresh302Response.setHTTPHeaderField(HTTPNames::Date,
                                       kOriginalRequestDateAsString);
   fresh302Response.setHTTPHeaderField(HTTPNames::Expires,
                                       kOneDayAfterOriginalRequest);
   fresh302Response.setHTTPHeaderField(HTTPNames::Location,
                                       redirectTargetUrlString);
@@ skipping 15 matching lines @@
   firstResource->finish();
   memoryCache()->add(firstResource);
 
   advanceClock(500.);
 
   Resource* fetched = fetch();
   EXPECT_EQ(firstResource, fetched);
 }
 
 }  // namespace blink