Source/WebCore/loader/DocumentLoader.h

   1 /*
   2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2011 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #ifndef DocumentLoader_h
  31 #define DocumentLoader_h
  32
  33 #include "CachedRawResourceClient.h"
  34 #include "CachedResourceHandle.h"
  35 #include "DocumentLoadTiming.h"
  36 #include "DocumentWriter.h"
  37 #include "IconDatabaseBase.h"
  38 #include "NavigationAction.h"
  39 #include "ResourceError.h"
  40 #include "ResourceLoaderOptions.h"
  41 #include "ResourceRequest.h"
  42 #include "ResourceResponse.h"
  43 #include "StringWithDirection.h"
  44 #include "StyleSheetContents.h"
  45 #include "SubstituteData.h"
  46 #include "Timer.h"
  47 #include <wtf/HashSet.h>
  48 #include <wtf/RefPtr.h>
  49 #include <wtf/Vector.h>
  50
  51 #if HAVE(RUNLOOP_TIMER)
  52 #include <wtf/RunLoopTimer.h>
  53 #endif
  54
  55 #if USE(QUICK_LOOK)
  56 #include "QuickLook.h"
  57 #endif
  58
  59 namespace WebCore {
  60
  61     class ApplicationCacheHost;
  62     class Archive;
  63     class ArchiveResource;
  64     class ArchiveResourceCollection;
  65     class CachedRawResource;
  66     class CachedResourceLoader;
  67     class FormState;
  68     class Frame;
  69     class FrameLoader;
  70     class Page;
  71     class ResourceLoader;
  72     class SharedBuffer;
  73     class SubresourceLoader;
  74     class SubstituteResource;
  75
  76 #if ENABLE(CONTENT_FILTERING)
  77     class ContentFilter;
  78 #endif
  79
  80     typedef HashMap<unsigned long, RefPtr<ResourceLoader>> ResourceLoaderMap;
  81     typedef Vector<ResourceResponse> ResponseVector;
  82
  83     class DocumentLoader : public RefCounted<DocumentLoader>, private CachedRawResourceClient {
  84         WTF_MAKE_FAST_ALLOCATED;
  85     public:
  86         static Ref<DocumentLoader> create(const ResourceRequest& request, const SubstituteData& data)
  87         {
  88             return adoptRef(*new DocumentLoader(request, data));
  89         }
  90         WEBCORE_EXPORT virtual ~DocumentLoader();
  91
  92         void attachToFrame(Frame&);
  93         Frame* frame() const { return m_frame; }
  94
  95         WEBCORE_EXPORT virtual void detachFromFrame();
  96
  97         WEBCORE_EXPORT FrameLoader* frameLoader() const;
  98         WEBCORE_EXPORT SubresourceLoader* mainResourceLoader() const;
  99         WEBCORE_EXPORT PassRefPtr<SharedBuffer> mainResourceData() const;
 100
 101         DocumentWriter& writer() const { return m_writer; }
 102
 103         WEBCORE_EXPORT const ResourceRequest& originalRequest() const;
 104         WEBCORE_EXPORT const ResourceRequest& originalRequestCopy() const;
 105
 106         WEBCORE_EXPORT const ResourceRequest& request() const;
 107         WEBCORE_EXPORT ResourceRequest& request();
 108
 109         CachedResourceLoader& cachedResourceLoader() { return m_cachedResourceLoader; }
 110
 111         const SubstituteData& substituteData() const { return m_substituteData; }
 112
 113         WEBCORE_EXPORT const URL& url() const;
 114         WEBCORE_EXPORT const URL& unreachableURL() const;
 115
 116         const URL& originalURL() const;
 117         WEBCORE_EXPORT const URL& responseURL() const;
 118         WEBCORE_EXPORT const String& responseMIMEType() const;
 119 #if PLATFORM(IOS)
 120         // FIXME: This method seems to violate the encapsulation of this class.
 121         WEBCORE_EXPORT void setResponseMIMEType(const String&);
 122 #endif
 123         const String& currentContentType() const;
 124         void replaceRequestURLForSameDocumentNavigation(const URL&);
 125         bool isStopping() const { return m_isStopping; }
 126         void stopLoading();
 127         void setCommitted(bool committed) { m_committed = committed; }
 128         bool isCommitted() const { return m_committed; }
 129         WEBCORE_EXPORT bool isLoading() const;
 130
 131         const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
 132
 133         const ResourceResponse& response() const { return m_response; }
 134 #if PLATFORM(IOS)
 135         // FIXME: This method seems to violate the encapsulation of this class.
 136         void setResponse(const ResourceResponse& response) { m_response = response; }
 137 #endif
 138
 139         bool isClientRedirect() const { return m_isClientRedirect; }
 140         void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
 141         void handledOnloadEvents();
 142         bool wasOnloadHandled() { return m_wasOnloadHandled; }
 143         WEBCORE_EXPORT bool isLoadingInAPISense() const;
 144         WEBCORE_EXPORT void setTitle(const StringWithDirection&);
 145         const String& overrideEncoding() const { return m_overrideEncoding; }
 146
 147 #if PLATFORM(MAC)
 148         void schedule(SchedulePair&);
 149         void unschedule(SchedulePair&);
 150 #endif
 151
 152 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
 153         void setArchive(PassRefPtr<Archive>);
 154         WEBCORE_EXPORT void addAllArchiveResources(Archive*);
 155         WEBCORE_EXPORT void addArchiveResource(PassRefPtr<ArchiveResource>);
 156         PassRefPtr<Archive> popArchiveForSubframe(const String& frameName, const URL&);
 157         WEBCORE_EXPORT SharedBuffer* parsedArchiveData() const;
 158
 159         WEBCORE_EXPORT bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&);
 160 #endif
 161         void scheduleSubstituteResourceLoad(ResourceLoader&, SubstituteResource&);
 162
 163         // Return the ArchiveResource for the URL only when loading an Archive
 164         ArchiveResource* archiveResourceForURL(const URL&) const;
 165
 166         WEBCORE_EXPORT PassRefPtr<ArchiveResource> mainResource() const;
 167
 168         // Return an ArchiveResource for the URL, either creating from live data or
 169         // pulling from the ArchiveResourceCollection
 170         WEBCORE_EXPORT PassRefPtr<ArchiveResource> subresource(const URL&) const;
 171         WEBCORE_EXPORT Vector<RefPtr<ArchiveResource>> subresources() const;
 172
 173 #ifndef NDEBUG
 174         bool isSubstituteLoadPending(ResourceLoader*) const;
 175 #endif
 176         void cancelPendingSubstituteLoad(ResourceLoader*);
 177
 178         void addResponse(const ResourceResponse&);
 179         const ResponseVector& responses() const { return m_responses; }
 180
 181         const NavigationAction& triggeringAction() const { return m_triggeringAction; }
 182         void setTriggeringAction(const NavigationAction&);
 183         void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
 184         void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
 185         const ResourceRequest& lastCheckedRequest()  { return m_lastCheckedRequest; }
 186
 187         void stopRecordingResponses();
 188         const StringWithDirection& title() const { return m_pageTitle; }
 189
 190         WEBCORE_EXPORT URL urlForHistory() const;
 191         WEBCORE_EXPORT bool urlForHistoryReflectsFailure() const;
 192
 193         // These accessors accommodate WebCore's somewhat fickle custom of creating history
 194         // items for redirects, but only sometimes. For "source" and "destination",
 195         // these accessors return the URL that would have been used if a history
 196         // item were created. This allows WebKit to link history items reflecting
 197         // redirects into a chain from start to finish.
 198         String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; } // null if no client redirect occurred.
 199         String clientRedirectDestinationForHistory() const { return urlForHistory(); }
 200         void setClientRedirectSourceForHistory(const String& clientRedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientRedirectSourceForHistory; }
 201
 202         String serverRedirectSourceForHistory() const { return (urlForHistory() == url() || url() == blankURL()) ? String() : urlForHistory().string(); } // null if no server redirect occurred.
 203         String serverRedirectDestinationForHistory() const { return url(); }
 204
 205         bool didCreateGlobalHistoryEntry() const { return m_didCreateGlobalHistoryEntry; }
 206         void setDidCreateGlobalHistoryEntry(bool didCreateGlobalHistoryEntry) { m_didCreateGlobalHistoryEntry = didCreateGlobalHistoryEntry; }
 207
 208         bool subresourceLoadersArePageCacheAcceptable() const { return m_subresourceLoadersArePageCacheAcceptable; }
 209
 210         void setDefersLoading(bool);
 211         void setMainResourceDataBufferingPolicy(DataBufferingPolicy);
 212
 213         void startLoadingMainResource();
 214         WEBCORE_EXPORT void cancelMainResourceLoad(const ResourceError&);
 215
 216         // Support iconDatabase in synchronous mode.
 217         void iconLoadDecisionAvailable();
 218
 219         // Support iconDatabase in asynchronous mode.
 220         void continueIconLoadWithDecision(IconLoadDecision);
 221         void getIconLoadDecisionForIconURL(const String&);
 222         void getIconDataForIconURL(const String&);
 223
 224         bool isLoadingMainResource() const { return m_loadingMainResource; }
 225         bool isLoadingMultipartContent() const { return m_isLoadingMultipartContent; }
 226
 227         void stopLoadingPlugIns();
 228         void stopLoadingSubresources();
 229
 230         void addSubresourceLoader(ResourceLoader*);
 231         void removeSubresourceLoader(ResourceLoader*);
 232         void addPlugInStreamLoader(ResourceLoader&);
 233         void removePlugInStreamLoader(ResourceLoader&);
 234
 235         void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
 236
 237         void setDeferMainResourceDataLoad(bool defer) { m_deferMainResourceDataLoad = defer; }
 238
 239         void didTellClientAboutLoad(const String& url)
 240         {
 241 #if !PLATFORM(COCOA)
 242             // Don't include data urls here, as if a lot of data is loaded
 243             // that way, we hold on to the (large) url string for too long.
 244             if (protocolIs(url, "data"))
 245                 return;
 246 #endif
 247             if (!url.isEmpty())
 248                 m_resourcesClientKnowsAbout.add(url);
 249         }
 250         bool haveToldClientAboutLoad(const String& url) { return m_resourcesClientKnowsAbout.contains(url); }
 251         void recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest&);
 252         void takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loads);
 253
 254         DocumentLoadTiming& timing() { return m_documentLoadTiming; }
 255         void resetTiming() { m_documentLoadTiming = DocumentLoadTiming(); }
 256
 257         // The WebKit layer calls this function when it's ready for the data to
 258         // actually be added to the document.
 259         WEBCORE_EXPORT void commitData(const char* bytes, size_t length);
 260
 261         ApplicationCacheHost* applicationCacheHost() const { return m_applicationCacheHost.get(); }
 262
 263         void checkLoadComplete();
 264
 265         // The URL of the document resulting from this DocumentLoader.
 266         URL documentURL() const;
 267
 268 #if USE(QUICK_LOOK)
 269         void setQuickLookHandle(std::unique_ptr<QuickLookHandle> quickLookHandle) { m_quickLookHandle = WTF::move(quickLookHandle); }
 270         QuickLookHandle* quickLookHandle() const { return m_quickLookHandle.get(); }
 271 #endif
 272
 273 #if ENABLE(CONTENT_EXTENSIONS)
 274         void addPendingContentExtensionSheet(const String& identifier, StyleSheetContents&);
 275         void addPendingContentExtensionDisplayNoneSelector(const String& identifier, const String& selector, uint32_t selectorID);
 276 #endif
 277
 278         void setShouldOpenExternalURLsPolicy(ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy) { m_shouldOpenExternalURLsPolicy = shouldOpenExternalURLsPolicy; }
 279         ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicyToPropagate() const;
 280
 281     protected:
 282         WEBCORE_EXPORT DocumentLoader(const ResourceRequest&, const SubstituteData&);
 283
 284         WEBCORE_EXPORT virtual void attachToFrame();
 285
 286         bool m_deferMainResourceDataLoad;
 287
 288     private:
 289         Document* document() const;
 290
 291         void setRequest(const ResourceRequest&);
 292
 293         void commitIfReady();
 294         void setMainDocumentError(const ResourceError&);
 295         void commitLoad(const char*, int);
 296         void clearMainResourceLoader();
 297
 298         void setupForReplace();
 299         void maybeFinishLoadingMultipartContent();
 300
 301         bool maybeCreateArchive();
 302 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
 303         void clearArchiveResources();
 304 #endif
 305
 306         void willSendRequest(ResourceRequest&, const ResourceResponse&);
 307         void finishedLoading(double finishTime);
 308         void mainReceivedError(const ResourceError&);
 309         WEBCORE_EXPORT virtual void redirectReceived(CachedResource*, ResourceRequest&, const ResourceResponse&) override;
 310         WEBCORE_EXPORT virtual void responseReceived(CachedResource*, const ResourceResponse&) override;
 311         WEBCORE_EXPORT virtual void dataReceived(CachedResource*, const char* data, int length) override;
 312         WEBCORE_EXPORT virtual void notifyFinished(CachedResource*) override;
 313
 314         bool maybeLoadEmpty();
 315
 316         bool isMultipartReplacingLoad() const;
 317         bool isPostOrRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
 318
 319         void continueAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
 320
 321         void continueAfterContentPolicy(PolicyAction);
 322
 323         void stopLoadingForPolicyChange();
 324         ResourceError interruptedForPolicyChangeError() const;
 325
 326 #if HAVE(RUNLOOP_TIMER)
 327         typedef RunLoopTimer<DocumentLoader> DocumentLoaderTimer;
 328 #else
 329         typedef Timer DocumentLoaderTimer;
 330 #endif
 331         void handleSubstituteDataLoadSoon();
 332         void handleSubstituteDataLoadNow();
 333         void startDataLoadTimer();
 334
 335         void deliverSubstituteResourcesAfterDelay();
 336         void substituteResourceDeliveryTimerFired();
 337
 338         void clearMainResource();
 339
 340         void cancelPolicyCheckIfNeeded();
 341         void becomeMainResourceClient();
 342
 343 #if ENABLE(CONTENT_FILTERING)
 344         friend class ContentFilter;
 345         void installContentFilterUnblockHandler(ContentFilter&);
 346         void contentFilterDidDecide();
 347 #endif
 348
 349         Frame* m_frame;
 350         Ref<CachedResourceLoader> m_cachedResourceLoader;
 351
 352         CachedResourceHandle<CachedRawResource> m_mainResource;
 353         ResourceLoaderMap m_subresourceLoaders;
 354         ResourceLoaderMap m_multipartSubresourceLoaders;
 355         ResourceLoaderMap m_plugInStreamLoaders;
 356
 357         mutable DocumentWriter m_writer;
 358
 359         // A reference to actual request used to create the data source.
 360         // This should only be used by the resourceLoadDelegate's
 361         // identifierForInitialRequest:fromDatasource: method. It is
 362         // not guaranteed to remain unchanged, as requests are mutable.
 363         ResourceRequest m_originalRequest;
 364
 365         SubstituteData m_substituteData;
 366
 367         // A copy of the original request used to create the data source.
 368         // We have to copy the request because requests are mutable.
 369         ResourceRequest m_originalRequestCopy;
 370
 371         // The 'working' request. It may be mutated
 372         // several times from the original request to include additional
 373         // headers, cookie information, canonicalization and redirects.
 374         ResourceRequest m_request;
 375
 376         ResourceResponse m_response;
 377
 378         ResourceError m_mainDocumentError;
 379
 380         bool m_originalSubstituteDataWasValid;
 381         bool m_committed;
 382         bool m_isStopping;
 383         bool m_gotFirstByte;
 384         bool m_isClientRedirect;
 385         bool m_isLoadingMultipartContent;
 386
 387         // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadHandled are roughly the same
 388         // and should be merged.
 389         bool m_wasOnloadHandled;
 390
 391         StringWithDirection m_pageTitle;
 392
 393         String m_overrideEncoding;
 394
 395         // The action that triggered loading - we keep this around for the
 396         // benefit of the various policy handlers.
 397         NavigationAction m_triggeringAction;
 398
 399         // The last request that we checked click policy for - kept around
 400         // so we can avoid asking again needlessly.
 401         ResourceRequest m_lastCheckedRequest;
 402
 403         // We retain all the received responses so we can play back the
 404         // WebResourceLoadDelegate messages if the item is loaded from the
 405         // page cache.
 406         ResponseVector m_responses;
 407         bool m_stopRecordingResponses;
 408
 409         typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource>> SubstituteResourceMap;
 410         SubstituteResourceMap m_pendingSubstituteResources;
 411         Timer m_substituteResourceDeliveryTimer;
 412
 413         std::unique_ptr<ArchiveResourceCollection> m_archiveResourceCollection;
 414 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
 415         RefPtr<Archive> m_archive;
 416         RefPtr<SharedBuffer> m_parsedArchiveData;
 417 #endif
 418
 419         HashSet<String> m_resourcesClientKnowsAbout;
 420         Vector<ResourceRequest> m_resourcesLoadedFromMemoryCacheForClientNotification;
 421
 422         String m_clientRedirectSourceForHistory;
 423         bool m_didCreateGlobalHistoryEntry;
 424
 425         bool m_loadingMainResource;
 426         DocumentLoadTiming m_documentLoadTiming;
 427
 428         double m_timeOfLastDataReceived;
 429         unsigned long m_identifierForLoadWithoutResourceLoader;
 430
 431         DocumentLoaderTimer m_dataLoadTimer;
 432         bool m_waitingForContentPolicy;
 433
 434         RefPtr<IconLoadDecisionCallback> m_iconLoadDecisionCallback;
 435         RefPtr<IconDataCallback> m_iconDataCallback;
 436
 437         bool m_subresourceLoadersArePageCacheAcceptable;
 438         ShouldOpenExternalURLsPolicy m_shouldOpenExternalURLsPolicy { ShouldOpenExternalURLsPolicy::ShouldNotAllow };
 439
 440         std::unique_ptr<ApplicationCacheHost> m_applicationCacheHost;
 441
 442 #if ENABLE(CONTENT_FILTERING)
 443         std::unique_ptr<ContentFilter> m_contentFilter;
 444 #endif
 445
 446 #if USE(QUICK_LOOK)
 447         std::unique_ptr<QuickLookHandle> m_quickLookHandle;
 448 #endif
 449
 450 #if ENABLE(CONTENT_EXTENSIONS)
 451         HashMap<String, RefPtr<StyleSheetContents>> m_pendingNamedContentExtensionStyleSheets;
 452         HashMap<String, Vector<std::pair<String, uint32_t>>> m_pendingContentExtensionDisplayNoneSelectors;
 453 #endif
 454
 455 #ifndef NDEBUG
 456         bool m_hasEverBeenAttached { false };
 457 #endif
 458     };
 459
 460     inline void DocumentLoader::recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest& request)
 461     {
 462         m_resourcesLoadedFromMemoryCacheForClientNotification.append(request);
 463     }
 464
 465     inline void DocumentLoader::takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loadsSet)
 466     {
 467         loadsSet.swap(m_resourcesLoadedFromMemoryCacheForClientNotification);
 468         m_resourcesLoadedFromMemoryCacheForClientNotification.clear();
 469     }
 470
 471 }
 472
 473 #endif // DocumentLoader_h