1 files changed, 237 insertions, 0 deletions
diff --git a/src/3rdparty/webkit/WebCore/xml/XMLHttpRequest.h b/src/3rdparty/webkit/WebCore/xml/XMLHttpRequest.h
new file mode 100644
index 0000000..858f228
--- /dev/null
+++ b/src/3rdparty/webkit/WebCore/xml/XMLHttpRequest.h
@@ -0,0 +1,237 @@
+/*
+ *  Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved.
+ *  Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@nypop.com>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef XMLHttpRequest_h
+#define XMLHttpRequest_h
+
+#include "ActiveDOMObject.h"
+#include "AtomicStringHash.h"
+#include "EventListener.h"
+#include "EventTarget.h"
+#include "FormData.h"
+#include "ResourceResponse.h"
+#include "SubresourceLoaderClient.h"
+#include "ScriptString.h"
+#include <wtf/OwnPtr.h>
+
+namespace WebCore {
+
+class Document;
+class File;
+class TextResourceDecoder;
+
+class XMLHttpRequest : public RefCounted<XMLHttpRequest>, public EventTarget, private SubresourceLoaderClient, public ActiveDOMObject {
+public:
+    static PassRefPtr<XMLHttpRequest> create(Document* document) { return adoptRef(new XMLHttpRequest(document)); }
+    ~XMLHttpRequest();
+
+    // These exact numeric values are important because JS expects them.
+    enum State {
+        UNSENT = 0,
+        OPENED = 1,
+        HEADERS_RECEIVED = 2,
+        LOADING = 3,
+        DONE = 4
+    };
+
+    virtual XMLHttpRequest* toXMLHttpRequest() { return this; }
+
+    virtual void contextDestroyed();
+    virtual bool canSuspend() const;
+    virtual void stop();
+
+    virtual ScriptExecutionContext* scriptExecutionContext() const;
+
+    String statusText(ExceptionCode&) const;
+    int status(ExceptionCode&) const;
+    State readyState() const;
+    void open(const String& method, const KURL&, bool async, ExceptionCode&);
+    void open(const String& method, const KURL&, bool async, const String& user, ExceptionCode&);
+    void open(const String& method, const KURL&, bool async, const String& user, const String& password, ExceptionCode&);
+    void send(ExceptionCode&);
+    void send(Document*, ExceptionCode&);
+    void send(const String&, ExceptionCode&);
+    void send(File*, ExceptionCode&);
+    void abort();
+    void setRequestHeader(const AtomicString& name, const String& value, ExceptionCode&);
+    void overrideMimeType(const String& override);
+    String getAllResponseHeaders(ExceptionCode&) const;
+    String getResponseHeader(const AtomicString& name, ExceptionCode&) const;
+    const ScriptString& responseText() const;
+    Document* responseXML() const;
+    void setLastSendLineNumber(unsigned lineNumber) { m_lastSendLineNumber = lineNumber; }
+    void setLastSendURL(const String& url) { m_lastSendURL = url; }
+
+    XMLHttpRequestUpload* upload();
+    XMLHttpRequestUpload* optionalUpload() const { return m_upload.get(); }
+
+    void setOnreadystatechange(PassRefPtr<EventListener> eventListener) { m_onReadyStateChangeListener = eventListener; }
+    EventListener* onreadystatechange() const { return m_onReadyStateChangeListener.get(); }
+
+    void setOnabort(PassRefPtr<EventListener> eventListener) { m_onAbortListener = eventListener; }
+    EventListener* onabort() const { return m_onAbortListener.get(); }
+
+    void setOnerror(PassRefPtr<EventListener> eventListener) { m_onErrorListener = eventListener; }
+    EventListener* onerror() const { return m_onErrorListener.get(); }
+
+    void setOnload(PassRefPtr<EventListener> eventListener) { m_onLoadListener = eventListener; }
+    EventListener* onload() const { return m_onLoadListener.get(); }
+
+    void setOnloadstart(PassRefPtr<EventListener> eventListener) { m_onLoadStartListener = eventListener; }
+    EventListener* onloadstart() const { return m_onLoadStartListener.get(); }
+
+    void setOnprogress(PassRefPtr<EventListener> eventListener) { m_onProgressListener = eventListener; }
+    EventListener* onprogress() const { return m_onProgressListener.get(); }
+
+    typedef Vector<RefPtr<EventListener> > ListenerVector;
+    typedef HashMap<AtomicString, ListenerVector> EventListenersMap;
+
+    // useCapture is not used, even for add/remove pairing (for Firefox compatibility).
+    virtual void addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
+    virtual void removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
+    virtual bool dispatchEvent(PassRefPtr<Event>, ExceptionCode&);
+    EventListenersMap& eventListeners() { return m_eventListeners; }
+
+    using RefCounted<XMLHttpRequest>::ref;
+    using RefCounted<XMLHttpRequest>::deref;
+
+private:
+    XMLHttpRequest(Document*);
+    
+    virtual void refEventTarget() { ref(); }
+    virtual void derefEventTarget() { deref(); }
+
+    Document* document() const;
+
+    virtual void willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse);
+    virtual void didSendData(SubresourceLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
+    virtual void didReceiveResponse(SubresourceLoader*, const ResourceResponse&);
+    virtual void didReceiveData(SubresourceLoader*, const char* data, int size);
+    virtual void didFail(SubresourceLoader*, const ResourceError&);
+    virtual void didFinishLoading(SubresourceLoader*);
+    virtual void receivedCancellation(SubresourceLoader*, const AuthenticationChallenge&);
+
+    // Special versions for the preflight
+    void didReceiveResponsePreflight(SubresourceLoader*, const ResourceResponse&);
+    void didFinishLoadingPreflight(SubresourceLoader*);
+
+    void processSyncLoadResults(const Vector<char>& data, const ResourceResponse&, ExceptionCode&);
+    void updateAndDispatchOnProgress(unsigned int len);
+
+    String responseMIMEType() const;
+    bool responseIsXML() const;
+
+    bool initSend(ExceptionCode&);
+
+    String getRequestHeader(const AtomicString& name) const;
+    void setRequestHeaderInternal(const AtomicString& name, const String& value);
+    bool isSafeRequestHeader(const String&) const;
+
+    void changeState(State newState);
+    void callReadyStateChangeListener();
+    void dropProtection();
+    void internalAbort();
+    void clearResponse();
+    void clearRequest();
+
+    void createRequest(ExceptionCode&);
+
+    void makeSameOriginRequest(ExceptionCode&);
+    void makeCrossSiteAccessRequest(ExceptionCode&);
+
+    void makeSimpleCrossSiteAccessRequest(ExceptionCode&);
+    void makeCrossSiteAccessRequestWithPreflight(ExceptionCode&);
+    void handleAsynchronousPreflightResult();
+
+    void loadRequestSynchronously(ResourceRequest&, ExceptionCode&);
+    void loadRequestAsynchronously(ResourceRequest&);
+
+    bool isOnAccessControlResponseHeaderWhitelist(const String&) const;
+
+    bool isSimpleCrossSiteAccessRequest() const;
+    String accessControlOrigin() const;
+    bool accessControlCheck(const ResourceResponse&);
+
+    void genericError();
+    void networkError();
+    void abortError();
+
+    void dispatchReadyStateChangeEvent();
+    void dispatchXMLHttpRequestProgressEvent(EventListener* listener, const AtomicString& type, bool lengthComputable, unsigned loaded, unsigned total);
+    void dispatchAbortEvent();
+    void dispatchErrorEvent();
+    void dispatchLoadEvent();
+    void dispatchLoadStartEvent();
+    void dispatchProgressEvent(long long expectedLength);
+
+    RefPtr<EventListener> m_onReadyStateChangeListener;
+    RefPtr<EventListener> m_onAbortListener;
+    RefPtr<EventListener> m_onErrorListener;
+    RefPtr<EventListener> m_onLoadListener;
+    RefPtr<EventListener> m_onLoadStartListener;
+    RefPtr<EventListener> m_onProgressListener;
+    EventListenersMap m_eventListeners;
+
+    RefPtr<XMLHttpRequestUpload> m_upload;
+
+    KURL m_url;
+    String m_method;
+    HTTPHeaderMap m_requestHeaders;
+    RefPtr<FormData> m_requestEntityBody;
+    String m_mimeTypeOverride;
+    bool m_async;
+    bool m_includeCredentials;
+
+    RefPtr<SubresourceLoader> m_loader;
+    State m_state;
+
+    ResourceResponse m_response;
+    String m_responseEncoding;
+
+    RefPtr<TextResourceDecoder> m_decoder;
+    unsigned long m_identifier;
+
+    // Unlike most strings in the DOM, we keep this as a JSC::UString, not a WebCore::String.
+    // That's because these strings can easily get huge (they are filled from the network with
+    // no parsing) and because JS can easily observe many intermediate states, so it's very useful
+    // to be able to share the buffer with JavaScript versions of the whole or partial string.
+    // In contrast, this string doesn't interact much with the rest of the engine so it's not that
+    // big a cost that it isn't a String.
+    ScriptString m_responseText;
+    mutable bool m_createdDocument;
+    mutable RefPtr<Document> m_responseXML;
+
+    bool m_error;
+
+    bool m_uploadComplete;
+
+    bool m_sameOriginRequest;
+    bool m_allowAccess;
+    bool m_inPreflight;
+
+    // Used for onprogress tracking
+    long long m_receivedLength;
+    
+    unsigned m_lastSendLineNumber;
+    String m_lastSendURL;
+};
+
+} // namespace WebCore
+
+#endif // XMLHttpRequest_h