WebCore/ResourceLoader.h

   1 /*
   2  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef ResourceLoader_h
  30 #define ResourceLoader_h
  31
  32 #include "ResourceHandleClient.h"
  33 #include "ResourceRequest.h"
  34 #include "ResourceResponse.h"
  35 #include <wtf/RefCounted.h>
  36 #include "AuthenticationChallenge.h"
  37 #include "KURL.h"
  38
  39 #include <wtf/Forward.h>
  40
  41 namespace WebCore {
  42
  43     class ApplicationCache;
  44     class DocumentLoader;
  45     class Frame;
  46     class FrameLoader;
  47     class ProtectionSpace;
  48     class ResourceHandle;
  49     class SharedBuffer;
  50
  51     class ResourceLoader : public RefCounted<ResourceLoader>, protected ResourceHandleClient {
  52     public:
  53         virtual ~ResourceLoader();
  54
  55         void cancel();
  56
  57         virtual bool load(const ResourceRequest&);
  58
  59         FrameLoader* frameLoader() const;
  60         DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
  61
  62         virtual void cancel(const ResourceError&);
  63         ResourceError cancelledError();
  64         ResourceError blockedError();
  65         ResourceError cannotShowURLError();
  66
  67         virtual void setDefersLoading(bool);
  68
  69         void setIdentifier(unsigned long identifier) { m_identifier = identifier; }
  70         unsigned long identifier() const { return m_identifier; }
  71
  72         virtual void releaseResources();
  73         const ResourceResponse& response() const;
  74
  75         virtual void addData(const char*, int, bool allAtOnce);
  76         virtual PassRefPtr<SharedBuffer> resourceData();
  77         void clearResourceData();
  78
  79         virtual void willSendRequest(ResourceRequest&, const ResourceResponse& redirectResponse);
  80         virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
  81         virtual void didReceiveResponse(const ResourceResponse&);
  82         virtual void didReceiveData(const char*, int, long long lengthReceived, bool allAtOnce);
  83         void willStopBufferingData(const char*, int);
  84         virtual void didFinishLoading();
  85         virtual void didFail(const ResourceError&);
  86
  87         virtual bool shouldUseCredentialStorage();
  88         virtual void didReceiveAuthenticationChallenge(const AuthenticationChallenge&);
  89         void didCancelAuthenticationChallenge(const AuthenticationChallenge&);
  90
  91         virtual bool canAuthenticateAgainstProtectionSpace(const ProtectionSpace&);
  92
  93         virtual void receivedCancellation(const AuthenticationChallenge&);
  94
  95         // ResourceHandleClient
  96         virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse);
  97         virtual void didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
  98         virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
  99         virtual void didReceiveData(ResourceHandle*, const char*, int, int lengthReceived);
 100         virtual void didFinishLoading(ResourceHandle*);
 101         virtual void didFail(ResourceHandle*, const ResourceError&);
 102         virtual void wasBlocked(ResourceHandle*);
 103         virtual void cannotShowURL(ResourceHandle*);
 104         virtual void willStopBufferingData(ResourceHandle*, const char* data, int length) { willStopBufferingData(data, length); }
 105         virtual bool shouldUseCredentialStorage(ResourceHandle*) { return shouldUseCredentialStorage(); }
 106         virtual void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge) { didReceiveAuthenticationChallenge(challenge); }
 107         virtual void didCancelAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge) { didCancelAuthenticationChallenge(challenge); }
 108         virtual bool canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace& protectionSpace) { return canAuthenticateAgainstProtectionSpace(protectionSpace); }
 109         virtual void receivedCancellation(ResourceHandle*, const AuthenticationChallenge& challenge) { receivedCancellation(challenge); }
 110         virtual void willCacheResponse(ResourceHandle*, CacheStoragePolicy&);
 111 #if PLATFORM(MAC)
 112         virtual NSCachedURLResponse* willCacheResponse(ResourceHandle*, NSCachedURLResponse*);
 113 #endif
 114
 115         ResourceHandle* handle() const { return m_handle.get(); }
 116         bool sendResourceLoadCallbacks() const { return m_sendResourceLoadCallbacks; }
 117
 118         void setShouldBufferData(bool shouldBufferData);
 119
 120     protected:
 121         ResourceLoader(Frame*, bool sendResourceLoadCallbacks, bool shouldContentSniff);
 122
 123 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
 124         bool scheduleLoadFallbackResourceFromApplicationCache(ApplicationCache* = 0);
 125 #endif
 126
 127         virtual void didCancel(const ResourceError&);
 128         void didFinishLoadingOnePart();
 129
 130         const ResourceRequest& request() const { return m_request; }
 131         bool reachedTerminalState() const { return m_reachedTerminalState; }
 132         bool cancelled() const { return m_cancelled; }
 133         bool defersLoading() const { return m_defersLoading; }
 134
 135         RefPtr<ResourceHandle> m_handle;
 136         RefPtr<Frame> m_frame;
 137         RefPtr<DocumentLoader> m_documentLoader;
 138         ResourceResponse m_response;
 139
 140     private:
 141         ResourceRequest m_request;
 142         RefPtr<SharedBuffer> m_resourceData;
 143
 144         unsigned long m_identifier;
 145
 146         bool m_reachedTerminalState;
 147         bool m_cancelled;
 148         bool m_calledDidFinishLoad;
 149
 150         bool m_sendResourceLoadCallbacks;
 151         bool m_shouldContentSniff;
 152         bool m_shouldBufferData;
 153         bool m_defersLoading;
 154         ResourceRequest m_deferredRequest;
 155     };
 156
 157 }
 158
 159 #endif