Use MockResource as much as possibler in MemoryCacheCorrectnessTest

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

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
@@ skipping 22 matching lines @@
 namespace blink {
 class FetchRequest;
 class RawResourceClient;
 class ResourceFetcher;
 class SubstituteData;
 
 class CORE_EXPORT RawResource final : public Resource {
  public:
   using ClientType = RawResourceClient;
 
-  static Resource* fetchSynchronously(FetchRequest&, ResourceFetcher*);
+  static RawResource* fetchSynchronously(FetchRequest&, ResourceFetcher*);
   static RawResource* fetch(FetchRequest&, ResourceFetcher*);
   static RawResource* fetchMainResource(FetchRequest&,
                                         ResourceFetcher*,
                                         const SubstituteData&);
   static RawResource* fetchImport(FetchRequest&, ResourceFetcher*);
   static RawResource* fetchMedia(FetchRequest&, ResourceFetcher*);
   static RawResource* fetchTextTrack(FetchRequest&, ResourceFetcher*);
   static RawResource* fetchManifest(FetchRequest&, ResourceFetcher*);
 
   // Exposed for testing
   static RawResource* create(const ResourceRequest& request, Type type) {
     return new RawResource(request, type, ResourceLoaderOptions());
   }
 
   // FIXME: AssociatedURLLoader shouldn't be a DocumentThreadableLoader and
   // therefore shouldn't use RawResource. However, it is, and it needs to be
   // able to defer loading. This can be fixed by splitting CORS preflighting out
   // of DocumentThreadableLoader.
   void setDefersLoading(bool);
 
+  // Resource implementation
   bool canReuse(const ResourceRequest&) const override;
+  bool willFollowRedirect(const ResourceRequest&,
+                          const ResourceResponse&) override;
 
  private:
   class RawResourceFactory : public ResourceFactory {
    public:
     explicit RawResourceFactory(Resource::Type type) : ResourceFactory(type) {}
 
     Resource* create(const ResourceRequest& request,
                      const ResourceLoaderOptions& options,
                      const String& charset) const override {
       return new RawResource(request, m_type, options);
     }
   };
 
   RawResource(const ResourceRequest&, Type, const ResourceLoaderOptions&);
 
+  // Resource implementation
   void didAddClient(ResourceClient*) override;
   void appendData(const char*, size_t) override;
-
   bool shouldIgnoreHTTPStatusCodeErrors() const override {
     return !isLinkPreload();
   }
-
-  bool willFollowRedirect(const ResourceRequest&,
-                          const ResourceResponse&) override;
   void willNotFollowRedirect() override;
   void responseReceived(const ResourceResponse&,
                         std::unique_ptr<WebDataConsumerHandle>) override;
   void setSerializedCachedMetadata(const char*, size_t) override;
   void didSendData(unsigned long long bytesSent,
                    unsigned long long totalBytesToBeSent) override;
   void didDownloadData(int) override;
   void reportResourceTimingToClients(const ResourceTimingInfo&) override;
 };
 
@@ skipping 88 matching lines @@
     DataReceived,
     DataDownloaded,
     NotifyFinished
   };
   State m_state;
 };
 
 }  // namespace blink
 
 #endif  // RawResource_h