Use MockResource as much as possibler in MemoryCacheCorrectnessTest

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

 /*
  * Copyright (C) 2011 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 17 matching lines @@
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceClientWalker.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
 #include "platform/HTTPNames.h"
 #include <memory>
 
 namespace blink {
 
-Resource* RawResource::fetchSynchronously(FetchRequest& request,
-                                          ResourceFetcher* fetcher) {
+RawResource* RawResource::fetchSynchronously(FetchRequest& request,
+                                             ResourceFetcher* fetcher) {
   request.makeSynchronous();
-  return fetcher->requestResource(request, RawResourceFactory(Resource::Raw));
+  return toRawResource(
+      fetcher->requestResource(request, RawResourceFactory(Resource::Raw)));
 }
 
 RawResource* RawResource::fetchImport(FetchRequest& request,
                                       ResourceFetcher* fetcher) {
   DCHECK_EQ(request.resourceRequest().frameType(),
             WebURLRequest::FrameTypeNone);
   request.mutableResourceRequest().setRequestContext(
       WebURLRequest::RequestContextImport);
   return toRawResource(fetcher->requestResource(
       request, RawResourceFactory(Resource::ImportResource)));
@@ skipping 97 matching lines @@
     client->responseReceived(this, response(), nullptr);
   if (!hasClient(c))
     return;
   if (data())
     client->dataReceived(this, data()->data(), data()->size());
   if (!hasClient(c))
     return;
   Resource::didAddClient(client);
 }
 
-bool RawResource::willFollowRedirect(const ResourceRequest& newRequest,
-                                     const ResourceResponse& redirectResponse) {
-  bool follow = Resource::willFollowRedirect(newRequest, redirectResponse);
-  // The base class method takes a non const reference of a ResourceRequest
-  // and returns bool just for allowing RawResource to reject redirect. It
-  // must always return true.
-  DCHECK(follow);
-
-  DCHECK(!redirectResponse.isNull());
-  ResourceClientWalker<RawResourceClient> w(clients());
-  while (RawResourceClient* c = w.next()) {
-    if (!c->redirectReceived(this, newRequest, redirectResponse))
-      follow = false;
-  }
-
-  return follow;
-}
-
 void RawResource::willNotFollowRedirect() {
   ResourceClientWalker<RawResourceClient> w(clients());
   while (RawResourceClient* c = w.next())
     c->redirectBlocked();
 }
 
 void RawResource::responseReceived(
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   bool isSuccessfulRevalidation =
@@ skipping 103 matching lines @@
   for (const auto& header : oldHeaders) {
     AtomicString headerName = header.key;
     if (!shouldIgnoreHeaderForCacheReuse(headerName) &&
         header.value != newHeaders.get(headerName))
       return false;
   }
 
   return true;
 }
 
+bool RawResource::willFollowRedirect(const ResourceRequest& newRequest,

[hiroshige, 2017/01/17 19:28:42]

What is the reason for moving this funtion definition?

[Takashi Toyoshima, 2017/01/19 04:08:20]

I just prefer to have definitions in the same order with the header
declarations. That's why I moved this to the place after the canReuse().

But... it looks this file contains definitions in completely different order and
moving this method here does not make much sense. I'd revert this change in the
next patch set.

+                                     const ResourceResponse& redirectResponse) {
+  bool follow = Resource::willFollowRedirect(newRequest, redirectResponse);
+  // The base class method takes a const reference of a ResourceRequest and
+  // returns bool just for allowing RawResource to reject redirect. It must
+  // always return true.
+  DCHECK(follow);
+
+  DCHECK(!redirectResponse.isNull());
+  ResourceClientWalker<RawResourceClient> w(clients());
+  while (RawResourceClient* c = w.next()) {
+    if (!c->redirectReceived(this, newRequest, redirectResponse))
+      follow = false;
+  }
+
+  return follow;
+}
+
 RawResourceClientStateChecker::RawResourceClientStateChecker()
     : m_state(NotAddedAsClient) {}
 
 RawResourceClientStateChecker::~RawResourceClientStateChecker() {}
 
 NEVER_INLINE void RawResourceClientStateChecker::willAddClient() {
   SECURITY_CHECK(m_state == NotAddedAsClient);
   m_state = Started;
 }
 
@@ skipping 44 matching lines @@
   SECURITY_CHECK(m_state != NotAddedAsClient);
   SECURITY_CHECK(m_state != NotifyFinished);
   SECURITY_CHECK(resource->errorOccurred() ||
                  (m_state == ResponseReceived ||
                   m_state == SetSerializedCachedMetadata ||
                   m_state == DataReceived || m_state == DataDownloaded));
   m_state = NotifyFinished;
 }
 
 }  // namespace blink