third_party/WebKit/Source/core/fetch/ResourceFetcher.h - chromium/src - Git at Google

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/

     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.

     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.

     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.

     This class provides all functionality needed for loading images, style
     sheets and html pages from the web. It has a memory cache for these objects.
 */

 #ifndef ResourceFetcher_h
 #define ResourceFetcher_h

 #include "core/CoreExport.h"
 #include "core/fetch/CachePolicy.h"
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/FetchInitiatorInfo.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/fetch/SubstituteData.h"
 #include "platform/Timer.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceLoadPriority.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/text/StringHash.h"
 #include <memory>

 namespace blink {

 class ArchiveResource;
 class CSSStyleSheetResource;
 class DocumentResource;
 class FontResource;
 class ImageResource;
 class MHTMLArchive;
 class RawResource;
 class ScriptResource;
 class XSLStyleSheetResource;
 class KURL;
 class ResourceTimingInfo;

 // The ResourceFetcher provides a per-context interface to the MemoryCache and
 // enforces a bunch of security checks and rules for resource revalidation. Its
 // lifetime is roughly per-DocumentLoader, in that it is generally created in
 // the DocumentLoader constructor and loses its ability to generate network
 // requests when the DocumentLoader is destroyed. Documents also hold a pointer
 // to ResourceFetcher for their lifetime (and will create one if they are
 // initialized without a LocalFrame), so a Document can keep a ResourceFetcher
 // alive past detach if scripts still reference the Document.
 class CORE_EXPORT ResourceFetcher
     : public GarbageCollectedFinalized<ResourceFetcher> {
   WTF_MAKE_NONCOPYABLE(ResourceFetcher);
   USING_PRE_FINALIZER(ResourceFetcher, clearPreloads);

  public:
   static ResourceFetcher* create(FetchContext* context) {
     return new ResourceFetcher(context);
   }
   virtual ~ResourceFetcher();
   DECLARE_VIRTUAL_TRACE();

   Resource* requestResource(FetchRequest&,
                             const ResourceFactory&,
                             const SubstituteData& = SubstituteData());

   Resource* cachedResource(const KURL&) const;

   using DocumentResourceMap = HeapHashMap<String, WeakMember<Resource>>;
   const DocumentResourceMap& allResources() const {
     return m_documentResources;
   }

   // Actually starts loading a Resource if it wasn't started during
   // requestResource().
   bool startLoad(Resource*);

   void setAutoLoadImages(bool);
   void setImagesEnabled(bool);

   FetchContext& context() const {
     return m_context ? *m_context.get() : FetchContext::nullInstance();
   }
   void clearContext();

   int requestCount() const;
   bool hasPendingRequest() const;

   enum ClearPreloadsPolicy { ClearAllPreloads, ClearSpeculativeMarkupPreloads };

   void enableIsPreloadedForTest();
   bool isPreloadedForTest(const KURL&) const;

   int countPreloads() const { return m_preloads ? m_preloads->size() : 0; }
   void clearPreloads(ClearPreloadsPolicy = ClearAllPreloads);
   void preloadStarted(Resource*);
   void logPreloadStats();
   void warnUnusedPreloads();

   MHTMLArchive* archive() const { return m_archive.get(); }
   ArchiveResource* createArchive(Resource*);

   void setDefersLoading(bool);
   void stopFetching();
   bool isFetching() const;

   bool willFollowRedirect(Resource*,
                           ResourceRequest&,
                           const ResourceResponse&,
                           int64_t encodedDataLength);
   enum DidFinishLoadingReason {
     DidFinishLoading,
     DidFinishFirstPartInMultipart
   };
   void didFinishLoading(Resource*,
                         double finishTime,
                         int64_t encodedDataLength,
                         DidFinishLoadingReason);
   void didFailLoading(Resource*, const ResourceError&);
   void didReceiveResponse(Resource*,
                           const ResourceResponse&,
                           WebDataConsumerHandle*);
   void didReceiveData(const Resource*,
                       const char* data,
                       int dataLength,
                       int encodedDataLength);
   void didDownloadData(const Resource*, int dataLength, int encodedDataLength);
   bool defersLoading() const;
   bool isControlledByServiceWorker() const;

   void acceptDataFromThreadedReceiver(unsigned long identifier,
                                       const char* data,
                                       int dataLength,
                                       int encodedDataLength);

   enum ResourceLoadStartType {
     ResourceLoadingFromNetwork,
     ResourceLoadingFromCache
   };
   void requestLoadStarted(unsigned long identifier,
                           Resource*,
                           const FetchRequest&,
                           ResourceLoadStartType,
                           bool isStaticData = false);
   static const ResourceLoaderOptions& defaultResourceOptions();

   String getCacheIdentifier() const;

   static void determineRequestContext(ResourceRequest&,
                                       Resource::Type,
                                       bool isMainFrame);
   void determineRequestContext(ResourceRequest&, Resource::Type);

   void updateAllImageResourcePriorities();

   void reloadLoFiImages();

   // This is only exposed for testing purposes.
   HeapListHashSet<Member<Resource>>* preloads() { return m_preloads.get(); }

  private:
   friend class ResourceCacheValidationSuppressor;

   explicit ResourceFetcher(FetchContext*);

   void initializeRevalidation(ResourceRequest&, Resource*);
   Resource* createResourceForLoading(FetchRequest&,
                                      const String& charset,
                                      const ResourceFactory&);
   void storeResourceTimingInitiatorInformation(Resource*);
   ResourceLoadPriority computeLoadPriority(Resource::Type,
                                            const FetchRequest&,
                                            ResourcePriority::VisibilityStatus);

   Resource* resourceForStaticData(const FetchRequest&,
                                   const ResourceFactory&,
                                   const SubstituteData&);

   // RevalidationPolicy enum values are used in UMAs https://crbug.com/579496.
   enum RevalidationPolicy { Use, Revalidate, Reload, Load };
   RevalidationPolicy determineRevalidationPolicy(Resource::Type,
                                                  const FetchRequest&,
                                                  Resource* existingResource,
                                                  bool isStaticData) const;

   void moveCachedNonBlockingResourceToBlocking(Resource*, const FetchRequest&);
   void moveResourceLoaderToNonBlocking(ResourceLoader*);
   void removeResourceLoader(ResourceLoader*);

   void initializeResourceRequest(ResourceRequest&,
                                  Resource::Type,
                                  FetchRequest::DeferOption);
   void willSendRequest(unsigned long identifier,
                        ResourceRequest&,
                        const ResourceResponse&,
                        const ResourceLoaderOptions&);
   bool canAccessResponse(Resource*, const ResourceResponse&) const;

   bool resourceNeedsLoad(Resource*, const FetchRequest&, RevalidationPolicy);
   bool shouldDeferImageLoad(const KURL&) const;

   void resourceTimingReportTimerFired(TimerBase*);

   void reloadImagesIfNotDeferred();

   void updateMemoryCacheStats(Resource*,
                               RevalidationPolicy,
                               const FetchRequest&,
                               const ResourceFactory&,
                               bool isStaticData) const;

   Member<FetchContext> m_context;

   HashSet<String> m_validatedURLs;
   mutable DocumentResourceMap m_documentResources;

   Member<HeapListHashSet<Member<Resource>>> m_preloads;
   Member<MHTMLArchive> m_archive;

   Timer<ResourceFetcher> m_resourceTimingReportTimer;

   using ResourceTimingInfoMap =
       HeapHashMap<Member<Resource>, std::unique_ptr<ResourceTimingInfo>>;
   ResourceTimingInfoMap m_resourceTimingInfoMap;

   Vector<std::unique_ptr<ResourceTimingInfo>> m_scheduledResourceTimingReports;

   HeapHashSet<Member<ResourceLoader>> m_loaders;
   HeapHashSet<Member<ResourceLoader>> m_nonBlockingLoaders;

   // Used in hit rate histograms.
   class DeadResourceStatsRecorder {
     DISALLOW_NEW();

    public:
     DeadResourceStatsRecorder();
     ~DeadResourceStatsRecorder();

     void update(RevalidationPolicy);

    private:
     int m_useCount;
     int m_revalidateCount;
     int m_loadCount;
   };
   DeadResourceStatsRecorder m_deadStatsRecorder;

   std::unique_ptr<HashSet<String>> m_preloadedURLsForTest;

   // 28 bits left
   bool m_autoLoadImages : 1;
   bool m_imagesEnabled : 1;
   bool m_allowStaleResources : 1;
   bool m_imageFetched : 1;
 };

 class ResourceCacheValidationSuppressor {
   WTF_MAKE_NONCOPYABLE(ResourceCacheValidationSuppressor);
   STACK_ALLOCATED();

  public:
   explicit ResourceCacheValidationSuppressor(ResourceFetcher* loader)
       : m_loader(loader), m_previousState(false) {
     if (m_loader) {
       m_previousState = m_loader->m_allowStaleResources;
       m_loader->m_allowStaleResources = true;
     }
   }
   ~ResourceCacheValidationSuppressor() {
     if (m_loader)
       m_loader->m_allowStaleResources = m_previousState;
   }

  private:
   Member<ResourceFetcher> m_loader;
   bool m_previousState;
 };

 }  // namespace blink

 #endif  // ResourceFetcher_h
	/*
	Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
	Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
	Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
	rights reserved.
	Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/

	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.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.

	You should have received a copy of the GNU Library General Public License
	along with this library; see the file COPYING.LIB. If not, write to
	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA.

	This class provides all functionality needed for loading images, style
	sheets and html pages from the web. It has a memory cache for these objects.
	*/

	#ifndef ResourceFetcher_h
	#define ResourceFetcher_h

	#include "core/CoreExport.h"
	#include "core/fetch/CachePolicy.h"
	#include "core/fetch/FetchContext.h"
	#include "core/fetch/FetchInitiatorInfo.h"
	#include "core/fetch/FetchRequest.h"
	#include "core/fetch/Resource.h"
	#include "core/fetch/ResourceLoaderOptions.h"
	#include "core/fetch/SubstituteData.h"
	#include "platform/Timer.h"
	#include "platform/network/ResourceError.h"
	#include "platform/network/ResourceLoadPriority.h"
	#include "wtf/HashMap.h"
	#include "wtf/HashSet.h"
	#include "wtf/ListHashSet.h"
	#include "wtf/text/StringHash.h"
	#include <memory>

	namespace blink {

	class ArchiveResource;
	class CSSStyleSheetResource;
	class DocumentResource;
	class FontResource;
	class ImageResource;
	class MHTMLArchive;
	class RawResource;
	class ScriptResource;
	class XSLStyleSheetResource;
	class KURL;
	class ResourceTimingInfo;

	// The ResourceFetcher provides a per-context interface to the MemoryCache and
	// enforces a bunch of security checks and rules for resource revalidation. Its
	// lifetime is roughly per-DocumentLoader, in that it is generally created in
	// the DocumentLoader constructor and loses its ability to generate network
	// requests when the DocumentLoader is destroyed. Documents also hold a pointer
	// to ResourceFetcher for their lifetime (and will create one if they are
	// initialized without a LocalFrame), so a Document can keep a ResourceFetcher
	// alive past detach if scripts still reference the Document.
	class CORE_EXPORT ResourceFetcher
	: public GarbageCollectedFinalized<ResourceFetcher> {
	WTF_MAKE_NONCOPYABLE(ResourceFetcher);
	USING_PRE_FINALIZER(ResourceFetcher, clearPreloads);

	public:
	static ResourceFetcher* create(FetchContext* context) {
	return new ResourceFetcher(context);
	}
	virtual ~ResourceFetcher();
	DECLARE_VIRTUAL_TRACE();

	Resource* requestResource(FetchRequest&,
	const ResourceFactory&,
	const SubstituteData& = SubstituteData());

	Resource* cachedResource(const KURL&) const;

	using DocumentResourceMap = HeapHashMap<String, WeakMember<Resource>>;
	const DocumentResourceMap& allResources() const {
	return m_documentResources;
	}

	// Actually starts loading a Resource if it wasn't started during
	// requestResource().
	bool startLoad(Resource*);

	void setAutoLoadImages(bool);
	void setImagesEnabled(bool);

	FetchContext& context() const {
	return m_context ? *m_context.get() : FetchContext::nullInstance();
	}
	void clearContext();

	int requestCount() const;
	bool hasPendingRequest() const;

	enum ClearPreloadsPolicy { ClearAllPreloads, ClearSpeculativeMarkupPreloads };

	void enableIsPreloadedForTest();
	bool isPreloadedForTest(const KURL&) const;

	int countPreloads() const { return m_preloads ? m_preloads->size() : 0; }
	void clearPreloads(ClearPreloadsPolicy = ClearAllPreloads);
	void preloadStarted(Resource*);
	void logPreloadStats();
	void warnUnusedPreloads();

	MHTMLArchive* archive() const { return m_archive.get(); }
	ArchiveResource* createArchive(Resource*);

	void setDefersLoading(bool);
	void stopFetching();
	bool isFetching() const;

	bool willFollowRedirect(Resource*,
	ResourceRequest&,
	const ResourceResponse&,
	int64_t encodedDataLength);
	enum DidFinishLoadingReason {
	DidFinishLoading,
	DidFinishFirstPartInMultipart
	};
	void didFinishLoading(Resource*,
	double finishTime,
	int64_t encodedDataLength,
	DidFinishLoadingReason);
	void didFailLoading(Resource*, const ResourceError&);
	void didReceiveResponse(Resource*,
	const ResourceResponse&,
	WebDataConsumerHandle*);
	void didReceiveData(const Resource*,
	const char* data,
	int dataLength,
	int encodedDataLength);
	void didDownloadData(const Resource*, int dataLength, int encodedDataLength);
	bool defersLoading() const;
	bool isControlledByServiceWorker() const;

	void acceptDataFromThreadedReceiver(unsigned long identifier,
	const char* data,
	int dataLength,
	int encodedDataLength);

	enum ResourceLoadStartType {
	ResourceLoadingFromNetwork,
	ResourceLoadingFromCache
	};
	void requestLoadStarted(unsigned long identifier,
	Resource*,
	const FetchRequest&,
	ResourceLoadStartType,
	bool isStaticData = false);
	static const ResourceLoaderOptions& defaultResourceOptions();

	String getCacheIdentifier() const;

	static void determineRequestContext(ResourceRequest&,
	Resource::Type,
	bool isMainFrame);
	void determineRequestContext(ResourceRequest&, Resource::Type);

	void updateAllImageResourcePriorities();

	void reloadLoFiImages();

	// This is only exposed for testing purposes.
	HeapListHashSet<Member<Resource>>* preloads() { return m_preloads.get(); }

	private:
	friend class ResourceCacheValidationSuppressor;

	explicit ResourceFetcher(FetchContext*);

	void initializeRevalidation(ResourceRequest&, Resource*);
	Resource* createResourceForLoading(FetchRequest&,
	const String& charset,
	const ResourceFactory&);
	void storeResourceTimingInitiatorInformation(Resource*);
	ResourceLoadPriority computeLoadPriority(Resource::Type,
	const FetchRequest&,
	ResourcePriority::VisibilityStatus);

	Resource* resourceForStaticData(const FetchRequest&,
	const ResourceFactory&,
	const SubstituteData&);

	// RevalidationPolicy enum values are used in UMAs https://crbug.com/579496.
	enum RevalidationPolicy { Use, Revalidate, Reload, Load };
	RevalidationPolicy determineRevalidationPolicy(Resource::Type,
	const FetchRequest&,
	Resource* existingResource,
	bool isStaticData) const;

	void moveCachedNonBlockingResourceToBlocking(Resource*, const FetchRequest&);
	void moveResourceLoaderToNonBlocking(ResourceLoader*);
	void removeResourceLoader(ResourceLoader*);

	void initializeResourceRequest(ResourceRequest&,
	Resource::Type,
	FetchRequest::DeferOption);
	void willSendRequest(unsigned long identifier,
	ResourceRequest&,
	const ResourceResponse&,
	const ResourceLoaderOptions&);
	bool canAccessResponse(Resource*, const ResourceResponse&) const;

	bool resourceNeedsLoad(Resource*, const FetchRequest&, RevalidationPolicy);
	bool shouldDeferImageLoad(const KURL&) const;

	void resourceTimingReportTimerFired(TimerBase*);

	void reloadImagesIfNotDeferred();

	void updateMemoryCacheStats(Resource*,
	RevalidationPolicy,
	const FetchRequest&,
	const ResourceFactory&,
	bool isStaticData) const;

	Member<FetchContext> m_context;

	HashSet<String> m_validatedURLs;
	mutable DocumentResourceMap m_documentResources;

	Member<HeapListHashSet<Member<Resource>>> m_preloads;
	Member<MHTMLArchive> m_archive;

	Timer<ResourceFetcher> m_resourceTimingReportTimer;

	using ResourceTimingInfoMap =
	HeapHashMap<Member<Resource>, std::unique_ptr<ResourceTimingInfo>>;
	ResourceTimingInfoMap m_resourceTimingInfoMap;

	Vector<std::unique_ptr<ResourceTimingInfo>> m_scheduledResourceTimingReports;

	HeapHashSet<Member<ResourceLoader>> m_loaders;
	HeapHashSet<Member<ResourceLoader>> m_nonBlockingLoaders;

	// Used in hit rate histograms.
	class DeadResourceStatsRecorder {
	DISALLOW_NEW();

	public:
	DeadResourceStatsRecorder();
	~DeadResourceStatsRecorder();

	void update(RevalidationPolicy);

	private:
	int m_useCount;
	int m_revalidateCount;
	int m_loadCount;
	};
	DeadResourceStatsRecorder m_deadStatsRecorder;

	std::unique_ptr<HashSet<String>> m_preloadedURLsForTest;

	// 28 bits left
	bool m_autoLoadImages : 1;
	bool m_imagesEnabled : 1;
	bool m_allowStaleResources : 1;
	bool m_imageFetched : 1;
	};

	class ResourceCacheValidationSuppressor {
	WTF_MAKE_NONCOPYABLE(ResourceCacheValidationSuppressor);
	STACK_ALLOCATED();

	public:
	explicit ResourceCacheValidationSuppressor(ResourceFetcher* loader)
	: m_loader(loader), m_previousState(false) {
	if (m_loader) {
	m_previousState = m_loader->m_allowStaleResources;
	m_loader->m_allowStaleResources = true;
	}
	}
	~ResourceCacheValidationSuppressor() {
	if (m_loader)
	m_loader->m_allowStaleResources = m_previousState;
	}

	private:
	Member<ResourceFetcher> m_loader;
	bool m_previousState;
	};

	} // namespace blink

	#endif // ResourceFetcher_h