[WIP] Add Resource::IsShareable

third_party/WebKit/Source/platform/loader/fetch/MemoryCacheCorrectnessTest.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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/loader/fetch/MemoryCache.h"
 
 #include "platform/loader/fetch/FetchContext.h"
 #include "platform/loader/fetch/FetchParameters.h"
-#include "platform/loader/fetch/RawResource.h"
 #include "platform/loader/fetch/Resource.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/loader/fetch/ResourceRequest.h"
 #include "platform/loader/testing/MockFetchContext.h"
 #include "platform/loader/testing/MockResource.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
@@ skipping 26 matching lines @@
     if (request.Url().IsNull())
       request.SetURL(KURL(kParsedURLString, kResourceURL));
     MockResource* resource = MockResource::Create(request);
     resource->SetResponse(ResourceResponse(KURL(kParsedURLString, kResourceURL),
                                            "text/html", 0, g_null_atom));
     resource->Finish();
     GetMemoryCache()->Add(resource);
 
     return resource;
   }
-  // TODO(toyoshim): Consider to use MockResource for all tests instead of
-  // RawResource.
-  RawResource* FetchRawResource() {
-    ResourceRequest resource_request(KURL(kParsedURLString, kResourceURL));
-    resource_request.SetRequestContext(WebURLRequest::kRequestContextInternal);
-    FetchParameters fetch_params(resource_request, FetchInitiatorInfo());
-    return RawResource::Fetch(fetch_params, Fetcher());
-  }
   MockResource* FetchMockResource() {
     FetchParameters fetch_params(
         ResourceRequest(KURL(kParsedURLString, kResourceURL)),
         FetchInitiatorInfo());
     return MockResource::Fetch(fetch_params, Fetcher());
   }
   ResourceFetcher* Fetcher() const { return fetcher_.Get(); }
   void AdvanceClock(double seconds) { platform_->AdvanceClockSeconds(seconds); }
 
  private:
@@ skipping 318 matching lines @@
   first_resource->SetResponse(fresh200_response);
   first_resource->Finish();
   GetMemoryCache()->Add(first_resource);
 
   AdvanceClock(500.);
 
   MockResource* fetched = FetchMockResource();
   EXPECT_NE(first_resource, fetched);
 }
 
-TEST_F(MemoryCacheCorrectnessTest, PostToSameURLTwice) {
-  ResourceRequest request1(KURL(kParsedURLString, kResourceURL));
-  request1.SetHTTPMethod(HTTPNames::POST);
-  RawResource* resource1 =
-      RawResource::Create(ResourceRequest(request1.Url()), Resource::kRaw);
-  resource1->SetStatus(ResourceStatus::kPending);
-  GetMemoryCache()->Add(resource1);
-
-  ResourceRequest request2(KURL(kParsedURLString, kResourceURL));
-  request2.SetHTTPMethod(HTTPNames::POST);
-  FetchParameters fetch2(request2, FetchInitiatorInfo());
-  RawResource* resource2 = RawResource::FetchSynchronously(fetch2, Fetcher());
-
-  EXPECT_EQ(resource2, GetMemoryCache()->ResourceForURL(request2.Url()));
-  EXPECT_NE(resource1, resource2);
-}
-
 TEST_F(MemoryCacheCorrectnessTest, 302RedirectNotImplicitlyFresh) {
   KURL redirect_url(kParsedURLString, kResourceURL);
   const char kRedirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirect_target_url(kParsedURLString, kRedirectTargetUrlString);
 
-  RawResource* first_resource =
-      RawResource::Create(ResourceRequest(redirect_url), Resource::kRaw);
+  MockResource* first_resource =
+      MockResource::Create(ResourceRequest(redirect_url));
 
   ResourceResponse fresh302_response;
   fresh302_response.SetURL(redirect_url);
   fresh302_response.SetHTTPStatusCode(302);
   fresh302_response.SetHTTPHeaderField(HTTPNames::Date,
                                        kOriginalRequestDateAsString);
   fresh302_response.SetHTTPHeaderField(HTTPNames::Last_Modified,
                                        kOneDayBeforeOriginalRequest);
   fresh302_response.SetHTTPHeaderField(HTTPNames::Location,
                                        kRedirectTargetUrlString);
@@ skipping 10 matching lines @@
                                        kOriginalRequestDateAsString);
   fresh200_response.SetHTTPHeaderField(HTTPNames::Expires,
                                        kOneDayAfterOriginalRequest);
 
   first_resource->SetResponse(fresh200_response);
   first_resource->Finish();
   GetMemoryCache()->Add(first_resource);
 
   AdvanceClock(500.);
 
-  RawResource* fetched = FetchRawResource();
+  MockResource* fetched = FetchMockResource();
   EXPECT_NE(first_resource, fetched);
 }
 
 TEST_F(MemoryCacheCorrectnessTest, 302RedirectExplicitlyFreshMaxAge) {
   KURL redirect_url(kParsedURLString, kResourceURL);
   const char kRedirectTargetUrlString[] = "http://redirect-target.com";
   KURL redirect_target_url(kParsedURLString, kRedirectTargetUrlString);
 
   MockResource* first_resource =
       MockResource::Create(ResourceRequest(redirect_url));
@@ skipping 65 matching lines @@
   first_resource->Finish();
   GetMemoryCache()->Add(first_resource);
 
   AdvanceClock(500.);
 
   MockResource* fetched = FetchMockResource();
   EXPECT_EQ(first_resource, fetched);
 }
 
 }  // namespace blink