Attachment #212807 for bug #16214

View Details Raw Unified Return to Bug 16214

| Differences between

Lines 1816-1822 set(WebCore_SOURCES a/Source/WebCore/CMakeLists.txt_sec1
- a/Source/WebCore/CMakeLists.txt -1 / +1 lines
1816	platform/FileStream.cpp	1816	platform/FileStream.cpp
1817	platform/FileSystem.cpp	1817	platform/FileSystem.cpp
1818	platform/HistogramSupport.cpp	1818	platform/HistogramSupport.cpp
1819	platform/KURL.cpp	1819	platform/URL.cpp
1820	platform/KillRingNone.cpp	1820	platform/KillRingNone.cpp
1821	platform/Language.cpp	1821	platform/Language.cpp
1822	platform/Length.cpp	1822	platform/Length.cpp



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-27  Zalan Bujtas  <zalan@apple.com>

        Unexpected word wrapping for wrapped content then raw content.



	Source/WebCore/platform/HistogramSupport.cpp \
	Source/WebCore/platform/HistogramSupport.h \
	Source/WebCore/platform/HostWindow.h \
	Source/WebCore/platform/URL.cpp \
	Source/WebCore/platform/URL.h \
	Source/WebCore/platform/URLHash.h \
	Source/WebCore/platform/KillRing.h \
	Source/WebCore/platform/KillRingNone.cpp \
	Source/WebCore/platform/Language.cpp \



namespace WebCore {

// static
PassRefPtr<DOMFileSystem> DOMFileSystem::create(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
{
    RefPtr<DOMFileSystem> fileSystem(adoptRef(new DOMFileSystem(context, name, type, rootURL, asyncFileSystem)));
    fileSystem->suspendIfNeeded();

    rootURL.append(filesystemId);
    rootURL.append("/");

    return DOMFileSystem::create(context, filesystemName.toString(), FileSystemTypeIsolated, URL(ParsedURLString, rootURL.toString()), AsyncFileSystem::create());
}

DOMFileSystem::DOMFileSystem(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
    : DOMFileSystemBase(context, name, type, rootURL, asyncFileSystem)
    , ActiveDOMObject(context)
{


class SnapshotFileCallback : public FileSystemCallbacksBase {
public:
    static PassOwnPtr<SnapshotFileCallback> create(PassRefPtr<DOMFileSystem> filesystem, const String& name, const URL& url, PassRefPtr<FileCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
    {
        return adoptPtr(new SnapshotFileCallback(filesystem, name, url, successCallback, errorCallback));
    }

    }

private:
    SnapshotFileCallback(PassRefPtr<DOMFileSystem> filesystem, const String& name,  const URL& url, PassRefPtr<FileCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
        : FileSystemCallbacksBase(errorCallback)
        , m_filesystem(filesystem)
        , m_name(name)


    RefPtr<DOMFileSystem> m_filesystem;
    String m_name;
    URL m_url;
    RefPtr<FileCallback> m_successCallback;
};



void DOMFileSystem::createFile(const FileEntry* fileEntry, PassRefPtr<FileCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
{
    URL fileSystemURL = createFileSystemURL(fileEntry);
    m_asyncFileSystem->createSnapshotFileAndReadMetadata(fileSystemURL, SnapshotFileCallback::create(this, fileEntry->name(), fileSystemURL, successCallback, errorCallback));
}





class DOMFileSystem : public DOMFileSystemBase, public ActiveDOMObject {
public:
    static PassRefPtr<DOMFileSystem> create(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);

    // Creates a new isolated file system for the given filesystemId.
    static PassRefPtr<DOMFileSystem> createIsolatedFileSystem(ScriptExecutionContext*, const String& filesystemId);

    }

private:
    DOMFileSystem(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);

    // ActiveDOMObject methods.
    virtual void stop() OVERRIDE;



const char DOMFileSystemBase::isolatedPathPrefix[] = "isolated";
const size_t DOMFileSystemBase::isolatedPathPrefixLength = sizeof(DOMFileSystemBase::isolatedPathPrefix) - 1;

DOMFileSystemBase::DOMFileSystemBase(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
    : m_context(context)
    , m_name(name)
    , m_type(type)

}

// static
bool DOMFileSystemBase::crackFileSystemURL(const URL& url, FileSystemType& type, String& filePath)
{
    if (!url.protocolIs("filesystem"))
        return false;

    return true;
}

URL DOMFileSystemBase::createFileSystemURL(const String& fullPath) const
{
    ASSERT(DOMFilePath::isAbsolute(fullPath));
    URL url = m_filesystemRootURL;
    // Remove the extra leading slash.
    url.setPath(url.path() + encodeWithURLEscapeSequences(fullPath.substring(1)));
    return url;

    return m_context->securityOrigin();
}

URL DOMFileSystemBase::createFileSystemURL(const EntryBase* entry) const
{
    return createFileSystemURL(entry->fullPath());
}



#include "AsyncFileSystem.h"
#include "FileSystemFlags.h"
#include "FileSystemType.h"
#include "URL.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/text/WTFString.h>

    static const char isolatedPathPrefix[];
    static const size_t isolatedPathPrefixLength;

    static PassRefPtr<DOMFileSystemBase> create(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
    {
        return adoptRef(new DOMFileSystemBase(context, name, type, rootURL, asyncFileSystem));
    }


    const String& name() const { return m_name; }
    FileSystemType type() const { return m_type; }
    URL rootURL() const { return m_filesystemRootURL; }
    AsyncFileSystem* asyncFileSystem() const { return m_asyncFileSystem.get(); }
    SecurityOrigin* securityOrigin() const;


    bool clonable() const { return m_clonable; }

    static bool isValidType(FileSystemType);
    static bool crackFileSystemURL(const URL&, FileSystemType&, String& filePath);
    bool supportsToURL() const;
    URL createFileSystemURL(const EntryBase*) const;
    URL createFileSystemURL(const String& fullPath) const;

    // Actual FileSystem API implementations. All the validity checks on virtual paths are done at this level.
    // They return false for immediate errors that don't involve lower AsyncFileSystem layer (e.g. for name validation errors). Otherwise they return true (but later may call back with an runtime error).

    bool readDirectory(PassRefPtr<DirectoryReaderBase>, const String& path, PassRefPtr<EntriesCallback>, PassRefPtr<ErrorCallback>);

protected:
    DOMFileSystemBase(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
    friend class DOMFileSystemSync;

    ScriptExecutionContext* m_context;
    String m_name;
    FileSystemType m_type;
    URL m_filesystemRootURL;
    bool m_clonable;

    mutable OwnPtr<AsyncFileSystem> m_asyncFileSystem;



    return adoptRef(new DOMFileSystemSync(fileSystem->m_context, fileSystem->name(), fileSystem->type(), fileSystem->rootURL(), fileSystem->m_asyncFileSystem.release()));
}

DOMFileSystemSync::DOMFileSystemSync(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
    : DOMFileSystemBase(context, name, type, rootURL, asyncFileSystem)
{
}

        friend class WTF::RefCounted<CreateFileResult>;
    };

    static PassOwnPtr<CreateFileHelper> create(PassRefPtr<CreateFileResult> result, const String& name, const URL& url, FileSystemType type)
    {
        return adoptPtr(new CreateFileHelper(result, name, url, type));
    }

        }
    }
private:
    CreateFileHelper(PassRefPtr<CreateFileResult> result, const String& name, const URL& url, FileSystemType type)
        : m_result(result)
        , m_name(name)
        , m_url(url)


    RefPtr<CreateFileResult> m_result;
    String m_name;
    URL m_url;
    FileSystemType m_type;
};


PassRefPtr<File> DOMFileSystemSync::createFile(const FileEntrySync* fileEntry, ExceptionCode& ec)
{
    ec = 0;
    URL fileSystemURL = createFileSystemURL(fileEntry);
    RefPtr<CreateFileHelper::CreateFileResult> result(CreateFileHelper::CreateFileResult::create());
    m_asyncFileSystem->createSnapshotFileAndReadMetadata(fileSystemURL, CreateFileHelper::create(result, fileEntry->name(), fileSystemURL, type()));
    if (!m_asyncFileSystem->waitForOperationToComplete()) {




class DOMFileSystemSync : public DOMFileSystemBase {
public:
    static PassRefPtr<DOMFileSystemSync> create(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
    {
        return adoptRef(new DOMFileSystemSync(context, name, type, rootURL, asyncFileSystem));
    }

    PassRefPtr<FileWriterSync> createWriter(const FileEntrySync*, ExceptionCode&);

private:
    DOMFileSystemSync(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
};

}

Lines 84-90 void DOMWindowFileSystem::webkitResolveLocalFileSystemURL(DOMWindow* window, con a/Source/WebCore/Modules/filesystem/DOMWindowFileSystem.cpp_sec1
- a/Source/WebCore/Modules/filesystem/DOMWindowFileSystem.cpp -1 / +1 lines
84	return;	84	return;
85		85
86	SecurityOrigin* securityOrigin = document->securityOrigin();	86	SecurityOrigin* securityOrigin = document->securityOrigin();
87	KURL completedURL = document->completeURL(url);	87	URL completedURL = document->completeURL(url);
88	if (!AsyncFileSystem::isAvailable() \|\| !securityOrigin->canAccessFileSystem() \|\| !securityOrigin->canRequest(completedURL)) {	88	if (!AsyncFileSystem::isAvailable() \|\| !securityOrigin->canAccessFileSystem() \|\| !securityOrigin->canRequest(completedURL)) {
89	DOMFileSystem::scheduleCallback(document, errorCallback, FileError::create(FileError::SECURITY_ERR));	89	DOMFileSystem::scheduleCallback(document, errorCallback, FileError::create(FileError::SECURITY_ERR));
90	return;	90	return;



{
}

void FileSystemCallbacks::didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
{
    if (m_successCallback) {
        ASSERT(asyncFileSystem);

{
}

void ResolveURICallbacks::didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
{
    ASSERT(asyncFileSystem);
    RefPtr<DirectoryEntry> root = DOMFileSystem::create(m_scriptExecutionContext.get(), name, m_type, rootURL, asyncFileSystem)->root();



class FileSystemCallbacks : public FileSystemCallbacksBase {
public:
    static PassOwnPtr<FileSystemCallbacks> create(PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType);
    virtual void didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);

private:
    FileSystemCallbacks(PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType);

class ResolveURICallbacks : public FileSystemCallbacksBase {
public:
    static PassOwnPtr<ResolveURICallbacks> create(PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType, const String& filePath);
    virtual void didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);

private:
    ResolveURICallbacks(PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType, const String& filePath);




void WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemURL(WorkerGlobalScope* worker, const String& url, PassRefPtr<EntryCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
{
    URL completedURL = worker->completeURL(url);
    ScriptExecutionContext* secureContext = worker->scriptExecutionContext();
    if (!AsyncFileSystem::isAvailable() || !secureContext->securityOrigin()->canAccessFileSystem() || !secureContext->securityOrigin()->canRequest(completedURL)) {
        DOMFileSystem::scheduleCallback(worker, errorCallback, FileError::create(FileError::SECURITY_ERR));

PassRefPtr<EntrySync> WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemSyncURL(WorkerGlobalScope* worker, const String& url, ExceptionCode& ec)
{
    ec = 0;
    URL completedURL = worker->completeURL(url);
    ScriptExecutionContext* secureContext = worker->scriptExecutionContext();
    if (!AsyncFileSystem::isAvailable() || !secureContext->securityOrigin()->canAccessFileSystem() || !secureContext->securityOrigin()->canRequest(completedURL)) {
        ec = FileException::SECURITY_ERR;




#if ENABLE(MEDIA_SOURCE)

#include "KURL.h"
#include "MediaSourceBase.h"
#include "URL.h"
#include <wtf/MainThread.h>

namespace WebCore {

    return instance;
}

void MediaSourceRegistry::registerURL(SecurityOrigin*, const URL& url, URLRegistrable* registrable)
{
    ASSERT(&registrable->registry() == this);
    ASSERT(isMainThread());

    m_mediaSources.set(url.string(), source);
}

void MediaSourceRegistry::unregisterURL(const URL& url)
{
    ASSERT(isMainThread());
    HashMap<String, RefPtr<MediaSourceBase> >::iterator iter = m_mediaSources.find(url.string());




namespace WebCore {

class URL;
class MediaSourceBase;

class MediaSourceRegistry : public URLRegistry {

    static MediaSourceRegistry& registry();

    // Registers a blob URL referring to the specified media source.
    virtual void registerURL(SecurityOrigin*, const URL&, URLRegistrable*) OVERRIDE;
    virtual void unregisterURL(const URL&) OVERRIDE;
    virtual URLRegistrable* lookup(const String&) OVERRIDE;

private:




#if ENABLE(MEDIA_STREAM)

#include "URL.h"
#include "MediaStream.h"
#include <wtf/MainThread.h>


    return instance;
}

void MediaStreamRegistry::registerURL(SecurityOrigin*, const URL& url, URLRegistrable* stream)
{
    ASSERT(&stream->registry() == this);
    ASSERT(isMainThread());
    m_streamDescriptors.set(url.string(), static_cast<MediaStream*>(stream)->descriptor());
}

void MediaStreamRegistry::unregisterURL(const URL& url)
{
    ASSERT(isMainThread());
    m_streamDescriptors.remove(url.string());




namespace WebCore {

class URL;
class MediaStream;
class MediaStreamDescriptor;


    static MediaStreamRegistry& registry();

    // Registers a blob URL referring to the specified stream data.
    virtual void registerURL(SecurityOrigin*, const URL&, URLRegistrable*) OVERRIDE;
    virtual void unregisterURL(const URL&) OVERRIDE;

    MediaStreamDescriptor* lookupMediaStreamDescriptor(const String& url);


Lines 99-105 PassRefPtr<RTCConfiguration> RTCPeerConnection::parseConfiguration(const Diction a/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp_sec1
- a/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp -1 / +1 lines
99	ec = TYPE_MISMATCH_ERR;	99	ec = TYPE_MISMATCH_ERR;
100	return 0;	100	return 0;
101	}	101	}
102	KURL url(KURL(), urlString);	102	URL url(URL(), urlString);
103	if (!url.isValid() \|\| !(url.protocolIs("turn") \|\| url.protocolIs("stun"))) {	103	if (!url.isValid() \|\| !(url.protocolIs("turn") \|\| url.protocolIs("stun"))) {
104	ec = TYPE_MISMATCH_ERR;	104	ec = TYPE_MISMATCH_ERR;
105	return 0;	105	return 0;



    String newURL = url;
    newURL.remove(index, WTF_ARRAY_LENGTH(token) - 1);

    URL base(ParsedURLString, baseURL);
    URL kurl(base, newURL);

    if (kurl.isEmpty() || !kurl.isValid()) {
        ec = SYNTAX_ERR;



        return;
    }

    m_icon = iconURI.isEmpty() ? URL() : scriptExecutionContext()->completeURL(iconURI);
    if (!m_icon.isEmpty() && !m_icon.isValid()) {
        ec = SYNTAX_ERR;
        return;

    if (options.get("dir", argument))
        notification->setDir(argument);
    if (options.get("icon", argument)) {
        URL iconURI = argument.isEmpty() ? URL() : context->completeURL(argument);
        if (!iconURI.isEmpty() && iconURI.isValid())
            notification->setIconURL(iconURI);
    }



#include "ActiveDOMObject.h"
#include "EventNames.h"
#include "EventTarget.h"
#include "URL.h"
#include "NotificationClient.h"
#include "SharedBuffer.h"
#include "TextDirection.h"

#endif
    void close();

    URL iconURL() const { return m_icon; }
    void setIconURL(const URL& url) { m_icon = url; }

    String title() const { return m_title; }
    String body() const { return m_body; }

#endif

    // Text notifications.
    URL m_icon;
    String m_title;
    String m_body;
    String m_direction;

Lines 39-45 a/Source/WebCore/Modules/notifications/NotificationClient.h_sec1
- a/Source/WebCore/Modules/notifications/NotificationClient.h -1 / +1 lines
39	namespace WebCore {	39	namespace WebCore {
40		40
41	class Document;	41	class Document;
42	class KURL;	42	class URL;
43	class Notification;	43	class Notification;
44	class Page;	44	class Page;
45	class ScriptExecutionContext;	45	class ScriptExecutionContext;



    return adoptRef(new SpeechGrammar);
}

PassRefPtr<SpeechGrammar> SpeechGrammar::create(const URL& src, double weight)
{
    return adoptRef(new SpeechGrammar(src, weight));
}

{
}

SpeechGrammar::SpeechGrammar(const URL& src, double weight)
    : m_src(src)
    , m_weight(weight)
{




#if ENABLE(SCRIPTED_SPEECH)

#include "URL.h"
#include <wtf/RefCounted.h>
#include <wtf/text/WTFString.h>


class SpeechGrammar : public RefCounted<SpeechGrammar> {
public:
    static PassRefPtr<SpeechGrammar> create(); // FIXME: The spec is not clear on what the constructor should look like.
    static PassRefPtr<SpeechGrammar> create(const URL& src, double weight);

    const URL& src(ScriptExecutionContext*) const { return m_src; }
    const URL& src() const { return m_src; }
    void setSrc(ScriptExecutionContext*, const String& src);

    double weight() const { return m_weight; }


private:
    SpeechGrammar();
    SpeechGrammar(const URL& src, double weight);

    URL m_src;
    double m_weight;
};


Lines 55-61 void SpeechGrammarList::addFromUri(ScriptExecutionContext* scriptExecutionContex a/Source/WebCore/Modules/speech/SpeechGrammarList.cpp_sec1
- a/Source/WebCore/Modules/speech/SpeechGrammarList.cpp -1 / +1 lines
55	void SpeechGrammarList::addFromString(const String& string, double weight)	55	void SpeechGrammarList::addFromString(const String& string, double weight)
56	{	56	{
57	String urlString = String("data:application/xml,") + encodeWithURLEscapeSequences(string);	57	String urlString = String("data:application/xml,") + encodeWithURLEscapeSequences(string);
58	m_grammars.append(SpeechGrammar::create(KURL(KURL(), urlString), weight));	58	m_grammars.append(SpeechGrammar::create(URL(URL(), urlString), weight));
59	}	59	}
60		60
61	SpeechGrammarList::SpeechGrammarList()	61	SpeechGrammarList::SpeechGrammarList()



namespace WebCore {

class Blob;
class URL;
class ScriptExecutionContext;
class WebSocketChannelClient;


        InvalidMessage
    };

    virtual void connect(const URL&, const String& protocol) = 0;
    virtual String subprotocol() = 0; // Will be available after didConnect() callback is invoked.
    virtual String extensions() = 0; // Will be available after didConnect() callback is invoked.
    virtual SendResult send(const String& message) = 0;



void WebSocket::connect(const String& url, const Vector<String>& protocols, ExceptionCode& ec)
{
    LOG(Network, "WebSocket %p connect() url='%s'", this, url.utf8().data());
    m_url = URL(URL(), url);

    if (!m_url.isValid()) {
        scriptExecutionContext()->addConsoleMessage(JSMessageSource, ErrorMessageLevel, "Invalid url for WebSocket " + m_url.stringCenterEllipsizedToLength());

        m_channel->close(code, reason);
}

const URL& WebSocket::url() const
{
    return m_url;
}



#include "EventListener.h"
#include "EventNames.h"
#include "EventTarget.h"
#include "URL.h"
#include "WebSocketChannel.h"
#include "WebSocketChannelClient.h"
#include <wtf/Forward.h>

    void close(ExceptionCode& ec) { close(WebSocketChannel::CloseEventCodeNotSpecified, String(), ec); }
    void close(int code, ExceptionCode& ec) { close(code, String(), ec); }

    const URL& url() const;
    State readyState() const;
    unsigned long bufferedAmount() const;


    RefPtr<ThreadableWebSocketChannel> m_channel;

    State m_state;
    URL m_url;
    unsigned long m_bufferedAmount;
    unsigned long m_bufferedAmountAfterClose;
    BinaryType m_binaryType;

Lines 99-105 WebSocketChannel::~WebSocketChannel() a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp -1 / +1 lines
99	{	99	{
100	}	100	}
101		101
102	void WebSocketChannel::connect(const KURL& url, const String& protocol)	102	void WebSocketChannel::connect(const URL& url, const String& protocol)
103	{	103	{
104	LOG(Network, "WebSocketChannel %p connect()", this);	104	LOG(Network, "WebSocketChannel %p connect()", this);
105	ASSERT(!m_handle);	105	ASSERT(!m_handle);

Lines 68-74 public: a/Source/WebCore/Modules/websockets/WebSocketChannel.h_sec1
- a/Source/WebCore/Modules/websockets/WebSocketChannel.h -1 / +1 lines
68	bool send(const char* data, int length);	68	bool send(const char* data, int length);
69		69
70	// ThreadableWebSocketChannel functions.	70	// ThreadableWebSocketChannel functions.
71	virtual void connect(const KURL&, const String& protocol) OVERRIDE;	71	virtual void connect(const URL&, const String& protocol) OVERRIDE;
72	virtual String subprotocol() OVERRIDE;	72	virtual String subprotocol() OVERRIDE;
73	virtual String extensions() OVERRIDE;	73	virtual String extensions() OVERRIDE;
74	virtual ThreadableWebSocketChannel::SendResult send(const String& message) OVERRIDE;	74	virtual ThreadableWebSocketChannel::SendResult send(const String& message) OVERRIDE;



#include "Document.h"
#include "HTTPHeaderMap.h"
#include "HTTPParsers.h"
#include "URL.h"
#include "Logging.h"
#include "ResourceRequest.h"
#include "ScriptCallStack.h"


static const char randomCharacterInSecWebSocketKey[] = "!\"#$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";

static String resourceName(const URL& url)
{
    StringBuilder name;
    name.append(url.path());

    return result;
}

static String hostName(const URL& url, bool secure)
{
    ASSERT(url.protocolIs("wss") == secure);
    StringBuilder builder;

    return base64Encode(reinterpret_cast<const char*>(hash.data()), sha1HashSize);
}

WebSocketHandshake::WebSocketHandshake(const URL& url, const String& protocol, ScriptExecutionContext* context)
    : m_url(url)
    , m_clientProtocol(protocol)
    , m_secure(m_url.protocolIs("wss"))

{
}

const URL& WebSocketHandshake::url() const
{
    return m_url;
}

void WebSocketHandshake::setURL(const URL& url)
{
    m_url = url.copy();
}

    if (!m_clientProtocol.isEmpty())
        fields.append("Sec-WebSocket-Protocol: " + m_clientProtocol);

    URL url = httpURLForAuthenticationAndCookies();
    if (m_context->isDocument()) {
        Document* document = toDocument(m_context);
        String cookie = cookieRequestHeaderFieldValue(document, url);

    if (!m_clientProtocol.isEmpty())
        request.addHTTPHeaderField("Sec-WebSocket-Protocol", m_clientProtocol);

    URL url = httpURLForAuthenticationAndCookies();
    if (m_context->isDocument()) {
        Document* document = toDocument(m_context);
        String cookie = cookieRequestHeaderFieldValue(document, url);

    m_extensionDispatcher.addProcessor(processor);
}

URL WebSocketHandshake::httpURLForAuthenticationAndCookies() const
{
    URL url = m_url.copy();
    bool couldSetProtocol = url.setProtocol(m_secure ? "https" : "http");
    ASSERT_UNUSED(couldSetProtocol, couldSetProtocol);
    return url;




#if ENABLE(WEB_SOCKETS)

#include "URL.h"
#include "ResourceResponse.h"
#include "WebSocketExtensionDispatcher.h"
#include "WebSocketExtensionProcessor.h"

    enum Mode {
        Incomplete, Normal, Failed, Connected
    };
    WebSocketHandshake(const URL&, const String& protocol, ScriptExecutionContext*);
    ~WebSocketHandshake();

    const URL& url() const;
    void setURL(const URL&);
    const String host() const;

    const String& clientProtocol() const;

    static String getExpectedWebSocketAccept(const String& secWebSocketKey);

private:
    URL httpURLForAuthenticationAndCookies() const;

    int readStatusLine(const char* header, size_t headerLength, int& statusCode, String& statusText);


    void processHeaders();
    bool checkResponseHeaders();

    URL m_url;
    String m_clientProtocol;
    bool m_secure;
    ScriptExecutionContext* m_context;



        m_bridge->disconnect();
}

void WorkerThreadableWebSocketChannel::connect(const URL& url, const String& protocol)
{
    if (m_bridge)
        m_bridge->connect(url, protocol);

        m_mainWebSocketChannel->disconnect();
}

void WorkerThreadableWebSocketChannel::Peer::connect(const URL& url, const String& protocol)
{
    ASSERT(isMainThread());
    if (!m_mainWebSocketChannel)

        m_workerClientWrapper->setFailedWebSocketChannelCreation();
}

void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* context, Peer* peer, const URL& url, const String& protocol)
{
    ASSERT(isMainThread());
    ASSERT_UNUSED(context, context->isDocument());

    peer->connect(url, protocol);
}

void WorkerThreadableWebSocketChannel::Bridge::connect(const URL& url, const String& protocol)
{
    ASSERT(m_workerClientWrapper);
    if (!m_peer)

    peer->send(*arrayBuffer);
}

void WorkerThreadableWebSocketChannel::mainThreadSendBlob(ScriptExecutionContext* context, Peer* peer, const URL& url, const String& type, long long size)
{
    ASSERT(isMainThread());
    ASSERT_UNUSED(context, context->isDocument());




namespace WebCore {

class URL;
class ScriptExecutionContext;
class ThreadableWebSocketChannelClientWrapper;
class WorkerGlobalScope;

    virtual ~WorkerThreadableWebSocketChannel();

    // ThreadableWebSocketChannel functions.
    virtual void connect(const URL&, const String& protocol) OVERRIDE;
    virtual String subprotocol() OVERRIDE;
    virtual String extensions() OVERRIDE;
    virtual ThreadableWebSocketChannel::SendResult send(const String& message) OVERRIDE;

        }
        ~Peer();

        void connect(const URL&, const String& protocol);
        void send(const String& message);
        void send(const JSC::ArrayBuffer&);
        void send(const Blob&);

        }
        ~Bridge();
        void initialize();
        void connect(const URL&, const String& protocol);
        ThreadableWebSocketChannel::SendResult send(const String& message);
        ThreadableWebSocketChannel::SendResult send(const JSC::ArrayBuffer&, unsigned byteOffset, unsigned byteLength);
        ThreadableWebSocketChannel::SendResult send(const Blob&);


    WorkerThreadableWebSocketChannel(WorkerGlobalScope*, WebSocketChannelClient*, const String& taskMode);

    static void mainThreadConnect(ScriptExecutionContext*, Peer*, const URL&, const String& protocol);
    static void mainThreadSend(ScriptExecutionContext*, Peer*, const String& message);
    static void mainThreadSendArrayBuffer(ScriptExecutionContext*, Peer*, PassOwnPtr<Vector<char> >);
    static void mainThreadSendBlob(ScriptExecutionContext*, Peer*, const URL&, const String& type, long long size);
    static void mainThreadBufferedAmount(ScriptExecutionContext*, Peer*);
    static void mainThreadClose(ScriptExecutionContext*, Peer*, int code, const String& reason);
    static void mainThreadFail(ScriptExecutionContext*, Peer*, const String& reason);



    platform/image-decoders/gif/GIFImageDecoder.cpp \
    platform/image-decoders/gif/GIFImageReader.cpp\
    platform/KillRingNone.cpp \
    platform/URL.cpp \
    platform/Language.cpp \
    platform/Length.cpp \
    platform/LengthBox.cpp \

    platform/image-decoders/gif/GIFImageReader.h \
    platform/image-decoders/png/PNGImageDecoder.h \
    platform/KillRing.h \
    platform/URL.h \
    platform/Length.h \
    platform/LengthBox.h \
    platform/leveldb/LevelDBComparator.h \

    platform/graphics/qt/GlyphPageTreeNodeQt.cpp \
    platform/graphics/qt/SimpleFontDataQt.cpp \
    platform/graphics/qt/TileQt.cpp \
    platform/qt/URLQt.cpp \
    platform/qt/MIMETypeRegistryQt.cpp \
    platform/qt/PasteboardQt.cpp \
    platform/qt/PlatformKeyboardEventQt.cpp \



__ZN3WTF12AtomicString3addEPK10__CFString
__ZN3WTF6StringC1EP8NSString
__ZN3WTF6StringC1EPK10__CFString
__ZN7WebCore8GradientD1Ev
__ZN7WebCore10ClientRectC1ERKNS_7IntRectE
__ZN7WebCore10ClientRectC1ERKNS_9FloatRectE
__ZN7WebCore10ClientRectC1Ev

__ZN7WebCore10ScrollView23setPaintsEntireContentsEb
__ZN7WebCore10ScrollView23setScrollbarsSuppressedEbb
__ZN7WebCore10ScrollView24windowResizerRectChangedEv
__ZN7WebCore10ScrollView4hideEv
__ZN7WebCore10ScrollView4showEv
__ZN7WebCore10ScrollView5paintEPNS_15GraphicsContextERKNS_7IntRectE
__ZN7WebCore10ScrollView8addChildEN3WTF10PassRefPtrINS_6WidgetEEE
__ZN7WebCore10StorageMap10removeItemERKN3WTF6StringERS2_

__ZN7WebCore10StorageMap7setItemERKN3WTF6StringES4_RS2_Rb
__ZN7WebCore10deleteFileERKN3WTF6StringE
__ZN7WebCore10fileExistsERKN3WTF6StringE
__ZN7WebCore10setCookiesEPNS_8DocumentERKNS_3URLERKN3WTF6StringE
__ZN7WebCore10toDocumentEN3JSC7JSValueE
__ZN7WebCore11BitmapImage13getCGImageRefEv
__ZN7WebCore11BitmapImageC1EP7CGImagePNS_13ImageObserverE
__ZN7WebCore11BitmapImageC1EPNS_13ImageObserverE
__ZN7WebCore11BitmapImage13getCGImageRefEv
__ZN7WebCore11CachedFrame23cachedFramePlatformDataEv
__ZN7WebCore11CachedFrame26setCachedFramePlatformDataEN3WTF10PassOwnPtrINS_23CachedFramePlatformDataEEE
__ZN7WebCore11FileChooser10chooseFileERKN3WTF6StringE

__ZN7WebCore11FileChooserD1Ev
__ZN7WebCore11FrameLoader11loadArchiveEN3WTF10PassRefPtrINS_7ArchiveEEE
__ZN7WebCore11FrameLoader11shouldCloseEv
__ZN7WebCore11FrameLoader11urlSelectedERKNS_3URLERKN3WTF6StringENS4_10PassRefPtrINS_5EventEEEbbNS_18ShouldSendReferrerE
__ZN7WebCore11FrameLoader12shouldReloadERKNS_4KURLES3_
__ZN7WebCore11FrameLoader14detachChildrenEv
__ZN7WebCore11FrameLoader14stopAllLoadersENS_26ClearProvisionalItemPolicyE
__ZN7WebCore11FrameLoader16detachFromParentEv
__ZN7WebCore11FrameLoader16loadFrameRequestERKNS_16FrameLoadRequestEbbN3WTF10PassRefPtrINS_5EventEEENS5_INS_9FormStateEEENS_18ShouldSendReferrerE
__ZN7WebCore11FrameLoader17stopForUserCancelEb
__ZN7WebCore11FrameLoader21loadURLIntoChildFrameERKNS_3URLERKN3WTF6StringEPNS_5FrameE
__ZN7WebCore11FrameLoader22findFrameForNavigationERKN3WTF12AtomicStringEPNS_8DocumentE
__ZN7WebCore11FrameLoader23timeOfLastCompletedLoadEv
__ZN7WebCore11FrameLoader26reloadWithOverrideEncodingERKN3WTF6StringE

__ZN7WebCore11HistoryItem20setTransientPropertyERKN3WTF6StringEP11objc_object
__ZN7WebCore11HistoryItem21decodeBackForwardTreeERKN3WTF6StringES4_S4_RNS1_7DecoderE
__ZN7WebCore11HistoryItem22mergeAutoCompleteHintsEPS0_
__ZN7WebCore11HistoryItem6setURLERKNS_4KURLE
__ZN7WebCore11HistoryItem7visitedERKN3WTF6StringEdNS_18VisitCountBehaviorE
__ZN7WebCore11HistoryItem8formDataEv
__ZN7WebCore11HistoryItem8setTitleERKN3WTF6StringE
__ZN7WebCore11HistoryItemC1ERKN3WTF6StringES4_S4_d
__ZN7WebCore11HistoryItemC1ERKN3WTF6StringES4_d
__ZN7WebCore11HistoryItemC1ERKNS_3URLERKN3WTF6StringES7_S7_
__ZN7WebCore11HistoryItemC1Ev
__ZN7WebCore11HistoryItemD1Ev
__ZN7WebCore11JSDOMWindow6s_infoE

__ZN7WebCore11MemoryCache13getStatisticsEv
__ZN7WebCore11MemoryCache13setCapacitiesEjjj
__ZN7WebCore11MemoryCache14evictResourcesEv
__ZN7WebCore11MemoryCache14resourceForURLERKNS_3URLE
__ZN7WebCore11MemoryCache18resourceForRequestERKNS_15ResourceRequestE
__ZN7WebCore11MemoryCache19getOriginsWithCacheERN3WTF7HashSetINS1_6RefPtrINS_14SecurityOriginEEENS_18SecurityOriginHashENS1_10HashTraitsIS5_EEEE
__ZN7WebCore11MemoryCache25removeResourcesWithOriginEPNS_14SecurityOriginE

__ZN7WebCore11PageConsole24setShouldPrintExceptionsEb
__ZN7WebCore11SQLResultOkE
__ZN7WebCore11URLWithDataEP6NSDataP5NSURL
__ZN7WebCore11getURLBytesEPK7__CFURLRN3WTF7CStringE
__ZN7WebCore11getURLBytesEPK7__CFURLRN3WTF6VectorIcLm512ENS3_15CrashOnOverflowEEE
__ZN7WebCore11getURLBytesEPK7__CFURLRN3WTF7CStringE
__ZN7WebCore11iBeamCursorEv
__ZN7WebCore11memoryCacheEv
__ZN7WebCore11startOfLineERKNS_15VisiblePositionE

__ZN7WebCore12UTF8EncodingEv
__ZN7WebCore12cacheStorageEv
__ZN7WebCore12createMarkupEPKNS_5RangeEPN3WTF6VectorIPNS_4NodeELm0ENS3_15CrashOnOverflowEEENS_23EAnnotateForInterchangeEbNS_13EAbsoluteURLsE
__ZN7WebCore12deleteCookieERKNS_21NetworkStorageSessionERKNS_3URLERKN3WTF6StringE
__ZN7WebCore12gcControllerEv
__ZN7WebCore12iconDatabaseEv
__ZN7WebCore13AXObjectCache10rootObjectEv

__ZN7WebCore13GraphicsLayer20setReplicatedByLayerEPS0_
__ZN7WebCore13GraphicsLayer54noteDeviceOrPageScaleFactorChangedIncludingDescendantsEv
__ZN7WebCore13GraphicsLayer6createEPNS_20GraphicsLayerFactoryEPNS_19GraphicsLayerClientE
__ZN7WebCore13GraphicsLayer7setSizeERKNS_9FloatSizeE
__ZN7WebCore13GraphicsLayer8addChildEPS0_
__ZN7WebCore13GraphicsLayerC2EPNS_19GraphicsLayerClientE
__ZN7WebCore13GraphicsLayerD2Ev

__ZN7WebCore13ResourceErrorC1EP7NSError
__ZN7WebCore13ResourceErrorC1EP9__CFError
__ZN7WebCore13SQLResultDoneE
__ZN7WebCore13ScriptGCEvent11getHeapSizeERNS_8HeapInfoE
__ZN7WebCore13StyledElement22setInlineStylePropertyENS_13CSSPropertyIDERKN3WTF6StringEb
__ZN7WebCore13StyledElement22setInlineStylePropertyENS_13CSSPropertyIDEdNS_17CSSPrimitiveValue9UnitTypesEb
__ZN7WebCore13cookiesForDOMERKNS_21NetworkStorageSessionERKNS_3URLES5_
__ZN7WebCore13createWrapperEPN3JSC9ExecStateEPNS_17JSDOMGlobalObjectEPNS_4NodeE
__ZN7WebCore13directoryNameERKN3WTF6StringE
__ZN7WebCore13getRawCookiesERKNS_21NetworkStorageSessionERKNS_3URLES5_RN3WTF6VectorINS_6CookieELm0ENS6_15CrashOnOverflowEEE
__ZN7WebCore13listDirectoryERKN3WTF6StringES3_
__ZN7WebCore13pointerCursorEv
__ZN7WebCore13toJSDOMWindowEN3JSC7JSValueE

__ZN7WebCore14SecurityOrigin16createFromStringERKN3WTF6StringE
__ZN7WebCore14SecurityOrigin28createFromDatabaseIdentifierERKN3WTF6StringE
__ZN7WebCore14SecurityOrigin6createERKN3WTF6StringES4_i
__ZN7WebCore14SecurityOrigin6createERKNS_3URLE
__ZN7WebCore14SecurityPolicy18setLocalLoadPolicyENS0_15LocalLoadPolicyE
__ZN7WebCore14SecurityPolicy22generateReferrerHeaderENS_14ReferrerPolicyERKNS_3URLERKN3WTF6StringE
__ZN7WebCore14SecurityPolicy22generateReferrerHeaderENS_14ReferrerPolicyERKNS_4KURLERKN3WTF6StringE
__ZN7WebCore14SecurityPolicy27resetOriginAccessWhitelistsEv
__ZN7WebCore14SecurityPolicy29addOriginAccessWhitelistEntryERKNS_14SecurityOriginERKN3WTF6StringES7_b
__ZN7WebCore14SecurityPolicy32removeOriginAccessWhitelistEntryERKNS_14SecurityOriginERKN3WTF6StringES7_b

__ZN7WebCore14StorageTracker7originsERN3WTF6VectorINS1_6RefPtrINS_14SecurityOriginEEELm0ENS1_15CrashOnOverflowEEE
__ZN7WebCore14StorageTracker7trackerEv
__ZN7WebCore14SubframeLoader12allowPluginsENS_28ReasonForCallingAllowPluginsE
__ZN7WebCore14cookiesEnabledERKNS_21NetworkStorageSessionERKNS_3URLES5_
__ZN7WebCore14decodeHostNameEP8NSString
__ZN7WebCore14encodeHostNameEP8NSString
__ZN7WebCore14endOfParagraphERKNS_15VisiblePositionENS_27EditingBoundaryCrossingRuleE

__ZN7WebCore15AffineTransform9translateEdd
__ZN7WebCore15AffineTransformC1Edddddd
__ZN7WebCore15AffineTransformC1Ev
__ZN7WebCore15ArchiveResource6createEN3WTF10PassRefPtrINS_12SharedBufferEEERKNS_3URLERKNS1_6StringESA_SA_RKNS_16ResourceResponseE
__ZN7WebCore15BackForwardList10removeItemEPNS_11HistoryItemE
__ZN7WebCore15BackForwardList10setEnabledEb
__ZN7WebCore15BackForwardList11currentItemEv
__ZN7WebCore15BackForwardList11forwardItemEv
__ZN7WebCore15BackForwardList11setCapacityEi
__ZN7WebCore15BackForwardList12containsItemEPNS_11HistoryItemE
__ZN7WebCore15BackForwardList17backListWithLimitEiRN3WTF6VectorINS1_6RefPtrINS_11HistoryItemEEELm0ENS1_15CrashOnOverflowEEE
__ZN7WebCore15BackForwardList20forwardListWithLimitEiRN3WTF6VectorINS1_6RefPtrINS_11HistoryItemEEELm0ENS1_15CrashOnOverflowEEE
__ZN7WebCore15BackForwardList6closedEv
__ZN7WebCore15BackForwardList6goBackEv
__ZN7WebCore15BackForwardList7enabledEv
__ZN7WebCore15BackForwardList7entriesEv
__ZN7WebCore15BackForwardList8backItemEv
__ZN7WebCore15BackForwardList8capacityEv
__ZN7WebCore15BackForwardList9goForwardEv
__ZN7WebCore15BackForwardListC1EPNS_4PageE
__ZN7WebCore15DOMWrapperWorld13clearWrappersEv
__ZN7WebCore15DOMWrapperWorldD1Ev
__ZN7WebCore15DatabaseManager10initializeERKN3WTF6StringE

__ZN7WebCore15DatabaseManager8setQuotaEPNS_14SecurityOriginEy
__ZN7WebCore15DatabaseManager9setClientEPNS_21DatabaseManagerClientE
__ZN7WebCore15FocusController10setFocusedEb
__ZN7WebCore15FocusController17setFocusedElementEPNS_7ElementEN3WTF10PassRefPtrINS_5FrameEEENS_14FocusDirectionE
__ZN7WebCore15FocusController15setFocusedFrameEN3WTF10PassRefPtrINS_5FrameEEE
__ZN7WebCore15FocusController15setInitialFocusENS_14FocusDirectionEPNS_13KeyboardEventE
__ZN7WebCore15FocusController17setFocusedElementEPNS_7ElementEN3WTF10PassRefPtrINS_5FrameEEENS_14FocusDirectionE
__ZN7WebCore15FocusController28setContainingWindowIsVisibleEb
__ZN7WebCore15FocusController9setActiveEb
__ZN7WebCore15GraphicsContext10strokeRectERKNS_9FloatRectEf

__ZN7WebCore15VisiblePositionC1ERKNS_8PositionENS_9EAffinityE
__ZN7WebCore15defaultLanguageEv
__ZN7WebCore15localizedStringEPKc
__ZN7WebCore15mimeTypeFromURLERKNS_3URLE
__ZN7WebCore15originalURLDataEP5NSURL
__ZN7WebCore15pathGetFileNameERKN3WTF6StringE
__ZN7WebCore15reportExceptionEPN3JSC9ExecStateENS0_7JSValueEPNS_12CachedScriptE

__ZN7WebCore15visitedLinkHashERKN3WTF6StringE
__ZN7WebCore16ApplicationCache18diskUsageForOriginEPNS_14SecurityOriginE
__ZN7WebCore16ApplicationCache20deleteCacheForOriginEPNS_14SecurityOriginE
__ZN7WebCore16CSSParserContextC1ERNS_8DocumentERKNS_3URLERKN3WTF6StringE
__ZN7WebCore16DatabaseStrategy17getDatabaseServerEv
__ZN7WebCore16DeviceMotionData12Acceleration6createEbdbdbd
__ZN7WebCore16DeviceMotionData12RotationRate6createEbdbdbd

__ZN7WebCore17cacheDOMStructureEPNS_17JSDOMGlobalObjectEPN3JSC9StructureEPKNS2_9ClassInfoE
__ZN7WebCore17languageDidChangeEv
__ZN7WebCore17openTemporaryFileERKN3WTF6StringERi
__ZN7WebCore17setCookiesFromDOMERKNS_21NetworkStorageSessionERKNS_3URLES5_RKN3WTF6StringE
__ZN7WebCore17userVisibleStringEP5NSURL
__ZN7WebCore18DOMWindowExtensionC1EPNS_5FrameEPNS_15DOMWrapperWorldE
__ZN7WebCore18PlatformPasteboard10uniqueNameEv

__ZN7WebCore18isStartOfParagraphERKNS_15VisiblePositionENS_27EditingBoundaryCrossingRuleE
__ZN7WebCore18makeAllDirectoriesERKN3WTF6StringE
__ZN7WebCore18pluginScriptObjectEPN3JSC9ExecStateEPNS_13JSHTMLElementE
__ZN7WebCore18proxyServersForURLERKNS_3URLEPKNS_17NetworkingContextE
__ZNK7WebCore19AnimationController11isSuspendedEv
__ZN7WebCore19AnimationController16resumeAnimationsEv
__ZN7WebCore19AnimationController17suspendAnimationsEv
__ZN7WebCore19AnimationController20pauseAnimationAtTimeEPNS_12RenderObjectERKN3WTF12AtomicStringEd
__ZN7WebCore19AnimationController21pauseTransitionAtTimeEPNS_12RenderObjectERKN3WTF6StringEd
__ZN7WebCore19AnimationController36setAllowsNewAnimationsWhileSuspendedEb
__ZNK7WebCore19AnimationController33allowsNewAnimationsWhileSuspendedEv
__ZN7WebCore15BackForwardList10removeItemEPNS_11HistoryItemE
__ZN7WebCore15BackForwardList10setEnabledEb
__ZN7WebCore15BackForwardList11currentItemEv
__ZN7WebCore15BackForwardList11forwardItemEv
__ZN7WebCore15BackForwardList11setCapacityEi
__ZN7WebCore15BackForwardList12containsItemEPNS_11HistoryItemE
__ZN7WebCore15BackForwardList17backListWithLimitEiRN3WTF6VectorINS1_6RefPtrINS_11HistoryItemEEELm0ENS1_15CrashOnOverflowEEE
__ZN7WebCore15BackForwardList20forwardListWithLimitEiRN3WTF6VectorINS1_6RefPtrINS_11HistoryItemEEELm0ENS1_15CrashOnOverflowEEE
__ZN7WebCore15BackForwardList6closedEv
__ZN7WebCore15BackForwardList6goBackEv
__ZN7WebCore15BackForwardList7enabledEv
__ZN7WebCore15BackForwardList7entriesEv
__ZN7WebCore15BackForwardList8backItemEv
__ZN7WebCore15BackForwardList8capacityEv
__ZN7WebCore15BackForwardList9goForwardEv
__ZN7WebCore15BackForwardListC1EPNS_4PageE
__ZN7WebCore19HTMLTextAreaElement8setValueERKN3WTF6StringE
__ZN7WebCore19LayerFlushScheduler10invalidateEv
__ZN7WebCore19LayerFlushScheduler23runLoopObserverCallbackEv
__ZN7WebCore19LayerFlushScheduler6resumeEv
__ZN7WebCore19LayerFlushScheduler7suspendEv
__ZN7WebCore19LayerFlushScheduler8scheduleEv
__ZN7WebCore19LayerFlushSchedulerC1EPNS_25LayerFlushSchedulerClientE
__ZN7WebCore19LayerFlushSchedulerC2EPNS_25LayerFlushSchedulerClientE
__ZN7WebCore19LayerFlushSchedulerD1Ev
__ZN7WebCore19LayerFlushSchedulerD2Ev
__ZN7WebCore19LayerFlushScheduler23runLoopObserverCallbackEv
__ZN7WebCore19LayerFlushSchedulerC1EPNS_25LayerFlushSchedulerClientE
__ZN7WebCore19ResourceRequestBase11setHTTPBodyEN3WTF10PassRefPtrINS_8FormDataEEE
__ZN7WebCore19ResourceRequestBase13setHTTPMethodERKN3WTF6StringE
__ZN7WebCore19ResourceRequestBase18setHTTPHeaderFieldEPKcRKN3WTF6StringE

__ZN7WebCore19ResourceRequestBase24s_defaultTimeoutIntervalE
__ZN7WebCore19ResourceRequestBase25setDefaultTimeoutIntervalEd
__ZN7WebCore19ResourceRequestBase50setResponseContentDispositionEncodingFallbackArrayERKN3WTF6StringES4_S4_
__ZN7WebCore19ResourceRequestBase6setURLERKNS_3URLE
__ZN7WebCore19TextResourceDecoder5flushEv
__ZN7WebCore19TextResourceDecoder6decodeEPKcm
__ZN7WebCore19TextResourceDecoderC1ERKN3WTF6StringERKNS_12TextEncodingEb

__ZN7WebCore20RenderEmbeddedObject29setPluginUnavailabilityReasonENS0_26PluginUnavailabilityReasonE
__ZN7WebCore20RenderEmbeddedObject37setUnavailablePluginIndicatorIsHiddenEb
__ZN7WebCore20RenderEmbeddedObject44setPluginUnavailabilityReasonWithDescriptionENS0_26PluginUnavailabilityReasonERKN3WTF6StringE
__ZNK7WebCore20RenderEmbeddedObject21isReplacementObscuredEv
__ZN7WebCore20ResourceHandleClient16didReceiveBufferEPNS_14ResourceHandleEN3WTF10PassRefPtrINS_12SharedBufferEEEi
__ZN7WebCore20ResourceHandleClient20willSendRequestAsyncEPNS_14ResourceHandleERKNS_15ResourceRequestERKNS_16ResourceResponseE
__ZN7WebCore20ResourceHandleClient22willCacheResponseAsyncEPNS_14ResourceHandleEP19NSCachedURLResponse

__ZN7WebCore20ResourceResponseBase19setTextEncodingNameERKN3WTF6StringE
__ZN7WebCore20ResourceResponseBase20setSuggestedFilenameERKN3WTF6StringE
__ZN7WebCore20ResourceResponseBase24setExpectedContentLengthEx
__ZN7WebCore20ResourceResponseBase6setURLERKNS_3URLE
__ZN7WebCore20ResourceResponseBaseC2Ev
__ZN7WebCore20ResourceResponseBaseC2ERKNS_4KURLERKN3WTF6StringExS7_S7_
__ZN7WebCore20UserGestureIndicator7s_stateE
__ZN7WebCore20UserGestureIndicatorC1ENS_26ProcessingUserGestureStateE
__ZN7WebCore20UserGestureIndicatorD1Ev

__ZN7WebCore21ResourceLoadScheduler22suspendPendingRequestsEv
__ZN7WebCore21ResourceLoadScheduler23scheduleSubresourceLoadEPNS_5FrameEPNS_14CachedResourceERKNS_15ResourceRequestENS_20ResourceLoadPriorityERKNS_21ResourceLoaderOptionsE
__ZN7WebCore21ResourceLoadScheduler24schedulePluginStreamLoadEPNS_5FrameEPNS_32NetscapePlugInStreamLoaderClientERKNS_15ResourceRequestE
__ZN7WebCore21ResourceLoadScheduler27crossOriginRedirectReceivedEPNS_14ResourceLoaderERKNS_4KURLE
__ZN7WebCore21ResourceLoadScheduler32notifyDidScheduleResourceRequestEPNS_14ResourceLoaderE
__ZN7WebCore21ResourceLoadScheduler6removeEPNS_14ResourceLoaderE
__ZN7WebCore21ResourceLoadSchedulerC2Ev

__ZN7WebCore27CSSComputedStyleDeclarationC1EN3WTF10PassRefPtrINS_4NodeEEEbRKNS1_6StringE
__ZN7WebCore27DeviceOrientationClientMock14setOrientationEN3WTF10PassRefPtrINS_21DeviceOrientationDataEEE
__ZN7WebCore27DeviceOrientationClientMockC1Ev
__ZN7WebCore27protocolHostAndPortAreEqualERKNS_3URLES2_
__ZN7WebCore27startObservingCookieChangesEPFvvE
__ZN7WebCore28DocumentStyleSheetCollection12addUserSheetEN3WTF10PassRefPtrINS_18StyleSheetContentsEEE
__ZN7WebCore28DocumentStyleSheetCollection14addAuthorSheetEN3WTF10PassRefPtrINS_18StyleSheetContentsEEE
__ZN7WebCore28encodeWithURLEscapeSequencesERKN3WTF6StringE
__ZN7WebCore28removeLanguageChangeObserverEPv
__ZN7WebCore29cookieRequestHeaderFieldValueERKNS_21NetworkStorageSessionERKNS_3URLES5_
__ZN7WebCore29isCharacterSmartReplaceExemptEib
__ZN7WebCore30hostNameNeedsDecodingWithRangeEP8NSString8_NSRange
__ZN7WebCore30hostNameNeedsEncodingWithRangeEP8NSString8_NSRange

__ZN7WebCore33stripLeadingAndTrailingHTMLSpacesERKN3WTF6StringE
__ZN7WebCore37WidgetHierarchyUpdatesSuspensionScope11moveWidgetsEv
__ZN7WebCore37WidgetHierarchyUpdatesSuspensionScope35s_widgetHierarchyUpdateSuspendCountE
__ZN7WebCore3URL10invalidateEv
__ZN7WebCore3URLC1ENS_18ParsedURLStringTagERKN3WTF6StringE
__ZN7WebCore3URLC1EP5NSURL
__ZN7WebCore3URLC1EPK7__CFURL
__ZN7WebCore3URLC1ERKS0_RKN3WTF6StringE
__ZN7WebCore3macERKNS_10CredentialE
__ZN7WebCore3macERKNS_23AuthenticationChallengeE
__ZN7WebCore40restrictMinimumScaleFactorToViewportSizeERNS_18ViewportAttributesENS_7IntSizeEf

__ZN7WebCore4FontaSERKS0_
__ZN7WebCore4Icon18createIconForFilesERKN3WTF6VectorINS1_6StringELm0ENS1_15CrashOnOverflowEEE
__ZN7WebCore4IconD1Ev
__ZN7WebCore4KURL10invalidateEv
__ZN7WebCore4KURLC1ENS_18ParsedURLStringTagERKN3WTF6StringE
__ZN7WebCore4KURLC1EP5NSURL
__ZN7WebCore4KURLC1EPK7__CFURL
__ZN7WebCore4KURLC1ERKS0_RKN3WTF6StringE
__ZN7WebCore4Node10renderRectEPb
__ZN7WebCore4Node11appendChildEN3WTF10PassRefPtrIS0_EERiNS_14AttachBehaviorE
__ZN7WebCore4Node11removeChildEPS0_Ri

__ZN7WebCore7TextRun19allowsRoundingHacksEv
__ZN7WebCore7TextRun21s_allowsRoundingHacksE
__ZN7WebCore7TextRun22setAllowsRoundingHacksEb
__ZN7WebCore7cookiesEPKNS_8DocumentERKNS_3URLE
__ZN7WebCore7jsArrayEPN3JSC9ExecStateEPNS_17JSDOMGlobalObjectEN3WTF10PassRefPtrINS_13DOMStringListEEE
__ZN7WebCore7makeRGBEiii
__ZN7WebCore7replaceERN3WTF6StringERKNS_17RegularExpressionERKS1_
__ZN7WebCore7toInt64EPN3JSC9ExecStateENS0_7JSValueENS_30IntegerConversionConfigurationE
__ZN7WebCore7toRangeEN3JSC7JSValueE
__ZN7WebCore7toUInt8EPN3JSC9ExecStateENS0_7JSValueENS_30IntegerConversionConfigurationE
__ZN7WebCore8BlobData10appendBlobERKNS_3URLExx
__ZN7WebCore8BlobData14setContentTypeERKN3WTF6StringE
__ZN7WebCore8CSSValue7destroyEv
__ZN7WebCore8Document11createRangeEv
__ZN7WebCore8Document12updateLayoutEv
__ZN7WebCore8Document13createElementERKNS_13QualifiedNameEb
__ZN7WebCore8Document14createTextNodeERKN3WTF6StringE
__ZN7WebCore8Document17setFocusedElementEN3WTF10PassRefPtrINS_7ElementEEENS_14FocusDirectionE
__ZN7WebCore8Document16isPageBoxVisibleEi
__ZN7WebCore8Document16shortcutIconURLsEv
__ZN7WebCore8Document17setFocusedElementEN3WTF10PassRefPtrINS_7ElementEEENS_14FocusDirectionE
__ZN7WebCore8Document20styleResolverChangedENS_23StyleResolverUpdateFlagE
__ZN7WebCore8Document22createDocumentFragmentEv
__ZN7WebCore8Document23didAddWheelEventHandlerEv

__ZN7WebCore8FormDataD1Ev
__ZN7WebCore8Gradient12addColorStopEfRKNS_5ColorE
__ZN7WebCore8GradientC1ERKNS_10FloatPointES3_
__ZN7WebCore8GradientD1Ev
__ZN7WebCore8PositionC1EN3WTF10PassRefPtrINS_4NodeEEEiNS0_10AnchorTypeE
__ZN7WebCore8Settings13gQTKitEnabledE
__ZN7WebCore8Settings14setJavaEnabledEb
__ZN7WebCore8Settings15setQTKitEnabledEb
__ZN7WebCore8Settings16setImagesEnabledEb
__ZN7WebCore8Settings16setScriptEnabledEb
__ZN7WebCore8Settings16setUsesPageCacheEb

__ZN7WebCore8Settings24setUsesOverlayScrollbarsEb
__ZN7WebCore8Settings25setMinimumLogicalFontSizeEi
__ZN7WebCore8Settings25setPrivateBrowsingEnabledEb
__ZN7WebCore8Settings25setUserStyleSheetLocationERKNS_3URLE
__ZN7WebCore8Settings26defaultMinDOMTimerIntervalEv
__ZN7WebCore8Settings27setJavaEnabledForLocalFilesEb
__ZN7WebCore8Settings27setLoadsImagesAutomaticallyEb

__ZN7WebCore9FrameTree11appendChildEN3WTF10PassRefPtrINS_5FrameEEE
__ZN7WebCore9FrameTree7setNameERKN3WTF12AtomicStringE
__ZN7WebCore9FrameTree9clearNameEv
__ZN7WebCore9FrameView6createERNS_5FrameE
__ZN7WebCore9FrameView11forceLayoutEb
__ZN7WebCore9FrameView12setMediaTypeERKN3WTF6StringE
__ZN7WebCore9FrameView12tiledBackingEv

__ZN7WebCore9FrameView17willEndLiveResizeEv
__ZN7WebCore9FrameView18enableAutoSizeModeEbRKNS_7IntSizeES3_
__ZN7WebCore9FrameView18updateControlTintsEv
__ZN7WebCore9FrameView19willStartLiveResizeEv
__ZN7WebCore9FrameView19scrollElementToRectEPNS_7ElementERKNS_7IntRectE
__ZN7WebCore9FrameView19willStartLiveResizeEv
__ZN7WebCore9FrameView20enterCompositingModeEv
__ZN7WebCore9FrameView20removeScrollableAreaEPNS_14ScrollableAreaE
__ZN7WebCore9FrameView20resetTrackedRepaintsEv
__ZN7WebCore9FrameView20setCanHaveScrollbarsEb
__ZN7WebCore9FrameView21flushDeferredRepaintsEv
__ZN7WebCore9FrameView21resumeAnimatingImagesEv
__ZN7WebCore9FrameView22setBaseBackgroundColorERKNS_5ColorE

__ZN7WebCore9FrameView24setScrollPinningBehaviorENS_21ScrollPinningBehaviorE
__ZN7WebCore9FrameView26adjustPageHeightDeprecatedEPffff
__ZN7WebCore9FrameView26adjustTiledBackingCoverageEv
__ZN7WebCore9FrameView29setShouldUpdateWhileOffscreenEb
__ZN7WebCore9FrameView29setAutoSizeFixedMinimumHeightEi
__ZN7WebCore9FrameView29setShouldUpdateWhileOffscreenEb
__ZN7WebCore9FrameView31setVisualUpdatesAllowedByClientEb
__ZN7WebCore9FrameView37setScrollingPerformanceLoggingEnabledEb
__ZN7WebCore9FrameView37updateLayoutAndStyleIfNeededRecursiveEv
__ZN7WebCore9FrameView38scrollPositionChangedViaPlatformWidgetEv
__ZN7WebCore9FrameView39flushCompositingStateIncludingSubframesEv
__ZN7WebCore9FrameView6createERNS_5FrameE
__ZN7WebCore9HTMLNames10listingTagE
__ZN7WebCore9HTMLNames11textareaTagE
__ZN7WebCore9HTMLNames12selectedAttrE

__ZN7WebCore9PageGroup17closeLocalStorageEv
__ZN7WebCore9PageGroup18addVisitedLinkHashEy
__ZN7WebCore9PageGroup18numberOfPageGroupsEv
__ZN7WebCore9PageGroup20addUserScriptToWorldEPNS_15DOMWrapperWorldERKN3WTF6StringERKNS_3URLERKNS3_6VectorIS4_Lm0ENS3_15CrashOnOverflowEEESE_NS_23UserScriptInjectionTimeENS_25UserContentInjectedFramesE
__ZN7WebCore9PageGroup20removeAllUserContentEv
__ZN7WebCore9PageGroup21removeAllVisitedLinksEv
__ZN7WebCore9PageGroup24addUserStyleSheetToWorldEPNS_15DOMWrapperWorldERKN3WTF6StringERKNS_3URLERKNS3_6VectorIS4_Lm0ENS3_15CrashOnOverflowEEESE_NS_25UserContentInjectedFramesENS_14UserStyleLevelENS_22UserStyleInjectionTimeE
__ZN7WebCore9PageGroup25removeUserScriptFromWorldEPNS_15DOMWrapperWorldERKNS_3URLE
__ZN7WebCore9PageGroup26removeUserScriptsFromWorldEPNS_15DOMWrapperWorldE
__ZN7WebCore9PageGroup26setShouldTrackVisitedLinksEb
__ZN7WebCore9PageGroup29removeUserStyleSheetFromWorldEPNS_15DOMWrapperWorldERKNS_3URLE
__ZN7WebCore9PageGroup30closeIdleLocalStorageDatabasesEv
__ZN7WebCore9PageGroup30removeUserStyleSheetsFromWorldEPNS_15DOMWrapperWorldE
__ZN7WebCore9PageGroup9pageGroupERKN3WTF6StringE

__ZN7WebCore9plainTextEPKNS_5RangeENS_20TextIteratorBehaviorEb
__ZN7WebCore9toElementEN3JSC7JSValueE
__ZN7WebCore9unionRectERKN3WTF6VectorINS_9FloatRectELm0ENS0_15CrashOnOverflowEEE
__ZN7WebCore13ScriptGCEvent11getHeapSizeERNS_8HeapInfoE
__ZNK3JSC8Bindings10RootObject12globalObjectEv
__ZNK3WTF6String14createCFStringEv
__ZNK7WebCore10Credential11hasPasswordEv

__ZNK7WebCore10ScrollView18visibleContentRectENS_14ScrollableArea36VisibleContentRectIncludesScrollbarsE
__ZNK7WebCore10ScrollView23rootViewToTotalContentsERKNS_8IntPointE
__ZNK7WebCore10ScrollView30scrollOffsetRelativeToDocumentEv
__ZN7WebCore10ScrollView4hideEv
__ZN7WebCore10ScrollView4showEv
__ZNK7WebCore10StorageMap6lengthEv
__ZNK7WebCore10StorageMap7getItemERKN3WTF6StringE
__ZNK7WebCore10StorageMap8containsERKN3WTF6StringE

__ZNK7WebCore12TextIterator5rangeEv
__ZNK7WebCore13ContainerNode14childNodeCountEv
__ZNK7WebCore13ContainerNode9childNodeEj
__ZN7WebCore13GraphicsLayer7setSizeERKNS_9FloatSizeE
__ZNK7WebCore13GraphicsLayer18accumulatedOpacityEv
__ZNK7WebCore13GraphicsLayer18getDebugBorderInfoERNS_5ColorERf
__ZNK7WebCore13GraphicsLayer26backingStoreMemoryEstimateEv

__ZNK7WebCore14DocumentLoader10requestURLEv
__ZNK7WebCore14DocumentLoader11frameLoaderEv
__ZNK7WebCore14DocumentLoader11responseURLEv
__ZNK7WebCore14DocumentLoader11subresourceERKNS_3URLE
__ZNK7WebCore14DocumentLoader12mainResourceEv
__ZNK7WebCore14DocumentLoader13urlForHistoryEv
__ZNK7WebCore14DocumentLoader14unreachableURLEv

__ZNK7WebCore14DocumentLoader18mainResourceLoaderEv
__ZNK7WebCore14DocumentLoader19isLoadingInAPISenseEv
__ZNK7WebCore14DocumentLoader19originalRequestCopyEv
__ZNK7WebCore14DocumentLoader21archiveResourceForURLERKNS_4KURLE
__ZNK7WebCore14DocumentLoader28urlForHistoryReflectsFailureEv
__ZNK7WebCore14DocumentLoader3urlEv
__ZNK7WebCore14DocumentLoader9isLoadingEv

__ZNK7WebCore14FrameSelection36rootEditableElementOrDocumentElementEv
__ZNK7WebCore14FrameSelection6boundsEb
__ZNK7WebCore14InsertionPoint8isActiveEv
__ZNK7WebCore14InspectorValue12toJSONStringEv
__ZNK7WebCore14RenderListItem10markerTextEv
__ZNK7WebCore14ResourceBuffer4dataEv
__ZNK7WebCore14ResourceBuffer4sizeEv

__ZNK7WebCore14ScrollableArea22mouseExitedContentAreaEv
__ZNK7WebCore14ScrollableArea23mouseEnteredContentAreaEv
__ZNK7WebCore14ScrollableArea23mouseMovedInContentAreaEv
__ZNK7WebCore14SecurityOrigin10canDisplayERKNS_3URLE
__ZNK7WebCore14SecurityOrigin11toRawStringEv
__ZNK7WebCore14SecurityOrigin12isolatedCopyEv
__ZNK7WebCore14SecurityOrigin16canAccessStorageEPKS0_NS0_25ShouldAllowFromThirdPartyE

__ZNK7WebCore18PlatformPasteboard11changeCountEv
__ZNK7WebCore18RenderLayerBacking11contentsBoxEv
__ZNK7WebCore18RenderLayerBacking20compositingLayerTypeEv
__ZNK7WebCore19AnimationController11isSuspendedEv
__ZNK7WebCore19AnimationController24numberOfActiveAnimationsEPNS_8DocumentE
__ZNK7WebCore19AnimationController33allowsNewAnimationsWhileSuspendedEv
__ZNK7WebCore19InspectorController12getHighlightEPNS_9HighlightE
__ZNK7WebCore19InspectorController29buildObjectForHighlightedNodeEv
__ZNK7WebCore14InspectorValue12toJSONStringEv
__ZNK7WebCore19ResourceRequestBase10httpMethodEv
__ZNK7WebCore19ResourceRequestBase15httpHeaderFieldEPKc
__ZNK7WebCore19ResourceRequestBase20firstPartyForCookiesEv

__ZNK7WebCore19ResourceRequestBase8httpBodyEv
__ZNK7WebCore20CachedResourceLoader11isPreloadedERKN3WTF6StringE
__ZNK7WebCore20HTMLTableCellElement9cellAboveEv
__ZNK7WebCore20RenderEmbeddedObject21isReplacementObscuredEv
__ZNK7WebCore20ResourceResponseBase12isAttachmentEv
__ZNK7WebCore20ResourceResponseBase12lastModifiedEv
__ZNK7WebCore20ResourceResponseBase14httpStatusCodeEv

__ZNK7WebCore21NetworkStorageSession13cookieStorageEv
__ZNK7WebCore21RenderLayerCompositor11scrollLayerEv
__ZNK7WebCore21RenderLayerCompositor15rootRenderLayerEv
__ZNK7WebCore21UserContentURLPattern7matchesERKNS_3URLE
__ZNK7WebCore23ApplicationCacheStorage11maximumSizeEv
__ZNK7WebCore23AuthenticationChallenge20authenticationClientEv
__ZNK7WebCore23FrameLoaderStateMachine15firstLayoutDoneEv

__ZNK7WebCore27AuthenticationChallengeBase20previousFailureCountEv
__ZNK7WebCore27AuthenticationChallengeBase5errorEv
__ZNK7WebCore27AuthenticationChallengeBase6isNullEv
__ZNK7WebCore3URL10protocolIsEPKc
__ZNK7WebCore3URL11createCFURLEv
__ZNK7WebCore3URL11isLocalFileEv
__ZNK7WebCore3URL12baseAsStringEv
__ZNK7WebCore3URL14fileSystemPathEv
__ZNK7WebCore3URL17lastPathComponentEv
__ZNK7WebCore3URL18fragmentIdentifierEv
__ZNK7WebCore3URL21hasFragmentIdentifierEv
__ZNK7WebCore3URL4hostEv
__ZNK7WebCore3URL4passEv
__ZNK7WebCore3URL4pathEv
__ZNK7WebCore3URL4portEv
__ZNK7WebCore3URL4userEv
__ZNK7WebCore3URL5queryEv
__ZNK7WebCore3URL8protocolEv
__ZNK7WebCore3URLcvP5NSURLEv
__ZNK7WebCore4Font5widthERKNS_7TextRunEPN3WTF7HashSetIPKNS_14SimpleFontDataENS4_7PtrHashIS8_EENS4_10HashTraitsIS8_EEEEPNS_13GlyphOverflowE
__ZNK7WebCore4Font8drawTextEPNS_15GraphicsContextERKNS_7TextRunERKNS_10FloatPointEiiNS0_24CustomFontNotReadyActionE
__ZNK7WebCore4FonteqERKS0_
__ZNK7WebCore4KURL10protocolIsEPKc
__ZNK7WebCore4KURL11createCFURLEv
__ZNK7WebCore4KURL11isLocalFileEv
__ZNK7WebCore4KURL12baseAsStringEv
__ZNK7WebCore4KURL14fileSystemPathEv
__ZNK7WebCore4KURL17lastPathComponentEv
__ZNK7WebCore4KURL18fragmentIdentifierEv
__ZNK7WebCore4KURL21hasFragmentIdentifierEv
__ZNK7WebCore4KURL4hostEv
__ZNK7WebCore4KURL4passEv
__ZNK7WebCore4KURL4pathEv
__ZNK7WebCore4KURL4portEv
__ZNK7WebCore4KURL4userEv
__ZNK7WebCore4KURL5queryEv
__ZNK7WebCore4KURL8protocolEv
__ZNK7WebCore4KURLcvP5NSURLEv
__ZNK7WebCore4Node11textContentEb
__ZNK7WebCore4Node13ownerDocumentEv
__ZNK7WebCore4Node14isDescendantOfEPKS0_
__ZNK7WebCore4Node18getSubresourceURLsERN3WTF11ListHashSetINS_4KURLELm256ENS_8KURLHashEEE
__ZNK7WebCore4Node28deprecatedShadowAncestorNodeEv
#if ENABLE(STYLE_SCOPED)
__ZNK7WebCore4Node31numberOfScopedHTMLStyleChildrenEv
#endif
__ZNK7WebCore4Node9nodeIndexEv
__ZNK7WebCore4Node9textRectsERN3WTF6VectorINS_7IntRectELm0ENS1_15CrashOnOverflowEEE
__ZNK7WebCore4Page10pluginDataEv

_hasCaseInsensitiveSuffix
_stringIsCaseInsensitiveEqualToString
_suggestedFilenameWithMIMEType
_wkCALayerEnumerateRectsBeingDrawnWithBlock
_wkCFURLRequestAllowAllPostCaching
_wkCGContextGetShouldSmoothFonts
_wkCGContextIsPDFContext
_wkCGContextResetClip
_wkCGPathAddRoundedRect
_wkCGPatternCreateWithImageAndTransform
_wkCTRunGetInitialAdvance
_wkCopyCFLocalizationPreferredName

_wkCopyNSURLResponseStatusLine
_wkCopyRequestWithStorageSession
_wkCreateCTLineWithUniCharProvider
_wkCreateCTTypesetterWithUniCharProviderAndOptions
_wkCreateCustomCFReadStream
_wkCreatePrivateStorageSession
_wkDeleteAllHTTPCookies

__ZN7WebCore12EventHandler8keyEventEP7NSEvent
__ZN7WebCore12EventHandler9mouseDownEP7NSEvent
__ZN7WebCore13toDeviceSpaceERKNS_9FloatRectEP8NSWindow
__ZN7WebCore13getRawCookiesERKNS_21NetworkStorageSessionERKNS_4KURLES5_RN3WTF6VectorINS_6CookieELm0ENS6_15CrashOnOverflowEEE
__ZN7WebCore15GraphicsContextC1EP9CGContext
__ZN7WebCore15GraphicsContext15drawNativeImageEP7CGImageRKNS_9FloatSizeENS_10ColorSpaceERKNS_9FloatRectES9_NS_17CompositeOperatorENS_9BlendModeENS_16ImageOrientationE
__ZN7WebCore15GraphicsContextC1EP9CGContext
__ZN7WebCore15ResourceRequest39updateFromDelegatePreservingOldHTTPBodyERKS0_
__ZN7WebCore16FontPlatformDataC1EP6NSFontfbbbNS_15FontOrientationENS_16FontWidthVariantE
__ZN7WebCore16FontPlatformDataC2EP6NSFontfbbbNS_15FontOrientationENS_16FontWidthVariantE

__ZN7WebCore19applicationIsSafariEv
__ZN7WebCore20PlatformEventFactory24createPlatformMouseEventEP7NSEventP6NSView
__ZN7WebCore20PlatformEventFactory27createPlatformKeyboardEventEP7NSEvent
__ZN7WebCore20builtInPDFPluginNameEv
__ZN7WebCore20applicationIsHRBlockEv
__ZN7WebCore20builtInPDFPluginNameEv
__ZN7WebCore21DeviceOrientationData6createEbdbdbdbb
__ZN7WebCore21applicationIsApertureEv
__ZN7WebCore21applicationIsVersionsEv

__ZN7WebCore32applicationIsAOLInstantMessengerEv
__ZN7WebCore32contextMenuItemTagInspectElementEv
__ZN7WebCore32contextMenuItemTagSmartCopyPasteEv
__ZN7WebCore33postScriptDocumentTypeDescriptionEv
__ZN7WebCore33contextMenuItemTagTextReplacementEv
__ZN7WebCore33postScriptDocumentTypeDescriptionEv
__ZN7WebCore33setDefaultThreadViolationBehaviorENS_23ThreadViolationBehaviorENS_20ThreadViolationRoundE
__ZN7WebCore34contextMenuItemTagDefaultDirectionEv
__ZN7WebCore35contextMenuItemTagShowSpellingPanelEb

__ZN7WebCore6Widget17setPlatformWidgetEP6NSView
__ZN7WebCore6WidgetC2EP6NSView
__ZN7WebCore7nsColorERKNS_5ColorE
__ZN7WebCore8IntPointC1ERK8_NSPoint
__ZN7WebCore8IntPointC1ERK7CGPoint
__ZN7WebCore8IntPointC1ERK8_NSPoint
__ZN7WebCore9FloatRectC1ERK7_NSRect
__ZNK7WebCore10FloatPointcv8_NSPointEv
__ZNK7WebCore14ScrollableArea18visibleContentRectENS0_36VisibleContentRectIncludesScrollbarsE

__ZNK7WebCore8IntPointcv8_NSPointEv
__ZNK7WebCore9FloatRectcv7_NSRectEv
_stringEncodingForResource
_wkAVAssetResolvedURL
_wkAccessibilityHandleFocusChanged
_wkAdvanceDefaultButtonPulseAnimation
_wkCopyAXTextMarkerRangeEnd
_wkCopyAXTextMarkerRangeStart
_wkCopyDefaultSearchProviderDisplayName
_wkCreateAXTextMarker
_wkCreateAXTextMarkerRange
_wkCreateAXUIElementRef

_wkCreateMediaUIControl
_wkCreateURLNPasteboardFlavorTypeName
_wkCreateURLPasteboardFlavorTypeName
_wkCreateVMPressureDispatchOnMainQueue
_wkCursor
_wkDrawBezeledTextArea
_wkDrawBezeledTextFieldCell
_wkDrawCapsLockIndicator

_wkDrawMediaSliderTrack
_wkDrawMediaUIPart
_wkDrawTextFieldCellFocusRing
_wkExecutableWasLinkedOnOrBeforeSnowLeopard
_wkGetAXTextMarkerRangeTypeID
_wkGetAXTextMarkerTypeID
_wkGetBytesFromAXTextMarker

_wkQTMovieSelectPreferredAlternates
_wkQTMovieSetShowClosedCaptions
_wkQTMovieViewSetDrawSynchronously
_wkRecommendedScrollerStyle
_wkSetCGFontRenderingMode
_wkSetCrashReportApplicationSpecificInformation
_wkSetDragImage
_wkSetMetadataURL
_wkSignedPublicKeyAndChallengeString

__ZN7WebCore11ImageSource33maximumImageSizeBeforeSubsamplingEv
__ZN7WebCore11ImageSource36setMaximumImageSizeBeforeSubsamplingEj
__ZN7WebCore11MathMLNames4initEv
__ZN7WebCore11MemoryCache15addImageToCacheEP7CGImageRKNS_4KURLE
__ZN7WebCore11MemoryCache18pruneDeadResourcesEv
__ZN7WebCore11MemoryCache18pruneLiveResourcesEb
__ZN7WebCore11MemoryCache20removeImageFromCacheERKNS_4KURLE
__ZN7WebCore11isEndOfLineERKNS_15VisiblePositionE
__ZN7WebCore12EventHandler10mouseMovedEP8WebEvent
__ZN7WebCore12EventHandler10wheelEventEP8WebEvent

__ZN7WebCore31NonSharedCharacterBreakIteratorC1EPKti
__ZN7WebCore31NonSharedCharacterBreakIteratorD1Ev
__ZN7WebCore31applicationIsDaijisenDictionaryEv
__ZN7WebCore32enableKURLSchemeCanonicalizationEb
__ZN7WebCore33applicationIsTheEconomistOnIPhoneEv
__ZN7WebCore41initializeHTTPConnectionSettingsOnStartupEv
__ZN7WebCore4FontC1ERKNS_16FontPlatformDataEN3WTF10PassRefPtrINS_12FontSelectorEEE

__ZN7WebCore5Frame20setViewportArgumentsERKNS_17ViewportArgumentsE
__ZN7WebCore5Frame21deepestNodeAtLocationEP7CGPoint
__ZN7WebCore5Frame21viewportOffsetChangedEv
__ZN7WebCore5Frame26initWithSimpleHTMLDocumentERKN3WTF6StringERKNS_4KURLE
__ZN7WebCore5Frame27nodeRespondingToClickEventsEP7CGPoint
__ZN7WebCore5Frame30setSingleLineSelectionBehaviorEb
__ZN7WebCore5Frame32dispatchPageHideEventBeforePauseEv

__ZN7WebCore9FrameView30graphicsLayerForPlatformWidgetEP7WAKView
__ZN7WebCore9FrameView32setCustomFixedPositionLayoutRectERKNS_7IntRectE
__ZN7WebCore9FrameView35setUseCustomFixedPositionLayoutRectEb
__ZN7WebCore9PageGroup17removeVisitedLinkERKNS_4KURLE
__ZN7WebCore9PageGroup20addUserScriptToWorldEPNS_15DOMWrapperWorldERKN3WTF6StringERKNS_4KURLERKNS3_6VectorIS4_Lm0ENS3_15CrashOnOverflowEEESE_NS_23UserScriptInjectionTimeENS_25UserContentInjectedFramesE
__ZN7WebCore9PageGroup24addUserStyleSheetToWorldEPNS_15DOMWrapperWorldERKN3WTF6StringERKNS_4KURLERKNS3_6VectorIS4_Lm0ENS3_15CrashOnOverflowEEESE_NS_25UserContentInjectedFramesENS_14UserStyleLevelENS_22UserStyleInjectionTimeE
__ZN7WebCore9TileCache14drainLayerPoolEv
__ZN7WebCore9TileCache20setLayerPoolCapacityEj
__ZNK7WebCore10FloatPointcv7CGPointEv

__ZN7WebCore20LogNotYetImplementedE
__ZN7WebCore28notImplementedLoggingChannelEv
__ZN7WebCore36initializeLoggingChannelsIfNecessaryEv
#endif

#if !ASSERT_DISABLED
__ZN7WebCore27NoExceptionAssertionCheckerC1EPKci
__ZN7WebCore27NoExceptionAssertionCheckerD1Ev
#endif

#if !defined(NSGEOMETRY_TYPES_SAME_AS_CGGEOMETRY_TYPES) && !PLATFORM(IOS)
__ZN7WebCore7IntSizeC1ERK7_NSSize
__ZNK7WebCore7IntSizecv7_NSSizeEv
#endif

_wkCALayerEnumerateRectsBeingDrawnWithBlock
_wkCFURLRequestAllowAllPostCaching
_wkCGPathAddRoundedRect
_wkCreateCTTypesetterWithUniCharProviderAndOptions

#if !PLATFORM(IOS_SIMULATOR)
_wkIOSurfaceContextCreate
_wkIOSurfaceContextCreateImage
#endif

#if !PLATFORM(IOS)
_wkAVAssetResolvedURL
_wkCopyDefaultSearchProviderDisplayName
_wkSetCrashReportApplicationSpecificInformation
_wkCreateVMPressureDispatchOnMainQueue
_wkCursor
_wkExecutableWasLinkedOnOrBeforeSnowLeopard
_wkRecommendedScrollerStyle
#endif

#if !PLATFORM(IOS) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
_wkCreateMemoryStatusPressureCriticalDispatchOnMainQueue
#endif

#if USE(CONTENT_FILTERING)
_wkFilterAddData
_wkFilterCreateInstance
_wkFilterDataComplete
_wkFilterIsBuffering
_wkFilterIsManagedSession
_wkFilterWasBlocked
#endif

#if !PLATFORM(IOS) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1080
__ZN7WebCore24TextAlternativeWithRangeC1EP18NSTextAlternatives8_NSRange
__ZN7WebCore27AlternativeTextUIController15addAlternativesERKN3WTF9RetainPtrI18NSTextAlternativesEE
__ZN7WebCore27AlternativeTextUIController16showAlternativesEP6NSViewRKNS_9FloatRectEyU13block_pointerFvP8NSStringE
__ZN7WebCore27AlternativeTextUIController18removeAlternativesEy
__ZN7WebCore27AlternativeTextUIController22alternativesForContextEy
__ZN7WebCore27AlternativeTextUIController5clearEv
__ZN7WebCore32collectDictationTextAlternativesEP18NSAttributedStringRN3WTF6VectorINS_24TextAlternativeWithRangeELm0ENS2_15CrashOnOverflowEEE
_wkCGContextDrawsWithCorrectShadowOffsets
_wkExecutableWasLinkedOnOrBeforeLion
_wkNSElasticDeltaForReboundDelta

_wkNSReboundDeltaForElasticDelta
#endif

#if !PLATFORM(IOS) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
_wkCreateMemoryStatusPressureCriticalDispatchOnMainQueue
#endif

#if PLATFORM(IOS) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
_wkCTFontTransformGlyphs
__ZN7WebCore27AlternativeTextUIController22alternativesForContextEy
__ZN7WebCore27AlternativeTextUIController5clearEv
__ZN7WebCore27AlternativeTextUIController18removeAlternativesEy
__ZN7WebCore27AlternativeTextUIController16showAlternativesEP6NSViewRKNS_9FloatRectEyU13block_pointerFvP8NSStringE
__ZN7WebCore24TextAlternativeWithRangeC1EP18NSTextAlternatives8_NSRange
__ZN7WebCore32collectDictationTextAlternativesEP18NSAttributedStringRN3WTF6VectorINS_24TextAlternativeWithRangeELm0ENS2_15CrashOnOverflowEEE
#endif

#if ENABLE(3D_RENDERING)
_WebCoreHas3DRendering
#endif

#if ENABLE(CSS_FILTERS)
__ZN7WebCore16FilterOperationsaSERKS0_
#endif

#if USE(APPKIT)
__ZN7WebCore6Editor13lowercaseWordEv
__ZN7WebCore6Editor13uppercaseWordEv

__ZN7WebCore8Settings22setAVFoundationEnabledEb
#endif

#if ENABLE(BLOB)
__ZN7WebCore12blobRegistryEv
__ZN7WebCore14LoaderStrategy18createBlobRegistryEv
__ZN7WebCore7RawDataC1Ev
__ZN7WebCore8BlobData10appendDataEN3WTF10PassRefPtrINS_7RawDataEEExx
__ZN7WebCore8BlobData10appendFileERKN3WTF6StringExxd
__ZN7WebCore8BlobData6createEv
__ZN7WebCore12BlobDataItem11toEndOfFileE
__ZN7WebCore12BlobRegistryD2Ev
__ZTVN7WebCore12BlobRegistryE
__ZTVN7WebCore16BlobRegistryImplE
#endif

#if ENABLE(CACHE_PARTITIONING)
__ZN7WebCore15ResourceRequest13partitionNameERKN3WTF6StringE
_wkCachePartitionKey
#endif

#if USE(CFNETWORK)

_wkSetRequestStorageSession
#endif

#if USE(CONTENT_FILTERING)
_wkFilterAddData
_wkFilterCreateInstance
_wkFilterDataComplete
_wkFilterIsBuffering
_wkFilterIsManagedSession
_wkFilterWasBlocked
__ZN7WebCore8BlobData6createEv
__ZN7WebCore12BlobDataItem11toEndOfFileE
__ZN7WebCore12BlobRegistryD2Ev
__ZTVN7WebCore12BlobRegistryE
__ZTVN7WebCore16BlobRegistryImplE
#endif

#if ENABLE(CONTEXT_MENUS)

__ZNK7WebCore15ContextMenuItem6actionEv
__ZNK7WebCore15ContextMenuItem7checkedEv
__ZNK7WebCore15ContextMenuItem7enabledEv
#endif

#if ENABLE(CSS_FILTERS)
__ZN7WebCore16FilterOperationsaSERKS0_
#endif

#if ENABLE(CSS3_CONDITIONAL_RULES)
.objc_class_name_DOMCSSSupportsRule
__ZN7WebCore12DOMWindowCSS6createEv
__ZN7WebCore4toJSEPN3JSC9ExecStateEPNS_17JSDOMGlobalObjectEPNS_12DOMWindowCSSE
#endif

#if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
__ZNK7WebCore8Document16annotatedRegionsEv

__ZN7WebCore8DragDataC1ERKN3WTF6StringERKNS_8IntPointES7_NS_13DragOperationENS_20DragApplicationFlagsE
#endif

#if ENABLE(ENCRYPTED_MEDIA_V2)
__ZN7WebCore3CDM18registerCDMFactoryEPFN3WTF10PassOwnPtrINS_19CDMPrivateInterfaceEEEPS0_EPFbRKNS1_6StringEEPFbSA_SA_E
#endif

#if ENABLE(FULLSCREEN_API)
__ZN7WebCore8Document22webkitCancelFullScreenEv
__ZN7WebCore8Document33webkitDidExitFullScreenForElementEPNS_7ElementE

__ZNK7WebCore12IconDatabase12databasePathEv
__ZNK7WebCore12IconDatabase24shouldStopThreadActivityEv
__ZNK7WebCore12IconDatabase9isEnabledEv
#endif

#if ENABLE(INPUT_TYPE_COLOR)
__ZN7WebCore5ColorC1EP7CGColor

__ZNK7WebCore9FloatQuad13containsPointERKNS_10FloatPointE
#endif

#if ENABLE(IOS_TEXT_AUTOSIZING)
__ZN7WebCore12RenderObject19resetTextAutosizingEv
__ZN7WebCore5Frame22setTextAutosizingWidthEf
#endif

#if ENABLE(MEDIA_STREAM)
__ZN7WebCore16UserMediaRequest22userMediaAccessGrantedEv
__ZN7WebCore16UserMediaRequest21userMediaAccessDeniedEv
__ZN7WebCore18provideUserMediaToEPNS_4PageEPNS_15UserMediaClientE
__ZNK7WebCore16UserMediaRequest14securityOriginEv
__ZN7WebCore21MockMediaStreamCenter29registerMockMediaStreamCenterEv
#endif

#if ENABLE(NETSCAPE_PLUGIN_API)
__NPN_Construct
__NPN_CreateObject

__ZN7WebCore8createCFERKNS_15ProtectionSpaceE
#endif

#if ENABLE(PUBLIC_SUFFIX_LIST)
__ZN7WebCore14isPublicSuffixERKN3WTF6StringE
__ZN7WebCore28topPrivatelyControlledDomainERKN3WTF6StringE
_wkIsPublicSuffix
#endif

#if USE(QUICK_LOOK)
__ZN7WebCore27qlPreviewConverterUTIForURLEP5NSURL
__ZN7WebCore30removeQLPreviewConverterForURLEP5NSURL

__ZN7WebCore9FrameView25serviceScriptedAnimationsEd
#endif

#if ENABLE(RUBBER_BANDING)
__ZNK7WebCore9FrameView31setWantsLayerForTopOverHangAreaEb
__ZNK7WebCore9FrameView34setWantsLayerForBottomOverHangAreaEb
#endif

#if ENABLE(SHADOW_DOM)
__ZN7WebCore4toJSEPN3JSC9ExecStateEPNS_17JSDOMGlobalObjectEPNS_10ShadowRootE
#endif

#if ENABLE(SPEECH_SYNTHESIS)
__ZN7WebCore15SpeechSynthesis22setPlatformSynthesizerEN3WTF10PassOwnPtrINS_25PlatformSpeechSynthesizerEEE
__ZN7WebCore24DOMWindowSpeechSynthesis15speechSynthesisEPNS_9DOMWindowE
__ZN7WebCore25PlatformSpeechSynthesizerC2EPNS_31PlatformSpeechSynthesizerClientE
__ZTVN7WebCore25PlatformSpeechSynthesizerE
__ZN7WebCore25PlatformSpeechSynthesizerD2Ev
__ZN7WebCore28PlatformSpeechSynthesisVoice6createERKN3WTF6StringES4_S4_bb
#endif

#if ENABLE(SVG)
__ZN7WebCore8Document13svgExtensionsEv
__ZN7WebCore8Document19accessSVGExtensionsEv
#endif

#if ENABLE(STYLE_SCOPED)
__ZNK7WebCore4Node31numberOfScopedHTMLStyleChildrenEv
__ZN7WebCore5Frame22setTextAutosizingWidthEf
#endif

#if ENABLE(THREADED_SCROLLING)


#if ENABLE(VIEW_MODE_CSS_MEDIA)
__ZN7WebCore4Page11setViewModeENS0_8ViewModeE
#endif

#if ENABLE(WORKERS)
__ZN7WebCore12WorkerThread17workerThreadCountEv
#endif

#if ENABLE(ENCRYPTED_MEDIA_V2)
__ZN7WebCore3CDM18registerCDMFactoryEPFN3WTF10PassOwnPtrINS_19CDMPrivateInterfaceEEEPS0_EPFbRKNS1_6StringEEPFbSA_SA_E
#endif

#if ENABLE(VIDEO_TRACK)
__ZN7WebCore9PageGroup18captionPreferencesEv
#endif

#if ENABLE(SPEECH_SYNTHESIS)
__ZN7WebCore15SpeechSynthesis22setPlatformSynthesizerEN3WTF10PassOwnPtrINS_25PlatformSpeechSynthesizerEEE
__ZN7WebCore24DOMWindowSpeechSynthesis15speechSynthesisEPNS_9DOMWindowE
__ZN7WebCore25PlatformSpeechSynthesizerC2EPNS_31PlatformSpeechSynthesizerClientE
__ZTVN7WebCore25PlatformSpeechSynthesizerE
__ZN7WebCore25PlatformSpeechSynthesizerD2Ev
__ZN7WebCore28PlatformSpeechSynthesisVoice6createERKN3WTF6StringES4_S4_bb
#endif

#if ENABLE(RUBBER_BANDING)
__ZNK7WebCore9FrameView31setWantsLayerForTopOverHangAreaEb
__ZNK7WebCore9FrameView34setWantsLayerForBottomOverHangAreaEb
#endif

#if ENABLE(PUBLIC_SUFFIX_LIST)
__ZN7WebCore14isPublicSuffixERKN3WTF6StringE
__ZN7WebCore28topPrivatelyControlledDomainERKN3WTF6StringE
_wkIsPublicSuffix
#endif

#if ENABLE(CACHE_PARTITIONING)
__ZN7WebCore15ResourceRequest13partitionNameERKN3WTF6StringE
_wkCachePartitionKey
#endif

#if ENABLE(MEDIA_STREAM)
__ZN7WebCore16UserMediaRequest22userMediaAccessGrantedEv
__ZN7WebCore16UserMediaRequest21userMediaAccessDeniedEv
__ZN7WebCore18provideUserMediaToEPNS_4PageEPNS_15UserMediaClientE
__ZNK7WebCore16UserMediaRequest14securityOriginEv
__ZN7WebCore21MockMediaStreamCenter29registerMockMediaStreamCenterEv
#endif



    </ClCompile>
    <ClCompile Include="..\platform\HistogramSupport.cpp" />
    <ClCompile Include="..\platform\KillRingNone.cpp" />
    <ClCompile Include="..\platform\URL.cpp" />
    <ClCompile Include="..\platform\Language.cpp" />
    <ClCompile Include="..\platform\Length.cpp" />
    <ClCompile Include="..\platform\LengthBox.cpp" />

    <ClCompile Include="..\platform\win\WindowMessageBroadcaster.cpp" />
    <ClCompile Include="..\platform\cf\CFURLExtras.cpp" />
    <ClCompile Include="..\platform\cf\FileSystemCF.cpp" />
    <ClCompile Include="..\platform\cf\URLCF.cpp" />
    <ClCompile Include="..\platform\cf\SharedBufferCF.cpp" />
    <ClCompile Include="..\platform\cf\win\CertificateCFWin.cpp" />
    <ClCompile Include="..\platform\graphics\BitmapImage.cpp" />

    <ClInclude Include="..\platform\HistogramSupport.h" />
    <ClInclude Include="..\platform\HostWindow.h" />
    <ClInclude Include="..\platform\KillRing.h" />
    <ClInclude Include="..\platform\URL.h" />
    <ClInclude Include="..\platform\URLHash.h" />
    <ClInclude Include="..\platform\Language.h" />
    <ClInclude Include="..\platform\LayoutUnit.h" />
    <ClInclude Include="..\platform\Length.h" />



    <ClCompile Include="..\platform\KillRingNone.cpp">
      <Filter>platform</Filter>
    </ClCompile>
    <ClCompile Include="..\platform\URL.cpp">
      <Filter>platform</Filter>
    </ClCompile>
    <ClCompile Include="..\platform\Language.cpp">

    <ClCompile Include="..\platform\cf\FileSystemCF.cpp">
      <Filter>platform\cf</Filter>
    </ClCompile>
    <ClCompile Include="..\platform\cf\URLCF.cpp">
      <Filter>platform\cf</Filter>
    </ClCompile>
    <ClCompile Include="..\platform\cf\win\CertificateCFWin.cpp">

    <ClInclude Include="..\platform\KillRing.h">
      <Filter>platform</Filter>
    </ClInclude>
    <ClInclude Include="..\platform\URL.h">
      <Filter>platform</Filter>
    </ClInclude>
    <ClInclude Include="..\platform\URLHash.h">
      <Filter>platform</Filter>
    </ClInclude>
    <ClInclude Include="..\platform\Language.h">



		1A927FD21416A15B003A83C8 /* npapi.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A927FCF1416A15B003A83C8 /* npapi.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1A927FD31416A15B003A83C8 /* npruntime.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A927FD01416A15B003A83C8 /* npruntime.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1A927FD41416A15B003A83C8 /* nptypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A927FD11416A15B003A83C8 /* nptypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1A98956B0AA78F80005EF5EF /* URLCF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A98956A0AA78F80005EF5EF /* URLCF.cpp */; };
		1AA21250163F0DA80000E63F /* AtomicStringCF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1AA2124F163F0DA80000E63F /* AtomicStringCF.cpp */; };
		1AA7160A149BC4DB0016EC19 /* TileController.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1AA71608149BC4DA0016EC19 /* TileController.mm */; };
		1AA7160B149BC4DB0016EC19 /* TileController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1AA71609149BC4DB0016EC19 /* TileController.h */; };

		657EDA081385CB97004E0645 /* MemoryPressureHandler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 657EDA061385CB97004E0645 /* MemoryPressureHandler.cpp */; };
		657EDA0B1385CBD8004E0645 /* MemoryPressureHandlerMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 657EDA0A1385CBD8004E0645 /* MemoryPressureHandlerMac.mm */; };
		658436860AE01B7400E53753 /* FrameLoadRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 658436850AE01B7400E53753 /* FrameLoadRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
		6593923709AE4346002C531F /* URL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6593923509AE4346002C531F /* URL.cpp */; };
		6593923809AE4346002C531F /* URL.h in Headers */ = {isa = PBXBuildFile; fileRef = 6593923609AE4346002C531F /* URL.h */; settings = {ATTRIBUTES = (Private, ); }; };
		6593923A09AE435C002C531F /* URLMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 6593923909AE435C002C531F /* URLMac.mm */; };
		6596F2B30B8731DF001326BD /* DOMHTMLInputElementInternal.h in Copy Generated Headers */ = {isa = PBXBuildFile; fileRef = 85E711640AC5D5350053270F /* DOMHTMLInputElementInternal.h */; };
		6596F2C10B87325C001326BD /* DOMHTMLTextAreaElementInternal.h in Copy Generated Headers */ = {isa = PBXBuildFile; fileRef = 85E7117F0AC5D5350053270F /* DOMHTMLTextAreaElementInternal.h */; };
		659A7D130B6DB4D9001155B3 /* SubstituteData.h in Headers */ = {isa = PBXBuildFile; fileRef = 659A7D120B6DB4D9001155B3 /* SubstituteData.h */; settings = {ATTRIBUTES = (Private, ); }; };

		BCBB8AB913F1AFB000734DF0 /* PODInterval.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBB8AB513F1AFB000734DF0 /* PODInterval.h */; settings = {ATTRIBUTES = (Private, ); }; };
		BCBB8ABA13F1AFB000734DF0 /* PODIntervalTree.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBB8AB613F1AFB000734DF0 /* PODIntervalTree.h */; settings = {ATTRIBUTES = (Private, ); }; };
		BCBB8ABB13F1AFB000734DF0 /* PODRedBlackTree.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBB8AB713F1AFB000734DF0 /* PODRedBlackTree.h */; settings = {ATTRIBUTES = (Private, ); }; };
		BCBD21AB0E417AD400A070F2 /* URLHash.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBD21AA0E417AD400A070F2 /* URLHash.h */; settings = {ATTRIBUTES = (Private, ); }; };
		BCBFB53C0DCD29CF0019B3E5 /* JSDOMWindowShell.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCBFB53A0DCD29CF0019B3E5 /* JSDOMWindowShell.cpp */; };
		BCBFB53D0DCD29CF0019B3E5 /* JSDOMWindowShell.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBFB53B0DCD29CF0019B3E5 /* JSDOMWindowShell.h */; settings = {ATTRIBUTES = (Private, ); }; };
		BCC0657D0F3CE1B700CD2D87 /* ClientRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCC065770F3CE1B700CD2D87 /* ClientRect.cpp */; };

		1A927FCF1416A15B003A83C8 /* npapi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = npapi.h; sourceTree = "<group>"; };
		1A927FD01416A15B003A83C8 /* npruntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = npruntime.h; sourceTree = "<group>"; };
		1A927FD11416A15B003A83C8 /* nptypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nptypes.h; sourceTree = "<group>"; };
		1A98956A0AA78F80005EF5EF /* URLCF.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = URLCF.cpp; sourceTree = "<group>"; };
		1AA2124F163F0DA80000E63F /* AtomicStringCF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AtomicStringCF.cpp; sourceTree = "<group>"; };
		1AA71608149BC4DA0016EC19 /* TileController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileController.mm; path = ca/mac/TileController.mm; sourceTree = "<group>"; };
		1AA71609149BC4DB0016EC19 /* TileController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileController.h; path = ca/mac/TileController.h; sourceTree = "<group>"; };

		657EDA071385CB97004E0645 /* MemoryPressureHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryPressureHandler.h; sourceTree = "<group>"; };
		657EDA0A1385CBD8004E0645 /* MemoryPressureHandlerMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MemoryPressureHandlerMac.mm; sourceTree = "<group>"; };
		658436850AE01B7400E53753 /* FrameLoadRequest.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = FrameLoadRequest.h; sourceTree = "<group>"; };
		6593923509AE4346002C531F /* URL.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = URL.cpp; sourceTree = "<group>"; };
		6593923609AE4346002C531F /* URL.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = URL.h; sourceTree = "<group>"; };
		6593923909AE435C002C531F /* URLMac.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; lineEnding = 0; path = URLMac.mm; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
		659A7D120B6DB4D9001155B3 /* SubstituteData.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SubstituteData.h; sourceTree = "<group>"; };
		659DDC8009E198BA001BF3C6 /* JSDocument.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSDocument.cpp; sourceTree = "<group>"; };
		659DDC8109E198BA001BF3C6 /* JSDocument.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSDocument.h; sourceTree = "<group>"; };

		BCBB8AB513F1AFB000734DF0 /* PODInterval.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PODInterval.h; sourceTree = "<group>"; };
		BCBB8AB613F1AFB000734DF0 /* PODIntervalTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PODIntervalTree.h; sourceTree = "<group>"; };
		BCBB8AB713F1AFB000734DF0 /* PODRedBlackTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PODRedBlackTree.h; sourceTree = "<group>"; };
		BCBD21AA0E417AD400A070F2 /* URLHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = URLHash.h; sourceTree = "<group>"; };
		BCBFB53A0DCD29CF0019B3E5 /* JSDOMWindowShell.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMWindowShell.cpp; sourceTree = "<group>"; };
		BCBFB53B0DCD29CF0019B3E5 /* JSDOMWindowShell.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMWindowShell.h; sourceTree = "<group>"; };
		BCC065770F3CE1B700CD2D87 /* ClientRect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ClientRect.cpp; sourceTree = "<group>"; };

				E1A8E56417552B2A007488E7 /* CFURLExtras.cpp */,
				E1A8E56517552B2A007488E7 /* CFURLExtras.h */,
				5160306B0CC4362300C8AC25 /* FileSystemCF.cpp */,
				1A98956A0AA78F80005EF5EF /* URLCF.cpp */,
				29A309AB1561C99B00BBD8E5 /* RunLoopCF.cpp */,
				512DD8E20D91E2B4000F89EE /* SharedBufferCF.cpp */,
			);

				C5392D341326AD0100043D35 /* HTMLConverter.mm */,
				935C476E09AC4D7300A6AAB4 /* KeyEventMac.mm */,
				521D46F511AEC98100514613 /* KillRingMac.mm */,
				6593923909AE435C002C531F /* URLMac.mm */,
				9352084409BD43B900F2038D /* Language.mm */,
				06E81ED60AB5D5E900C87837 /* LocalCurrentGraphicsContext.h */,
				06E81EEB0AB5DA9700C87837 /* LocalCurrentGraphicsContext.mm */,

				BC3BC29B0E91AB0F00835588 /* HostWindow.h */,
				521D46F711AEC9B100514613 /* KillRing.h */,
				4306E4E514955543007F17AC /* KillRingNone.cpp */,
				6593923509AE4346002C531F /* URL.cpp */,
				6593923609AE4346002C531F /* URL.h */,
				BCBD21AA0E417AD400A070F2 /* URLHash.h */,
				E18772F0126E2629003DD586 /* Language.cpp */,
				85EC9AF90A71A2C600EEEAED /* Language.h */,
				141DC0471648348F00371E5A /* LayoutUnit.h */,

				316FE11A0E6E1DA700BF6088 /* KeyframeAnimation.h in Headers */,
				BC5EBA110E823E4700B25965 /* KeyframeList.h in Headers */,
				521D46F811AEC9B100514613 /* KillRing.h in Headers */,
				6593923809AE4346002C531F /* URL.h in Headers */,
				BCBD21AB0E417AD400A070F2 /* URLHash.h in Headers */,
				450CEBF115073BBE002BB149 /* LabelableElement.h in Headers */,
				A456FA2711AD4A830020B420 /* LabelsNodeList.h in Headers */,
				85EC9AFB0A71A2C600EEEAED /* Language.h in Headers */,

				BC5EBA100E823E4700B25965 /* KeyframeList.cpp in Sources */,
				521D46F611AEC98100514613 /* KillRingMac.mm in Sources */,
				4306E4E614955543007F17AC /* KillRingNone.cpp in Sources */,
				6593923709AE4346002C531F /* URL.cpp in Sources */,
				1A98956B0AA78F80005EF5EF /* URLCF.cpp in Sources */,
				6593923A09AE435C002C531F /* URLMac.mm in Sources */,
				450CEBF015073BBE002BB149 /* LabelableElement.cpp in Sources */,
				A456FA2611AD4A830020B420 /* LabelsNodeList.cpp in Sources */,
				E18772F1126E2629003DD586 /* Language.cpp in Sources */,



    return m_areaElement.get();
}

URL AccessibilityImageMapLink::url() const
{
    if (!m_areaElement.get())
        return URL();
    
    return m_areaElement->href();
}

Lines 56-62 public: a/Source/WebCore/accessibility/AccessibilityImageMapLink.h_sec1
- a/Source/WebCore/accessibility/AccessibilityImageMapLink.h -1 / +1 lines
56		56
57	virtual Element* anchorElement() const;	57	virtual Element* anchorElement() const;
58	virtual Element* actionElement() const;	58	virtual Element* actionElement() const;
59	virtual KURL url() const;	59	virtual URL url() const;
60	virtual bool isLink() const { return true; }	60	virtual bool isLink() const { return true; }
61	virtual bool isLinked() const { return true; }	61	virtual bool isLinked() const { return true; }
62	virtual String title() const;	62	virtual String title() const;

Lines 642-648 public: a/Source/WebCore/accessibility/AccessibilityObject.h_sec1
- a/Source/WebCore/accessibility/AccessibilityObject.h -1 / +1 lines
642	unsigned selectionStart() const { return selectedTextRange().start; }	642	unsigned selectionStart() const { return selectedTextRange().start; }
643	unsigned selectionEnd() const { return selectedTextRange().length; }	643	unsigned selectionEnd() const { return selectedTextRange().length; }
644		644
645	virtual KURL url() const { return KURL(); }	645	virtual URL url() const { return URL(); }
646	virtual VisibleSelection selection() const { return VisibleSelection(); }	646	virtual VisibleSelection selection() const { return VisibleSelection(); }
647	virtual String selectedText() const { return String(); }	647	virtual String selectedText() const { return String(); }
648	virtual const AtomicString& accessKey() const { return nullAtom; }	648	virtual const AtomicString& accessKey() const { return nullAtom; }



        return 0;
    HTMLAnchorElement* anchor = toHTMLAnchorElement(element);
    
    URL linkURL = anchor->href();
    String fragmentIdentifier = linkURL.fragmentIdentifier();
    if (fragmentIdentifier.isEmpty())
        return 0;
    
    // check if URL is the same as current URL
    URL documentURL = m_renderer->document().url();
    if (!equalIgnoringFragmentIdentifier(documentURL, linkURL))
        return 0;
    

        Position(node, range.start + range.length, Position::PositionIsOffsetInAnchor), DOWNSTREAM));
}

URL AccessibilityRenderObject::url() const
{
    if (isAnchor() && isHTMLAnchorElement(m_renderer->node())) {
        if (HTMLAnchorElement* anchor = toHTMLAnchorElement(anchorElement()))

    if (isInputImage())
        return toHTMLInputElement(m_renderer->node())->src();
    
    return URL();
}

bool AccessibilityRenderObject::isUnvisited() const

Lines 139-145 public: a/Source/WebCore/accessibility/AccessibilityRenderObject.h_sec1
- a/Source/WebCore/accessibility/AccessibilityRenderObject.h -1 / +1 lines
139	Document* topDocument() const;	139	Document* topDocument() const;
140	HTMLLabelElement* labelElementContainer() const;	140	HTMLLabelElement* labelElementContainer() const;
141		141
142	virtual KURL url() const;	142	virtual URL url() const;
143	virtual PlainTextRange selectedTextRange() const;	143	virtual PlainTextRange selectedTextRange() const;
144	virtual VisibleSelection selection() const;	144	virtual VisibleSelection selection() const;
145	virtual String stringValue() const;	145	virtual String stringValue() const;

Lines 979-985 static void appendStringToResult(NSMutableString result, NSString string) a/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm_sec1
- a/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm -1 / +1 lines
979	if (![self _prepareAccessibilityCall])	979	if (![self _prepareAccessibilityCall])
980	return nil;	980	return nil;
981		981
982	KURL url = m_object->url();	982	URL url = m_object->url();
983	if (url.isNull())	983	if (url.isNull())
984	return nil;	984	return nil;
985	return (NSURL*)url;	985	return (NSURL*)url;

Lines 2138-2144 static NSString* roleValueToNSString(AccessibilityRole value) a/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm_sec1
- a/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm -1 / +1 lines
2138	}	2138	}
2139		2139
2140	if ([attributeName isEqualToString: NSAccessibilityURLAttribute]) {	2140	if ([attributeName isEqualToString: NSAccessibilityURLAttribute]) {
2141	KURL url = m_object->url();	2141	URL url = m_object->url();
2142	if (url.isNull())	2142	if (url.isNull())
2143	return nil;	2143	return nil;
2144	return (NSURL*)url;	2144	return (NSURL*)url;

Lines 73-79 ScriptValue ScriptController::executeScript(const ScriptSourceCode& sourceCode) a/Source/WebCore/bindings/ScriptControllerBase.cpp_sec1
- a/Source/WebCore/bindings/ScriptControllerBase.cpp -1 / +1 lines
73	return evaluate(sourceCode);	73	return evaluate(sourceCode);
74	}	74	}
75		75
76	bool ScriptController::executeIfJavaScriptURL(const KURL& url, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL)	76	bool ScriptController::executeIfJavaScriptURL(const URL& url, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL)
77	{	77	{
78	if (!protocolIsJavaScript(url))	78	if (!protocolIsJavaScript(url))
79	return false;	79	return false;



#include "config.h"
#include "ConvertToUTF8String.h"

#include "URL.h"
#include <wtf/text/CString.h>
#include <wtf/text/WTFString.h>


    return g_strdup(s.utf8().data());
}

gchar* convertToUTF8String(WebCore::URL const& s)
{
    return g_strdup(s.string().utf8().data());
}



#include <wtf/Forward.h>

namespace WebCore {
class URL;
}

typedef char gchar;

gchar* convertToUTF8String(WTF::String const& s);
gchar* convertToUTF8String(WebCore::URL const& s);

#endif /* ConvertToUTF8String_h */



    return jsStringWithCache(exec, s);
}

JSValue jsString(ExecState* exec, const URL& url)
{
    return jsStringWithCache(exec, url.string());
}

JSValue jsStringOrNull(ExecState* exec, const URL& url)
{
    if (url.isNull())
        return jsNull();
    return jsStringWithCache(exec, url.string());
}

JSValue jsStringOrUndefined(ExecState* exec, const URL& url)
{
    if (url.isNull())
        return jsUndefined();



    class Document;
    class Frame;
    class HTMLDocument;
    class URL;
    class Node;

    typedef int ExceptionCode;

    void setDOMException(JSC::ExecState*, ExceptionCode);

    JSC::JSValue jsStringWithCache(JSC::ExecState*, const String&);
    JSC::JSValue jsString(JSC::ExecState*, const URL&); // empty if the URL is null
    inline JSC::JSValue jsStringWithCache(JSC::ExecState* exec, const AtomicString& s)
    { 
        return jsStringWithCache(exec, s.string());
    }
        
    JSC::JSValue jsStringOrNull(JSC::ExecState*, const String&); // null if the string is null
    JSC::JSValue jsStringOrNull(JSC::ExecState*, const URL&); // null if the URL is null

    JSC::JSValue jsStringOrUndefined(JSC::ExecState*, const String&); // undefined if the string is null
    JSC::JSValue jsStringOrUndefined(JSC::ExecState*, const URL&); // undefined if the URL is null

    // See JavaScriptCore for explanation: Should be used for any string that is already owned by another
    // object, to let the engine know that collecting the JSString wrapper is unlikely to save memory.

Lines 88-94 JSValue JSXMLHttpRequest::open(ExecState* exec) a/Source/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSXMLHttpRequestCustom.cpp -1 / +1 lines
88	if (exec->argumentCount() < 2)	88	if (exec->argumentCount() < 2)
89	return exec->vm().throwException(exec, createNotEnoughArgumentsError(exec));	89	return exec->vm().throwException(exec, createNotEnoughArgumentsError(exec));
90		90
91	const KURL& url = impl()->scriptExecutionContext()->completeURL(exec->uncheckedArgument(1).toString(exec)->value(exec));	91	const URL& url = impl()->scriptExecutionContext()->completeURL(exec->uncheckedArgument(1).toString(exec)->value(exec));
92	String method = exec->uncheckedArgument(0).toString(exec)->value(exec);	92	String method = exec->uncheckedArgument(0).toString(exec)->value(exec);
93		93
94	ExceptionCode ec = 0;	94	ExceptionCode ec = 0;

Lines 95-101 public: a/Source/WebCore/bindings/js/ScriptController.h_sec1
- a/Source/WebCore/bindings/js/ScriptController.h -1 / +1 lines
95	ScriptValue executeScriptInWorld(DOMWrapperWorld*, const String& script, bool forceUserGesture = false);	95	ScriptValue executeScriptInWorld(DOMWrapperWorld*, const String& script, bool forceUserGesture = false);
96		96
97	// Returns true if argument is a JavaScript URL.	97	// Returns true if argument is a JavaScript URL.
98	bool executeIfJavaScriptURL(const KURL&, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL = ReplaceDocumentIfJavaScriptURL);	98	bool executeIfJavaScriptURL(const URL&, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL = ReplaceDocumentIfJavaScriptURL);
99		99
100	// This function must be called from the main thread. It is safe to call it repeatedly.	100	// This function must be called from the main thread. It is safe to call it repeatedly.
101	// Darwin is an exception to this rule: it is OK to call this function from any thread, even reentrantly.	101	// Darwin is an exception to this rule: it is OK to call this function from any thread, even reentrantly.



#include "CachedResourceHandle.h"
#include "CachedScript.h"
#include "CachedScriptSourceProvider.h"
#include "URL.h"
#include <parser/SourceProvider.h>
#include <wtf/text/TextPosition.h>
#include <wtf/RefPtr.h>


class ScriptSourceCode {
public:
    ScriptSourceCode(const String& source, const URL& url = URL(), const TextPosition& startPosition = TextPosition::minimumPosition())
        : m_provider(JSC::StringSourceProvider::create(source, url.isNull() ? String() : url.string(), startPosition))
        , m_code(m_provider, startPosition.m_line.oneBasedInt(), startPosition.m_column.oneBasedInt())
        , m_url(url)


    CachedScript* cachedScript() const { return m_cachedScript.get(); }

    const URL& url() const { return m_url; }
    
private:
    RefPtr<JSC::SourceProvider> m_provider;


    CachedResourceHandle<CachedScript> m_cachedScript;

    URL m_url;

};




        if (!readStringData(type))
            return 0;
        if (m_isDOMGlobalObject)
            file = File::create(path->string(), URL(URL(), url->string()), type->string());
        return true;
    }


                return JSValue();
            if (!m_isDOMGlobalObject)
                return jsNull();
            return getJSValue(Blob::create(URL(URL(), url->string()), type->string(), size).get());
        }
        case StringTag: {
            CachedStringRef cachedString;




    if ($codeGenerator->IsStringType($type)) {
        $implIncludes{"wtf/text/AtomicString.h"} = 1;
        $implIncludes{"URL.h"} = 1;
        $implIncludes{"WebDOMString.h"} = 1;
        return;
    }

    my $typeInfo = shift;
    my $returnValue = shift;

    # Used to invoke URLs "const String&" operator
    if ($codeGenerator->IsStringType($typeInfo->signature->type)) {
        return "    return static_cast<const WTF::String&>($returnValue);\n";
    }



        push(@implContent, "    ${className}* thisObj = jsCast<$className*>(asObject(slotBase));\n");
        push(@implContent, "    ASSERT_GC_OBJECT_INHERITS(thisObj, info());\n");
        if ($indexedGetterFunction->signature->type eq "DOMString") {
            $implIncludes{"URL.h"} = 1;
            push(@implContent, "    return jsStringOrUndefined(exec, thisObj->impl()->item(index));\n");
        } else {
            push(@implContent, "    return toJS(exec, thisObj->globalObject(), thisObj->impl()->item(index));\n");

    }

    if ($codeGenerator->IsStringType($type)) {
        AddToImplIncludes("URL.h", $conditional);
        my $conv = $signature->extendedAttributes->{"TreatReturnedNullStringAs"};
        if (defined $conv) {
            return "jsStringOrNull(exec, $value)" if $conv eq "Null";

Lines 618-624 sub AddIncludesForType a/Source/WebCore/bindings/scripts/CodeGeneratorObjC.pm_sec1
- a/Source/WebCore/bindings/scripts/CodeGeneratorObjC.pm -1 / +1 lines
618	}	618	}
619		619
620	if ($codeGenerator->IsStringType($type)) {	620	if ($codeGenerator->IsStringType($type)) {
621	$implIncludes{"KURL.h"} = 1;	621	$implIncludes{"URL.h"} = 1;
622	return;	622	return;
623	}	623	}
624		624



#include "config.h"
#include "WebDOMTestActiveDOMObject.h"

#include "KURL.h"
#include "Node.h"
#include "TestActiveDOMObject.h"
#include "URL.h"
#include "WebDOMNode.h"
#include "WebDOMString.h"
#include "WebExceptionHandler.h"




#include "DOMStringList.h"
#include "Float32Array.h"
#include "KURL.h"
#include "SerializedScriptValue.h"
#include "TestCallback.h"
#include "TestNode.h"
#include "URL.h"
#include "WebDOMDOMStringList.h"
#include "WebDOMFloat32Array.h"
#include "WebDOMString.h"



#include "config.h"
#include "WebDOMTestCustomNamedGetter.h"

#include "KURL.h"
#include "TestCustomNamedGetter.h"
#include "URL.h"
#include "WebDOMString.h"
#include "WebExceptionHandler.h"
#include <wtf/GetPtr.h>



#include "config.h"
#include "WebDOMTestEventConstructor.h"

#include "KURL.h"
#include "TestEventConstructor.h"
#include "URL.h"
#include "WebDOMString.h"
#include "WebExceptionHandler.h"
#include <wtf/GetPtr.h>



#include "WebDOMTestEventTarget.h"

#include "Event.h"
#include "KURL.h"
#include "Node.h"
#include "TestEventTarget.h"
#include "URL.h"
#include "WebDOMEvent.h"
#include "WebDOMNode.h"
#include "WebDOMString.h"



#include "config.h"
#include "WebDOMTestException.h"

#include "KURL.h"
#include "TestException.h"
#include "URL.h"
#include "WebDOMString.h"
#include "WebExceptionHandler.h"
#include <wtf/GetPtr.h>




#include "WebDOMTestInterface.h"

#include "KURL.h"
#include "Node.h"
#include "TestInterface.h"
#include "TestSupplemental.h"
#include "URL.h"
#include "WebDOMNode.h"
#include "WebDOMString.h"
#include "WebExceptionHandler.h"



#include "Dictionary.h"
#include "Document.h"
#include "HTMLNames.h"
#include "KURL.h"
#include "Node.h"
#include "SVGPoint.h"
#include "SerializedScriptValue.h"
#include "TestEnumType.h"
#include "TestNode.h"
#include "TestObj.h"
#include "URL.h"
#include "WebDOMDictionary.h"
#include "WebDOMDocument.h"
#include "WebDOMNode.h"



#include "config.h"
#include "WebDOMTestTypedefs.h"

#include "KURL.h"
#include "SVGPoint.h"
#include "SerializedScriptValue.h"
#include "TestTypedefs.h"
#include "URL.h"
#include "WebDOMSVGPoint.h"
#include "WebDOMString.h"
#include "WebExceptionHandler.h"



#include "JSTestEventConstructor.h"

#include "JSDictionary.h"
#include "KURL.h"
#include "TestEventConstructor.h"
#include "URL.h"
#include <runtime/Error.h>
#include <runtime/JSString.h>
#include <wtf/GetPtr.h>



#include "config.h"
#include "JSTestException.h"

#include "KURL.h"
#include "TestException.h"
#include "URL.h"
#include <runtime/JSString.h>
#include <wtf/GetPtr.h>


Lines 35-41 a/Source/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp_sec1
- a/Source/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp -1 / +1 lines
35		35
36	#if ENABLE(Condition11) \|\| ENABLE(Condition12) \|\| ENABLE(Condition22) \|\| ENABLE(Condition23)	36	#if ENABLE(Condition11) \|\| ENABLE(Condition12) \|\| ENABLE(Condition22) \|\| ENABLE(Condition23)
37	#include "JSNode.h"	37	#include "JSNode.h"
38	#include "KURL.h"	38	#include "URL.h"
39	#include <runtime/JSString.h>	39	#include <runtime/JSString.h>
40	#endif	40	#endif
41		41



#include "JSTestObj.h"
#include "JSTestSubObj.h"
#include "JSbool.h"
#include "KURL.h"
#include "SVGDocument.h"
#include "SVGPoint.h"
#include "SVGStaticPropertyTearOff.h"

#include "SerializedScriptValue.h"
#include "Settings.h"
#include "TestObj.h"
#include "URL.h"
#include "bool.h"
#include <runtime/Error.h>
#include <runtime/JSArray.h>



#include "JSTestCallback.h"
#include "JSTestEventTarget.h"
#include "JSTestSubObj.h"
#include "KURL.h"
#include "SVGPoint.h"
#include "SerializedScriptValue.h"
#include "TestTypedefs.h"
#include "URL.h"
#include <runtime/Error.h>
#include <runtime/JSArray.h>
#include <runtime/JSString.h>



#import "DOMTestActiveDOMObjectInternal.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "Node.h"
#import "TestActiveDOMObject.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>



#import "DOMTestNodeInternal.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "SerializedScriptValue.h"
#import "TestCallback.h"
#import "TestNode.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>



#import "DOMTestCustomNamedGetterInternal.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "TestCustomNamedGetter.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>



#import "DOMTestEventConstructorInternal.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "TestEventConstructor.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>



#import "EventListener.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "Node.h"
#import "ObjCEventListener.h"
#import "TestEventTarget.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>



#import "DOMTestExceptionInternal.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "TestException.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>



#import "DOMTestObjInternal.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "Node.h"
#import "TestInterface.h"
#import "TestObj.h"
#import "TestSupplemental.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>



#import "ExceptionHandlers.h"
#import "HTMLNames.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "Node.h"
#import "ObjCEventListener.h"
#import "SVGDocument.h"

#import "TestObjectCConstructor.h"
#import "TestSubObjConstructor.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import "any.h"



#import "DOMTestTypedefsInternal.h"
#import "ExceptionHandlers.h"
#import "JSMainThreadExecState.h"
#import "KURL.h"
#import "SVGPoint.h"
#import "SerializedScriptValue.h"
#import "TestTypedefs.h"
#import "ThreadCheck.h"
#import "URL.h"
#import "WebCoreObjCExtras.h"
#import "WebScriptObjectPrivate.h"
#import <wtf/GetPtr.h>

Lines 190-196 bool CSSCursorImageValue::isSVGCursor() const a/Source/WebCore/css/CSSCursorImageValue.cpp_sec1
- a/Source/WebCore/css/CSSCursorImageValue.cpp -1 / +1 lines
190	{	190	{
191	if (m_imageValue->isImageValue()) {	191	if (m_imageValue->isImageValue()) {
192	RefPtr<CSSImageValue> imageValue = static_cast<CSSImageValue*>(m_imageValue.get());	192	RefPtr<CSSImageValue> imageValue = static_cast<CSSImageValue*>(m_imageValue.get());
193	KURL kurl(ParsedURLString, imageValue->url());	193	URL kurl(ParsedURLString, imageValue->url());
194	return kurl.hasFragmentIdentifier();	194	return kurl.hasFragmentIdentifier();
195	}	195	}
196	return false;	196	return false;

Lines 80-86 String CSSFontFaceSrcValue::customCSSText() const a/Source/WebCore/css/CSSFontFaceSrcValue.cpp_sec1
- a/Source/WebCore/css/CSSFontFaceSrcValue.cpp -1 / +1 lines
80	return result.toString();	80	return result.toString();
81	}	81	}
82		82
83	void CSSFontFaceSrcValue::addSubresourceStyleURLs(ListHashSet<KURL>& urls, const StyleSheetContents* styleSheet) const	83	void CSSFontFaceSrcValue::addSubresourceStyleURLs(ListHashSet<URL>& urls, const StyleSheetContents* styleSheet) const
84	{	84	{
85	if (!isLocal())	85	if (!isLocal())
86	addSubresourceURL(urls, styleSheet->completeURL(m_resource));	86	addSubresourceURL(urls, styleSheet->completeURL(m_resource));

Lines 65-71 public: a/Source/WebCore/css/CSSFontFaceSrcValue.h_sec1
- a/Source/WebCore/css/CSSFontFaceSrcValue.h -1 / +1 lines
65		65
66	String customCSSText() const;	66	String customCSSText() const;
67		67
68	void addSubresourceStyleURLs(ListHashSet<KURL>&, const StyleSheetContents*) const;	68	void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;
69		69
70	bool hasFailedOrCanceledSubresources() const;	70	bool hasFailedOrCanceledSubresources() const;
71		71



    return strictContext;
}

CSSParserContext::CSSParserContext(CSSParserMode mode, const URL& baseURL)
    : baseURL(baseURL)
    , mode(mode)
    , isHTMLDocument(false)

{
}

CSSParserContext::CSSParserContext(Document& document, const URL& baseURL, const String& charset)
    : baseURL(baseURL.isNull() ? document.baseURL() : baseURL)
    , charset(charset)
    , mode(document.inQuirksMode() ? CSSQuirksMode : CSSStrictMode)

    m_hasFontFaceOnlyValues = false;
}

URL CSSParser::completeURL(const CSSParserContext& context, const String& url)
{
    if (url.isNull())
        return URL();
    if (context.charset.isEmpty())
        return URL(context.baseURL, url);
    return URL(context.baseURL, url, context.charset);
}

URL CSSParser::completeURL(const String& url) const
{
    return completeURL(m_context, url);
}

        unsigned argNumber = argsList->currentIndex();
        if (!argNumber) {
            if (arg->unit == CSSPrimitiveValue::CSS_URI) {
                URL shaderURL = completeURL(arg->string);
                value = WebKitCSSShaderValue::create(shaderURL.string());
            }
        } else if (argNumber == 1 || argNumber == 2) {

        if (arg->id == CSSValueNone)
            value = cssValuePool().createIdentifierValue(CSSValueNone);
        else if (arg->unit == CSSPrimitiveValue::CSS_URI) {
            URL shaderURL = completeURL(arg->string);
            value = WebKitCSSShaderValue::create(shaderURL.string());
            hadAtLeastOneCustomShader = true;
        } else if (argsList->currentIndex() == 1 && arg->unit == CSSParserValue::Function) {



    PassRefPtr<CSSPrimitiveValue> createPrimitiveVariableNameValue(CSSParserValue*);
#endif

    static URL completeURL(const CSSParserContext&, const String& url);

    Location currentLocation();


    inline bool inStrictMode() const { return m_context.mode == CSSStrictMode || m_context.mode == SVGAttributeMode; }
    inline bool inQuirksMode() const { return m_context.mode == CSSQuirksMode; }
    
    URL completeURL(const String& url) const;

    void recheckAtKeyword(const UChar* str, int len);




#ifndef CSSParserMode_h
#define CSSParserMode_h

#include "URL.h"

namespace WebCore {


struct CSSParserContext {
    WTF_MAKE_FAST_ALLOCATED;
public:
    CSSParserContext(CSSParserMode, const URL& baseURL = URL());
    CSSParserContext(Document&, const URL& baseURL = URL(), const String& charset = emptyString());

    URL baseURL;
    String charset;
    CSSParserMode mode;
    bool isHTMLDocument;

Lines 1203-1209 bool CSSPrimitiveValue::hasVariableReference() const a/Source/WebCore/css/CSSPrimitiveValue.cpp_sec1
- a/Source/WebCore/css/CSSPrimitiveValue.cpp -1 / +1 lines
1203	}	1203	}
1204	#endif	1204	#endif
1205		1205
1206	void CSSPrimitiveValue::addSubresourceStyleURLs(ListHashSet<KURL>& urls, const StyleSheetContents* styleSheet) const	1206	void CSSPrimitiveValue::addSubresourceStyleURLs(ListHashSet<URL>& urls, const StyleSheetContents* styleSheet) const
1207	{	1207	{
1208	if (m_primitiveUnitType == CSS_URI)	1208	if (m_primitiveUnitType == CSS_URI)
1209	addSubresourceURL(urls, styleSheet->completeURL(m_value.string));	1209	addSubresourceURL(urls, styleSheet->completeURL(m_value.string));

Lines 330-336 public: a/Source/WebCore/css/CSSPrimitiveValue.h_sec1
- a/Source/WebCore/css/CSSPrimitiveValue.h -1 / +1 lines
330		330
331	bool isQuirkValue() { return m_isQuirkValue; }	331	bool isQuirkValue() { return m_isQuirkValue; }
332		332
333	void addSubresourceStyleURLs(ListHashSet<KURL>&, const StyleSheetContents*) const;	333	void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;
334		334
335	Length viewportPercentageLength() const;	335	Length viewportPercentageLength() const;
336		336

Lines 49-55 String CSSReflectValue::customSerializeResolvingVariables(const HashMap<AtomicSt a/Source/WebCore/css/CSSReflectValue.cpp_sec1
- a/Source/WebCore/css/CSSReflectValue.cpp -1 / +1 lines
49	}	49	}
50	#endif	50	#endif
51		51
52	void CSSReflectValue::addSubresourceStyleURLs(ListHashSet<KURL>& urls, const StyleSheetContents* styleSheet) const	52	void CSSReflectValue::addSubresourceStyleURLs(ListHashSet<URL>& urls, const StyleSheetContents* styleSheet) const
53	{	53	{
54	if (m_mask)	54	if (m_mask)
55	m_mask->addSubresourceStyleURLs(urls, styleSheet);	55	m_mask->addSubresourceStyleURLs(urls, styleSheet);

Lines 52-58 public: a/Source/WebCore/css/CSSReflectValue.h_sec1
- a/Source/WebCore/css/CSSReflectValue.h -1 / +1 lines
52	String customSerializeResolvingVariables(const HashMap<AtomicString, String>&) const;	52	String customSerializeResolvingVariables(const HashMap<AtomicString, String>&) const;
53	#endif	53	#endif
54		54
55	void addSubresourceStyleURLs(ListHashSet<KURL>&, const StyleSheetContents*) const;	55	void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;
56		56
57	bool equals(const CSSReflectValue&) const;	57	bool equals(const CSSReflectValue&) const;
58		58



    return adoptRef(new CSSStyleSheet(sheet, ownerNode, false));
}

PassRefPtr<CSSStyleSheet> CSSStyleSheet::createInline(Node& ownerNode, const URL& baseURL, const String& encoding)
{
    CSSParserContext parserContext(ownerNode.document(), baseURL, encoding);
    RefPtr<StyleSheetContents> sheet = StyleSheetContents::create(baseURL.string(), parserContext);

{
    if (m_isInlineStylesheet)
        return true;
    URL baseURL = m_contents->baseURL();
    if (baseURL.isEmpty())
        return true;
    Document* document = ownerDocument();

    return m_contents->originalURL();
}

URL CSSStyleSheet::baseURL() const
{
    return m_contents->baseURL();
}



public:
    static PassRefPtr<CSSStyleSheet> create(PassRefPtr<StyleSheetContents>, CSSImportRule* ownerRule = 0);
    static PassRefPtr<CSSStyleSheet> create(PassRefPtr<StyleSheetContents>, Node* ownerNode);
    static PassRefPtr<CSSStyleSheet> createInline(Node&, const URL&, const String& encoding = String());

    virtual ~CSSStyleSheet();



    virtual void clearOwnerNode() OVERRIDE;
    virtual CSSImportRule* ownerRule() const OVERRIDE { return m_ownerRule; }
    virtual URL baseURL() const OVERRIDE;
    virtual bool isLoading() const OVERRIDE;
    
    void clearOwnerRule() { m_ownerRule = 0; }

Lines 111-117 CSSValue::Type CSSValue::cssValueType() const a/Source/WebCore/css/CSSValue.cpp_sec1
- a/Source/WebCore/css/CSSValue.cpp -1 / +1 lines
111	return CSS_CUSTOM;	111	return CSS_CUSTOM;
112	}	112	}
113		113
114	void CSSValue::addSubresourceStyleURLs(ListHashSet<KURL>& urls, const StyleSheetContents* styleSheet) const	114	void CSSValue::addSubresourceStyleURLs(ListHashSet<URL>& urls, const StyleSheetContents* styleSheet) const
115	{	115	{
116	// This should get called for internal instances only.	116	// This should get called for internal instances only.
117	ASSERT(!isCSSOMSafe());	117	ASSERT(!isCSSOMSafe());



#define CSSValue_h

#include "ExceptionCode.h"
#include "URLHash.h"
#include <wtf/ListHashSet.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>


    PassRefPtr<CSSValue> cloneForCSSOM() const;

    void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;

    bool hasFailedOrCanceledSubresources() const;


Lines 167-173 String CSSValueList::customSerializeResolvingVariables(const HashMap<AtomicStrin a/Source/WebCore/css/CSSValueList.cpp_sec1
- a/Source/WebCore/css/CSSValueList.cpp -1 / +1 lines
167	}	167	}
168	#endif	168	#endif
169		169
170	void CSSValueList::addSubresourceStyleURLs(ListHashSet<KURL>& urls, const StyleSheetContents* styleSheet) const	170	void CSSValueList::addSubresourceStyleURLs(ListHashSet<URL>& urls, const StyleSheetContents* styleSheet) const
171	{	171	{
172	size_t size = m_values.size();	172	size_t size = m_values.size();
173	for (size_t i = 0; i < size; ++i)	173	for (size_t i = 0; i < size; ++i)

Lines 66-72 public: a/Source/WebCore/css/CSSValueList.h_sec1
- a/Source/WebCore/css/CSSValueList.h -1 / +1 lines
66	String customSerializeResolvingVariables(const HashMap<AtomicString, String>&) const;	66	String customSerializeResolvingVariables(const HashMap<AtomicString, String>&) const;
67	#endif	67	#endif
68		68
69	void addSubresourceStyleURLs(ListHashSet<KURL>&, const StyleSheetContents*) const;	69	void addSubresourceStyleURLs(ListHashSet<URL>&, const StyleSheetContents*) const;
70		70
71	bool hasFailedOrCanceledSubresources() const;	71	bool hasFailedOrCanceledSubresources() const;
72		72

Lines 1998-2004 public: a/Source/WebCore/css/DeprecatedStyleBuilder.cpp_sec1
- a/Source/WebCore/css/DeprecatedStyleBuilder.cpp -1 / +1 lines
1998	#if ENABLE(SVG)	1998	#if ENABLE(SVG)
1999	else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_URI) {	1999	else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_URI) {
2000	String cssURLValue = primitiveValue->getStringValue();	2000	String cssURLValue = primitiveValue->getStringValue();
2001	KURL url = styleResolver->document().completeURL(cssURLValue);	2001	URL url = styleResolver->document().completeURL(cssURLValue);
2002	// FIXME: It doesn't work with forward or external SVG references (see https://bugs.webkit.org/show_bug.cgi?id=90405)	2002	// FIXME: It doesn't work with forward or external SVG references (see https://bugs.webkit.org/show_bug.cgi?id=90405)
2003	setValue(styleResolver->style(), ReferenceClipPathOperation::create(cssURLValue, url.fragmentIdentifier()));	2003	setValue(styleResolver->style(), ReferenceClipPathOperation::create(cssURLValue, url.fragmentIdentifier()));
2004	}	2004	}

Lines 1041-1047 void MutableStylePropertySet::mergeAndOverrideOnConflict(const StylePropertySet& a/Source/WebCore/css/StylePropertySet.cpp_sec1
- a/Source/WebCore/css/StylePropertySet.cpp -1 / +1 lines
1041	addParsedProperty(other.propertyAt(i).toCSSProperty());	1041	addParsedProperty(other.propertyAt(i).toCSSProperty());
1042	}	1042	}
1043		1043
1044	void StylePropertySet::addSubresourceStyleURLs(ListHashSet<KURL>& urls, StyleSheetContents* contextStyleSheet) const	1044	void StylePropertySet::addSubresourceStyleURLs(ListHashSet<URL>& urls, StyleSheetContents* contextStyleSheet) const
1045	{	1045	{
1046	unsigned size = propertyCount();	1046	unsigned size = propertyCount();
1047	for (unsigned i = 0; i < size; ++i)	1047	for (unsigned i = 0; i < size; ++i)



class CSSStyleDeclaration;
class ComputedStyleExtractor;
class ImmutableStylePropertySet;
class URL;
class MutableStylePropertySet;
class PropertySetCSSStyleDeclaration;
class StyledElement;


    CSSParserMode cssParserMode() const { return static_cast<CSSParserMode>(m_cssParserMode); }

    void addSubresourceStyleURLs(ListHashSet<URL>&, StyleSheetContents* contextStyleSheet) const;

    PassRefPtr<MutableStylePropertySet> mutableCopy() const;
    PassRefPtr<ImmutableStylePropertySet> immutableCopyIfNeeded() const;



    CustomFilterProgramType programType, const CustomFilterProgramMixSettings& mixSettings, CustomFilterMeshType meshType)
{
    CachedResourceLoader* cachedResourceLoader = m_state.document().cachedResourceLoader();
    URL vertexShaderURL = vertexShader ? vertexShader->completeURL(cachedResourceLoader) : URL();
    URL fragmentShaderURL = fragmentShader ? fragmentShader->completeURL(cachedResourceLoader) : URL();
    RefPtr<StyleCustomFilterProgram> program;
    if (m_customFilterProgramCache)
        program = m_customFilterProgramCache->lookup(CustomFilterProgramInfo(vertexShaderURL, fragmentShaderURL, programType, mixSettings, meshType));

                continue;

            WebKitCSSSVGDocumentValue* svgDocumentValue = static_cast<WebKitCSSSVGDocumentValue*>(argument);
            URL url = m_state.document().completeURL(svgDocumentValue->url());

            RefPtr<ReferenceFilterOperation> operation = ReferenceFilterOperation::create(svgDocumentValue->url(), url.fragmentIdentifier(), operationType);
            if (SVGURIReference::isExternalURIReference(svgDocumentValue->url(), m_state.document())) {

Lines 77-83 class DeprecatedStyleBuilder; a/Source/WebCore/css/StyleResolver.h_sec1
- a/Source/WebCore/css/StyleResolver.h -1 / +1 lines
77	class Element;	77	class Element;
78	class Frame;	78	class Frame;
79	class FrameView;	79	class FrameView;
80	class KURL;	80	class URL;
81	class KeyframeList;	81	class KeyframeList;
82	class KeyframeValue;	82	class KeyframeValue;
83	class MediaQueryEvaluator;	83	class MediaQueryEvaluator;



        m_cachedSheet->removeClient(&m_styleSheetClient);
}

void StyleRuleImport::setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet* cachedStyleSheet)
{
    if (m_styleSheet)
        m_styleSheet->clearOwnerRule();

    if (!cachedResourceLoader)
        return;

    URL absURL;
    if (!m_parentStyleSheet->baseURL().isNull())
        // use parent styleheet's URL as the base URL
        absURL = URL(m_parentStyleSheet->baseURL(), m_strHref);
    else
        absURL = document->completeURL(m_strHref);




    public:
        ImportedStyleSheetClient(StyleRuleImport* ownerRule) : m_ownerRule(ownerRule) { }
        virtual ~ImportedStyleSheetClient() { }
        virtual void setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet* sheet)
        {
            m_ownerRule->setCSSStyleSheet(href, baseURL, charset, sheet);
        }

        StyleRuleImport* m_ownerRule;
    };

    void setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet*);
    friend class ImportedStyleSheetClient;

    StyleRuleImport(const String& href, PassRefPtr<MediaQuerySet>);



#define StyleSheet_h

#include "CSSParserMode.h"
#include "URLHash.h"
#include <wtf/Forward.h>
#include <wtf/ListHashSet.h>
#include <wtf/RefCounted.h>


    virtual CSSImportRule* ownerRule() const { return 0; }
    virtual void clearOwnerNode() = 0;
    virtual URL baseURL() const = 0;
    virtual bool isLoading() const = 0;
    virtual bool isCSSStyleSheet() const { return false; }
    virtual bool isXSLStyleSheet() const { return false; }



    return ownerNode ? &ownerNode->document() : 0;
}

URL StyleSheetContents::completeURL(const String& url) const
{
    return CSSParser::completeURL(m_parserContext, url);
}

void StyleSheetContents::addSubresourceStyleURLs(ListHashSet<URL>& urls)
{
    Deque<StyleSheetContents*> styleSheetQueue;
    styleSheetQueue.append(this);



#define StyleSheetContents_h

#include "CSSParserMode.h"
#include "URL.h"
#include <wtf/HashMap.h>
#include <wtf/ListHashSet.h>
#include <wtf/RefCounted.h>

    bool loadCompleted() const { return m_loadCompleted; }
    bool hasFailedOrCanceledSubresources() const;

    URL completeURL(const String& url) const;
    void addSubresourceStyleURLs(ListHashSet<URL>&);

    void setIsUserStyleSheet(bool b) { m_isUserStyleSheet = b; }
    bool isUserStyleSheet() const { return m_isUserStyleSheet; }

    // this style sheet. This property probably isn't useful for much except
    // the JavaScript binding (which needs to use this value for security).
    String originalURL() const { return m_originalURL; }
    const URL& baseURL() const { return m_parserContext.baseURL; }

    unsigned ruleCount() const;
    StyleRuleBase* ruleAt(unsigned index) const;



#include "CachedResourceRequest.h"
#include "CachedResourceRequestInitiators.h"
#include "Document.h"
#include "URL.h"
#include "StyleCachedShader.h"
#include "StylePendingShader.h"
#include <wtf/text/StringBuilder.h>

{
}

URL WebKitCSSShaderValue::completeURL(CachedResourceLoader* loader) const
{
    return loader->document()->completeURL(m_url);
}



namespace WebCore {

class CachedResourceLoader;
class URL;
class StyleCachedShader;
class StyleShader;


    const String& format() const { return m_format; }
    void setFormat(const String& format) { m_format = format; }

    URL completeURL(CachedResourceLoader*) const;
    StyleCachedShader* cachedShader(CachedResourceLoader*);
    StyleShader* cachedOrPendingShader();




    RefPtr<Document> doc;
#if ENABLE(SVG)
    if (namespaceURI == SVGNames::svgNamespaceURI)
        doc = SVGDocument::create(0, URL());
    else
#endif
    if (namespaceURI == HTMLNames::xhtmlNamespaceURI)
        doc = Document::createXHTML(0, URL());
    else
        doc = Document::create(0, URL());

    doc->setSecurityOrigin(m_document.securityOrigin());



PassRefPtr<HTMLDocument> DOMImplementation::createHTMLDocument(const String& title)
{
    RefPtr<HTMLDocument> d = HTMLDocument::create(0, URL());
    d->open();
    d->write("<!doctype html><html><body></body></html>");
    if (!title.isNull())

    return d.release();
}

PassRefPtr<Document> DOMImplementation::createDocument(const String& type, Frame* frame, const URL& url, bool inViewSourceMode)
{
    if (inViewSourceMode)
        return HTMLViewSourceDocument::create(frame, url, type);



class DocumentType;
class Frame;
class HTMLDocument;
class URL;
class RegularExpression;

typedef int ExceptionCode;

    PassRefPtr<HTMLDocument> createHTMLDocument(const String& title);

    // Other methods (not part of DOM)
    static PassRefPtr<Document> createDocument(const String& MIMEType, Frame*, const URL&, bool inViewSourceMode);

    static bool isXMLMIMEType(const String& MIMEType);
    static bool isTextMIMEType(const String& MIMEType);



    return true;
}

static bool shouldInheritSecurityOriginFromOwner(const URL& url)
{
    // http://www.whatwg.org/specs/web-apps/current-work/#origin-0
    //

    return false;
}

static void printNavigationErrorMessage(Frame* frame, const URL& activeURL, const char* reason)
{
    String message = "Unsafe JavaScript attempt to initiate navigation for frame with URL '" + frame->document()->url().string() + "' from frame with URL '" + activeURL.string() + "'. " + reason + "\n";


}
#endif

Document::Document(Frame* frame, const URL& url, unsigned documentClasses)
    : ContainerNode(0, CreateDocument)
    , TreeScope(this)
    , m_styleResolverThrowawayTimer(this, &Document::styleResolverThrowawayTimerFired, timeBeforeThrowingAwayStyleResolverAfterLastUseInSeconds)

    updateBaseURL();
}

URL Document::baseURI() const
{
    return m_baseURL;
}

    addMessage(JSMessageSource, ErrorMessageLevel, errorMessage, sourceURL, lineNumber, columnNumber, callStack);
}

void Document::setURL(const URL& url)
{
    const URL& newURL = url.isEmpty() ? blankURL() : url;
    if (newURL == m_url)
        return;



void Document::updateBaseURL()
{
    URL oldBaseURL = m_baseURL;
    // DOM 3 Core: When the Document supports the feature "HTML" [DOM Level 2 HTML], the base URI is computed using
    // first the value of the href attribute of the HTML BASE element if any, and the value of the documentURI attribute
    // from the Document interface otherwise.

        // The documentURI attribute is read-only from JavaScript, but writable from Objective C, so we need to retain
        // this fallback behavior. We use a null base URL, since the documentURI attribute is an arbitrary string
        // and DOM 3 Core does not specify how it should be resolved.
        m_baseURL = URL(ParsedURLString, documentURI());
    }

    if (m_selectorQueryCache)
        m_selectorQueryCache->invalidate();

    if (!m_baseURL.isValid())
        m_baseURL = URL();

    if (m_elementSheet) {
        // Element sheet is silly. It never contains anything.

    }
}

void Document::setBaseURLOverride(const URL& url)
{
    m_baseURLOverride = url;
    updateBaseURL();

    }

    // FIXME: Since this doesn't share code with completeURL it may not handle encodings correctly.
    URL baseElementURL;
    if (href) {
        String strippedHref = stripLeadingAndTrailingHTMLSpaces(*href);
        if (!strippedHref.isEmpty())
            baseElementURL = URL(url(), strippedHref);
    }
    if (m_baseElementURL != baseElementURL && contentSecurityPolicy()->allowBaseURI(baseElementURL)) {
        m_baseElementURL = baseElementURL;

    m_baseTarget = target ? *target : nullAtom;
}

String Document::userAgent(const URL& url) const
{
    return frame() ? frame()->loader().userAgent(url) : String();
}

        return String();
    }

    URL cookieURL = this->cookieURL();
    if (cookieURL.isEmpty())
        return String();


        return;
    }

    URL cookieURL = this->cookieURL();
    if (cookieURL.isEmpty())
        return;


    m_decoder = decoder;
}

URL Document::completeURL(const String& url, const URL& baseURLOverride) const
{
    // Always return a null URL when passed a null string.
    // FIXME: Should we change the URL constructor to have this behavior?
    // See also [CSS]StyleSheet::completeURL(const String&)
    if (url.isNull())
        return URL();
    const URL& baseURL = ((baseURLOverride.isEmpty() || baseURLOverride == blankURL()) && parentDocument()) ? parentDocument()->baseURL() : baseURLOverride;
    if (!m_decoder)
        return URL(baseURL, url);
    return URL(baseURL, url, m_decoder->encoding());
}

URL Document::completeURL(const String& url) const
{
    return completeURL(url, m_baseURL);
}

    return command(this, commandName).value();
}

URL Document::openSearchDescriptionURL()
{
    static const char* const openSearchMIMEType = "application/opensearchdescription+xml";
    static const char* const openSearchRelation = "search";

    // FIXME: Why do only top-level frames have openSearchDescriptionURLs?
    if (!frame() || frame()->tree().parent())
        return URL();

    // FIXME: Why do we need to wait for FrameStateComplete?
    if (frame()->loader().state() != FrameStateComplete)
        return URL();

    if (!head())
        return URL();

    RefPtr<HTMLCollection> children = head()->children();
    for (unsigned i = 0; Node* child = children->item(i); i++) {

        return linkElement->href();
    }

    return URL();
}

void Document::pushCurrentScript(PassRefPtr<HTMLScriptElement> newCurrentScript)

    if (!m_frame) {
        // No source for a security context.
        // This can occur via document.implementation.createDocument().
        m_cookieURL = URL(ParsedURLString, emptyString());
        setSecurityOrigin(SecurityOrigin::createUnique());
        setContentSecurityPolicy(ContentSecurityPolicy::create(this));
        return;

    return isMainThread();
}

void Document::updateURLForPushOrReplaceState(const URL& url)
{
    Frame* f = frame();
    if (!f)




class Document : public ContainerNode, public TreeScope, public ScriptExecutionContext {
public:
    static PassRefPtr<Document> create(Frame* frame, const URL& url)
    {
        return adoptRef(new Document(frame, url));
    }
    static PassRefPtr<Document> createXHTML(Frame* frame, const URL& url)
    {
        return adoptRef(new Document(frame, url, XHTMLDocumentClass));
    }

    String documentURI() const { return m_documentURI; }
    void setDocumentURI(const String&);

    virtual URL baseURI() const;

#if ENABLE(PAGE_VISIBILITY_API)
    String visibilityState() const;


    bool wellFormed() const { return m_wellFormed; }

    virtual const URL& url() const OVERRIDE FINAL { return m_url; }
    void setURL(const URL&);

    // To understand how these concepts relate to one another, please see the
    // comments surrounding their declaration.
    const URL& baseURL() const { return m_baseURL; }
    void setBaseURLOverride(const URL&);
    const URL& baseURLOverride() const { return m_baseURLOverride; }
    const URL& baseElementURL() const { return m_baseElementURL; }
    const String& baseTarget() const { return m_baseTarget; }
    void processBaseElement();

    virtual URL completeURL(const String&) const OVERRIDE FINAL;
    URL completeURL(const String&, const URL& baseURLOverride) const;

    virtual String userAgent(const URL&) const;

    virtual void disableEval(const String& errorMessage);


    //    document inherits the security context of another document, it
    //    inherits its cookieURL but not its URL.
    //
    const URL& cookieURL() const { return m_cookieURL; }
    void setCookieURL(const URL& url) { m_cookieURL = url; }

    // The firstPartyForCookies is used to compute whether this document
    // appears in a "third-party" context for the purpose of third-party

    //       firstPartyForCookies have a different registry-controlled
    //       domain.
    //
    const URL& firstPartyForCookies() const { return m_firstPartyForCookies; }
    void setFirstPartyForCookies(const URL& url) { m_firstPartyForCookies = url; }
    
    // The following implements the rule from HTML 4 for what valid names are.
    // To get this right for all the XML cases, we probably have to improve this or move it

    bool queryCommandSupported(const String& command);
    String queryCommandValue(const String& command);

    URL openSearchDescriptionURL();

    // designMode support
    enum InheritedBool { off = false, on = true, inherit };    

    void initSecurityContext();
    void initContentSecurityPolicy();

    void updateURLForPushOrReplaceState(const URL&);
    void statePopped(PassRefPtr<SerializedScriptValue>);

    bool processingLoadEvent() const { return m_processingLoadEvent; }

    void setVisualUpdatesAllowedByClient(bool);

protected:
    Document(Frame*, const URL&, unsigned = DefaultDocumentClass);

    void clearXMLVersion() { m_xmlVersion = String(); }


    bool m_wellFormed;

    // Document URLs.
    URL m_url; // Document.URL: The URL from which this document was retrieved.
    URL m_baseURL; // Node.baseURI: The URL to use when resolving relative URLs.
    URL m_baseURLOverride; // An alternative base URL that takes precedence over m_baseURL (but not m_baseElementURL).
    URL m_baseElementURL; // The URL set by the <base> element.
    URL m_cookieURL; // The URL to use for cookie access.
    URL m_firstPartyForCookies; // The policy URL for third-party cookie blocking.

    // Document.documentURI:
    // Although URL-like, Document.documentURI can actually be set to any



{
}

URL DocumentType::baseURI() const
{
    return URL();
}

String DocumentType::nodeName() const

Lines 49-55 public: a/Source/WebCore/dom/DocumentType.h_sec1
- a/Source/WebCore/dom/DocumentType.h -1 / +1 lines
49	private:	49	private:
50	DocumentType(Document&, const String& name, const String& publicId, const String& systemId);	50	DocumentType(Document&, const String& name, const String& publicId, const String& systemId);
51		51
52	virtual KURL baseURI() const;	52	virtual URL baseURI() const;
53	virtual String nodeName() const;	53	virtual String nodeName() const;
54	virtual NodeType nodeType() const;	54	virtual NodeType nodeType() const;
55	virtual PassRefPtr<Node> cloneNode(bool deep);	55	virtual PassRefPtr<Node> cloneNode(bool deep);



    m_tagName.setPrefix(prefix.isEmpty() ? AtomicString() : prefix);
}

URL Element::baseURI() const
{
    const AtomicString& baseAttribute = getAttribute(baseAttr);
    URL base(URL(), baseAttribute);
    if (!base.protocol().isEmpty())
        return base;


    if (!parent)
        return base;

    const URL& parentBase = parent->baseURI();
    if (parentBase.isNull())
        return base;

    return URL(parentBase, baseAttribute);
}

const AtomicString& Element::imageSourceURL() const

    return data.dataset();
}

URL Element::getURLAttribute(const QualifiedName& name) const
{
#if !ASSERT_DISABLED
    if (elementData()) {

    return document().completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(name)));
}

URL Element::getNonEmptyURLAttribute(const QualifiedName& name) const
{
#if !ASSERT_DISABLED
    if (elementData()) {

#endif
    String value = stripLeadingAndTrailingHTMLSpaces(getAttribute(name));
    if (value.isEmpty())
        return URL();
    return document().completeURL(value);
}




    virtual const AtomicString& prefix() const OVERRIDE FINAL { return m_tagName.prefix(); }
    virtual const AtomicString& namespaceURI() const OVERRIDE FINAL { return m_tagName.namespaceURI(); }

    virtual URL baseURI() const OVERRIDE FINAL;

    virtual String nodeName() const;


    virtual bool isURLAttribute(const Attribute&) const { return false; }
    virtual bool isHTMLContentAttribute(const Attribute&) const { return false; }

    URL getURLAttribute(const QualifiedName&) const;
    URL getNonEmptyURLAttribute(const QualifiedName&) const;

    virtual const AtomicString& imageSourceURL() const;
    virtual String target() const { return String(); }

Lines 33-39 a/Source/WebCore/dom/IconURL.cpp_sec1
- a/Source/WebCore/dom/IconURL.cpp -1 / +1 lines
33		33
34	namespace WebCore {	34	namespace WebCore {
35		35
36	IconURL IconURL::defaultIconURL(const KURL& url, IconType type)	36	IconURL IconURL::defaultIconURL(const URL& url, IconType type)
37	{	37	{
38	IconURL result(url, emptyString(), emptyString(), type);	38	IconURL result(url, emptyString(), emptyString(), type);
39	result.m_isDefaultIcon = true;	39	result.m_isDefaultIcon = true;



#ifndef IconURL_h
#define IconURL_h

#include "URL.h"

namespace WebCore {


    IconType m_iconType;
    String m_sizes;
    String m_mimeType;
    URL m_iconURL;
    bool m_isDefaultIcon;

    IconURL()

    {
    }

    IconURL(const URL& url, const String& sizes, const String& mimeType, IconType type)
        : m_iconType(type)
        , m_sizes(sizes)
        , m_mimeType(mimeType)

    {
    }
    
    static IconURL defaultIconURL(const URL&, IconType);
};

bool operator==(const IconURL&, const IconURL&);

Lines 145-151 void InlineStyleSheetOwner::createSheet(Element& element, const String& text) a/Source/WebCore/dom/InlineStyleSheetOwner.cpp_sec1
- a/Source/WebCore/dom/InlineStyleSheetOwner.cpp -1 / +1 lines
145		145
146	m_loading = true;	146	m_loading = true;
147		147
148	m_sheet = CSSStyleSheet::createInline(element, KURL(), document.inputEncoding());	148	m_sheet = CSSStyleSheet::createInline(element, URL(), document.inputEncoding());
149	m_sheet->setMediaQueries(mediaQueries.release());	149	m_sheet->setMediaQueries(mediaQueries.release());
150	m_sheet->setTitle(element.title());	150	m_sheet->setTitle(element.title());
151	m_sheet->contents()->parseStringAtLine(text, m_startLineNumber.zeroBasedInt(), m_isParsingChildren);	151	m_sheet->contents()->parseStringAtLine(text, m_startLineNumber.zeroBasedInt(), m_isParsingChildren);



    return doc == this ? 0 : doc;
}

URL Node::baseURI() const
{
    return parentNode() ? parentNode()->baseURI() : URL();
}

bool Node::isEqualNode(Node* other) const

        it->value->invalidateCache();
}

void Node::getSubresourceURLs(ListHashSet<URL>& urls) const
{
    addSubresourceAttributeURLs(urls);
}




#include "EditingBoundary.h"
#include "EventTarget.h"
#include "URLHash.h"
#include "LayoutRect.h"
#include "MutationObserver.h"
#include "RenderStyleConstants.h"

    Node* pseudoAwareFirstChild() const;
    Node* pseudoAwareLastChild() const;

    virtual URL baseURI() const;
    
    void getSubresourceURLs(ListHashSet<URL>&) const;

    // These should all actually return a node, but this is only important for language bindings,
    // which will already know and hold a ref on the right node to return. Returning bool allows


    virtual void didMoveToNewDocument(Document* oldDocument);
    
    virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const { }

    bool hasRareData() const { return getFlag(HasRareDataFlag); }


};

// Used in Node::addSubresourceAttributeURLs() and in addSubresourceStyleURLs()
inline void addSubresourceURL(ListHashSet<URL>& urls, const URL& url)
{
    if (!url.isNull())
        urls.add(url);



            // We need to make a synthetic XSLStyleSheet that is embedded.  It needs to be able
            // to kick off import/include loads that can hang off some parent sheet.
            if (m_isXSL) {
                URL finalURL(ParsedURLString, m_localHref);
                m_sheet = XSLStyleSheet::createEmbedded(this, finalURL);
                m_loading = false;
            }

    return false;
}

void ProcessingInstruction::setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet* sheet)
{
    if (!inDocument()) {
        ASSERT(!m_sheet);

}

#if ENABLE(XSLT)
void ProcessingInstruction::setXSLStyleSheet(const String& href, const URL& baseURL, const String& sheet)
{
    ASSERT(m_isXSL);
    m_sheet = XSLStyleSheet::create(this, href, baseURL);

    sheet->setDisabled(m_alternate);
}

void ProcessingInstruction::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
{
    if (!sheet())
        return;



    virtual void removedFrom(ContainerNode*) OVERRIDE;

    void checkStyleSheet();
    virtual void setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet*);
#if ENABLE(XSLT)
    virtual void setXSLStyleSheet(const String& href, const URL& baseURL, const String& sheet);
#endif

    bool isLoading() const;
    virtual bool sheetLoaded();

    virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;

    void parseStyleSheet(const String& sheet);


Lines 280-286 void ScriptExecutionContext::closeMessagePorts() { a/Source/WebCore/dom/ScriptExecutionContext.cpp_sec1
- a/Source/WebCore/dom/ScriptExecutionContext.cpp -1 / +1 lines
280		280
281	bool ScriptExecutionContext::sanitizeScriptError(String& errorMessage, int& lineNumber, int& columnNumber, String& sourceURL, CachedScript* cachedScript)	281	bool ScriptExecutionContext::sanitizeScriptError(String& errorMessage, int& lineNumber, int& columnNumber, String& sourceURL, CachedScript* cachedScript)
282	{	282	{
283	KURL targetURL = completeURL(sourceURL);	283	URL targetURL = completeURL(sourceURL);
284	if (securityOrigin()->canRequest(targetURL) \|\| (cachedScript && cachedScript->passesAccessControlCheck(securityOrigin())))	284	if (securityOrigin()->canRequest(targetURL) \|\| (cachedScript && cachedScript->passesAccessControlCheck(securityOrigin())))
285	return false;	285	return false;
286	errorMessage = "Script error.";	286	errorMessage = "Script error.";




#include "ActiveDOMObject.h"
#include "ConsoleTypes.h"
#include "URL.h"
#include "SecurityContext.h"
#include "Supplementable.h"
#include <wtf/HashSet.h>

    virtual bool isContextThread() const { return true; }
    virtual bool isJSExecutionForbidden() const = 0;

    virtual const URL& url() const = 0;
    virtual URL completeURL(const String& url) const = 0;

    virtual String userAgent(const URL&) const = 0;

    virtual void disableEval(const String& errorMessage) = 0;


Lines 56-62 void SecurityContext::setContentSecurityPolicy(PassOwnPtr<ContentSecurityPolicy> a/Source/WebCore/dom/SecurityContext.cpp_sec1
- a/Source/WebCore/dom/SecurityContext.cpp -1 / +1 lines
56	m_contentSecurityPolicy = contentSecurityPolicy;	56	m_contentSecurityPolicy = contentSecurityPolicy;
57	}	57	}
58		58
59	bool SecurityContext::isSecureTransitionTo(const KURL& url) const	59	bool SecurityContext::isSecureTransitionTo(const URL& url) const
60	{	60	{
61	// If we haven't initialized our security origin by now, this is probably	61	// If we haven't initialized our security origin by now, this is probably
62	// a new window created via the API (i.e., that lacks an origin and lacks	62	// a new window created via the API (i.e., that lacks an origin and lacks




class SecurityOrigin;
class ContentSecurityPolicy;
class URL;

enum SandboxFlag {
    // See http://www.whatwg.org/specs/web-apps/current-work/#attr-iframe-sandbox for a list of the sandbox flags.

    SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
    ContentSecurityPolicy* contentSecurityPolicy() { return m_contentSecurityPolicy.get(); }

    bool isSecureTransitionTo(const URL&) const;

    void enforceSandboxFlags(SandboxFlags mask);
    bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }

Lines 274-280 void StyledElement::removeAllInlineStyleProperties() a/Source/WebCore/dom/StyledElement.cpp_sec1
- a/Source/WebCore/dom/StyledElement.cpp -1 / +1 lines
274	inlineStyleChanged();	274	inlineStyleChanged();
275	}	275	}
276		276
277	void StyledElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	277	void StyledElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
278	{	278	{
279	if (const StylePropertySet* inlineStyle = elementData() ? elementData()->inlineStyle() : 0)	279	if (const StylePropertySet* inlineStyle = elementData() ? elementData()->inlineStyle() : 0)
280	inlineStyle->addSubresourceStyleURLs(urls, document().elementSheet().contents());	280	inlineStyle->addSubresourceStyleURLs(urls, document().elementSheet().contents());

Lines 76-82 protected: a/Source/WebCore/dom/StyledElement.h_sec1
- a/Source/WebCore/dom/StyledElement.h -1 / +1 lines
76	void addPropertyToPresentationAttributeStyle(MutableStylePropertySet*, CSSPropertyID, double value, CSSPrimitiveValue::UnitTypes);	76	void addPropertyToPresentationAttributeStyle(MutableStylePropertySet*, CSSPropertyID, double value, CSSPrimitiveValue::UnitTypes);
77	void addPropertyToPresentationAttributeStyle(MutableStylePropertySet*, CSSPropertyID, const String& value);	77	void addPropertyToPresentationAttributeStyle(MutableStylePropertySet*, CSSPropertyID, const String& value);
78		78
79	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	79	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
80		80
81	private:	81	private:
82	void styleAttributeChanged(const AtomicString& newStyleString, AttributeModificationReason);	82	void styleAttributeChanged(const AtomicString& newStyleString, AttributeModificationReason);



    applyCommand(SimplifyMarkupCommand::create(document(), startNode, (endNode) ? NodeTraversal::next(endNode) : 0));
}

void Editor::copyURL(const URL& url, const String& title)
{
    copyURL(url, title, *Pasteboard::createForCopyAndPaste());
}

void Editor::copyURL(const URL& url, const String& title, Pasteboard& pasteboard)
{
    PasteboardURL pasteboardURL;
    pasteboardURL.url = url;

    if (!element)
        return;

    URL url = result.absoluteLinkURL();
    if (url.isEmpty())
        url = result.absoluteImageURL();




    void pasteAsPlainText();
    void performDelete();

    void copyURL(const URL&, const String& title);
    void copyURL(const URL&, const String& title, Pasteboard&);
    void copyImage(const HitTestResult&);

    String readPlainTextFromPasteboard(Pasteboard&);


#if PLATFORM(MAC) || PLATFORM(EFL)
    void writeSelectionToPasteboard(Pasteboard&);
    void writeImageToPasteboard(Pasteboard&, Element& imageElement, const URL&, const String& title);
#endif

private:

Lines 35-41 a/Source/WebCore/editing/MarkupAccumulator.cpp_sec1
- a/Source/WebCore/editing/MarkupAccumulator.cpp -1 / +1 lines
35	#include "HTMLElement.h"	35	#include "HTMLElement.h"
36	#include "HTMLNames.h"	36	#include "HTMLNames.h"
37	#include "HTMLTemplateElement.h"	37	#include "HTMLTemplateElement.h"
38	#include "KURL.h"	38	#include "URL.h"
39	#include "ProcessingInstruction.h"	39	#include "ProcessingInstruction.h"
40	#include "XLinkNames.h"	40	#include "XLinkNames.h"
41	#include "XMLNSNames.h"	41	#include "XMLNSNames.h"

Lines 37-43 void Editor::writeSelectionToPasteboard(Pasteboard&) a/Source/WebCore/editing/efl/EditorEfl.cpp_sec1
- a/Source/WebCore/editing/efl/EditorEfl.cpp -1 / +1 lines
37	notImplemented();	37	notImplemented();
38	}	38	}
39		39
40	void Editor::writeImageToPasteboard(Pasteboard&, Element&, const KURL&, const String&)	40	void Editor::writeImageToPasteboard(Pasteboard&, Element&, const URL&, const String&)
41	{	41	{
42	notImplemented();	42	notImplemented();
43	}	43	}

Lines 336-342 static void getImage(Element& imageElement, RefPtr<Image>& image, CachedImage*& a/Source/WebCore/editing/ios/EditorIOS.mm_sec1
- a/Source/WebCore/editing/ios/EditorIOS.mm -1 / +1 lines
336	cachedImage = tentativeCachedImage;	336	cachedImage = tentativeCachedImage;
337	}	337	}
338		338
339	void Editor::writeImageToPasteboard(Pasteboard& pasteboard, Element& imageElement, const KURL&, const String& title)	339	void Editor::writeImageToPasteboard(Pasteboard& pasteboard, Element& imageElement, const URL&, const String& title)
340	{	340	{
341	PasteboardImage pasteboardImage;	341	PasteboardImage pasteboardImage;
342		342



    String string = text.text;

    // FIXME: It's not clear this is 100% correct since we know -[NSURL URLWithString:] does not handle
    // all the same cases we handle well in the URL code for creating an NSURL.
    if (text.isURL)
        string = client()->userVisibleString([NSURL URLWithString:string]);


    return [(NSString *)string precomposedStringWithCanonicalMapping];
}

void Editor::writeImageToPasteboard(Pasteboard& pasteboard, Element& imageElement, const URL& url, const String& title)
{
    PasteboardImage pasteboardImage;


    virtual bool readRTFD(PassRefPtr<SharedBuffer>) override;
    virtual bool readRTF(PassRefPtr<SharedBuffer>) override;
    virtual bool readImage(PassRefPtr<SharedBuffer>, const String& type) override;
    virtual bool readURL(const URL&, const String& title) override;
    virtual bool readPlainText(const String&) override;
};


    if (!frame.document())
        return false;

    RefPtr<LegacyWebArchive> archive = LegacyWebArchive::create(URL(), buffer.get());
    if (!archive)
        return false;


    ASSERT(type.contains('/'));
    String typeAsFilenameWithExtension = type;
    typeAsFilenameWithExtension.replace('/', '.');
    URL imageURL = URL(URL(), "webkit-fake-url://" + createCanonicalUUIDString() + '/' + typeAsFilenameWithExtension);

    fragment = frame.editor().createFragmentForImageResourceAndAddResource(ArchiveResource::create(buffer, imageURL, type, emptyString(), emptyString()));
    return fragment;
}

bool Editor::WebContentReader::readURL(const URL& url, const String& title)
{
    if (url.string().isEmpty())
        return false;



#include "HTMLTableElement.h"
#include "HTMLTextAreaElement.h"
#include "HTMLTextFormControlElement.h"
#include "URL.h"
#include "MarkupAccumulator.h"
#include "Range.h"
#include "RenderBlock.h"

{
    Vector<AttributeChange> changes;

    URL parsedBaseURL(ParsedURLString, baseURL);

    for (auto element = elementDescendants(fragment).begin(), end = elementDescendants(fragment).end(); element != end; ++element) {
        if (!element->hasAttributes())

        for (unsigned i = 0; i < length; i++) {
            const Attribute& attribute = element->attributeAt(i);
            if (element->isURLAttribute(attribute) && !attribute.value().isEmpty())
                changes.append(AttributeChange(&*element, attribute.name(), URL(parsedBaseURL, attribute.value()).string()));
        }
    }


    taggedMarkup.append(markup.substring(fragmentEnd));

    RefPtr<DocumentFragment> taggedFragment = createFragmentFromMarkup(document, taggedMarkup.toString(), baseURL, parserContentPolicy);
    RefPtr<Document> taggedDocument = Document::create(0, URL());
    taggedDocument->takeAllChildrenFrom(taggedFragment.get());

    RefPtr<Node> nodeBeforeContext;

    return documentTypeString(node->document()) + createMarkup(range, 0, AnnotateForInterchange);
}

String urlToMarkup(const URL& url, const String& title)
{
    StringBuilder markup;
    markup.append("<a href=\"");



class DocumentFragment;
class Element;
class HTMLElement;
class URL;
class Node;
class QualifiedName;
class Range;

String createFullMarkup(const Node*);
String createFullMarkup(const Range*);

String urlToMarkup(const URL&, const String& title);

String documentTypeString(const Document&);




        proxy->client()->didWrite(bytesWritten);
}

void AsyncFileStream::write(const URL& blobURL, long long position, int length)
{
    fileThread()->postTask(createFileThreadTask(this, &AsyncFileStream::writeOnFileThread, blobURL, position, length));
}

void AsyncFileStream::writeOnFileThread(const URL& blobURL, long long position, int length)
{
    int bytesWritten = m_stream->write(blobURL, position, length);
    callOnMainThread(didWrite, AllowCrossThreadAccess(this), bytesWritten);




class FileStreamClient;
class FileStream;
class URL;

class AsyncFileStream : public RefCounted<AsyncFileStream> {
public:

    void openForWrite(const String& path);
    void close();
    void read(char* buffer, int length);
    void write(const URL& blobURL, long long position, int length);
    void truncate(long long position);

    // Stops the proxy and schedules it to be destructed. All the pending tasks will be aborted and the file stream will be closed.

    void openForWriteOnFileThread(const String& path);
    void closeOnFileThread();
    void readOnFileThread(char* buffer, int length);
    void writeOnFileThread(const URL& blobURL, long long position, int length);
    void truncateOnFileThread(long long position);

    RefPtr<FileStream> m_stream;




class BlobURLRegistry : public URLRegistry {
public:
    virtual void registerURL(SecurityOrigin*, const URL&, URLRegistrable*) OVERRIDE;
    virtual void unregisterURL(const URL&) OVERRIDE;

    static URLRegistry& registry();
};


void BlobURLRegistry::registerURL(SecurityOrigin* origin, const URL& publicURL, URLRegistrable* blob)
{
    ASSERT(&blob->registry() == this);
    ThreadableBlobRegistry::registerBlobURL(origin, publicURL, static_cast<Blob*>(blob)->url());
}

void BlobURLRegistry::unregisterURL(const URL& url)
{
    ThreadableBlobRegistry::unregisterBlobURL(url);
}

    ThreadableBlobRegistry::registerBlobURL(m_internalURL, blobData);
}

Blob::Blob(const URL& srcURL, const String& type, long long size)
    : m_type(Blob::normalizedContentType(type))
    , m_size(size)
{



#define Blob_h

#include "BlobData.h"
#include "URL.h"
#include "ScriptWrappable.h"
#include "URLRegistry.h"
#include <wtf/PassOwnPtr.h>

    }

    // For deserialization.
    static PassRefPtr<Blob> create(const URL& srcURL, const String& type, long long size)
    {
        ASSERT(Blob::isNormalizedContentType(type));
        return adoptRef(new Blob(srcURL, type, size));


    virtual ~Blob();

    const URL& url() const { return m_internalURL; }
    const String& type() const { return m_type; }

    virtual unsigned long long size() const { return static_cast<unsigned long long>(m_size); }

    Blob(PassOwnPtr<BlobData>, long long size);

    // For deserialization.
    Blob(const URL& srcURL, const String& type, long long size);

    // This is an internal URL referring to the blob data associated with this object. It serves
    // as an identifier for this blob. The internal URL is never used to source the blob's content
    // into an HTML or for FileRead'ing, public blob URLs must be used for those purposes.
    URL m_internalURL;

    String m_type;
    long long m_size;




#include "BlobURL.h"

#include "URL.h"
#include "SecurityOrigin.h"
#include "UUID.h"
#include <wtf/text/WTFString.h>


const char BlobURL::kBlobProtocol[] = "blob";

URL BlobURL::createPublicURL(SecurityOrigin* securityOrigin)
{
    ASSERT(securityOrigin);
    return createBlobURL(securityOrigin->toString());
}

URL BlobURL::createInternalURL()
{
    return createBlobURL("blobinternal://");
}

String BlobURL::getOrigin(const URL& url)
{
    ASSERT(url.protocolIs(kBlobProtocol));


    return url.string().substring(startIndex, endIndex - startIndex - 1);
}

String BlobURL::getIdentifier(const URL& url)
{
    ASSERT(url.protocolIs(kBlobProtocol));


    return url.string().substring(startIndex);
}

URL BlobURL::createBlobURL(const String& originString)
{
    ASSERT(!originString.isEmpty());
    String urlString = "blob:" + encodeWithURLEscapeSequences(originString) + '/' + createCanonicalUUIDString();
    return URL(ParsedURLString, urlString);
}

} // namespace WebCore



#ifndef BlobURL_h
#define BlobURL_h

#include "URL.h"

namespace WebCore {


// be used with ResourceHandle or FileReader.
class BlobURL {
public:
    static URL createPublicURL(SecurityOrigin*);
    static URL createInternalURL();
    static String getOrigin(const URL&);
    static String getIdentifier(const URL&);
    static const char* blobProtocol() { return kBlobProtocol; }

private:
    static URL createBlobURL(const String& originString);
    static const char kBlobProtocol[];
    BlobURL() { }
};



    return blobData.release();
}

static PassOwnPtr<BlobData> createBlobDataForFileSystemURL(const URL& fileSystemURL, const FileMetadata& metadata)
{
    OwnPtr<BlobData> blobData = BlobData::create();
    blobData->setContentType(getContentTypeFromFileName(fileSystemURL.path(), File::WellKnownContentTypes));

{
}

File::File(const String& path, const URL& url, const String& type)
    : Blob(url, type, -1)
    , m_path(path)
#if ENABLE(FILE_SYSTEM)

{
}

File::File(const URL& fileSystemURL, const FileMetadata& metadata)
    : Blob(createBlobDataForFileSystemURL(fileSystemURL, metadata), metadata.length)
    , m_fileSystemURL(fileSystemURL)
    , m_snapshotSize(metadata.length)



namespace WebCore {

struct FileMetadata;
class URL;

class File : public Blob {
public:

    }

    // For deserialization.
    static PassRefPtr<File> create(const String& path, const URL& srcURL, const String& type)
    {
        return adoptRef(new File(path, srcURL, type));
    }

        return adoptRef(new File(name, metadata));
    }

    static PassRefPtr<File> createForFileSystemFile(const URL& url, const FileMetadata& metadata)
    {
        return adoptRef(new File(url, metadata));
    }

    URL fileSystemURL() const { return m_fileSystemURL; }
#endif

    // Create a file with a name exposed to the author (via File.name and associated DOM properties) that differs from the one provided in the path.

    File(const String& path, ContentTypeLookupPolicy);

    // For deserialization.
    File(const String& path, const URL& srcURL, const String& type);
    File(const String& path, const String& name, ContentTypeLookupPolicy);

# if ENABLE(FILE_SYSTEM)
    File(const String& name, const FileMetadata&);
    File(const URL& fileSystemURL, const FileMetadata&);

    // Returns true if this has a valid snapshot metadata (i.e. m_snapshotSize >= 0).
    bool hasValidSnapshotMetadata() const { return m_snapshotSize >= 0; }

    String m_name;

#if ENABLE(FILE_SYSTEM)
    URL m_fileSystemURL;

    // If m_snapshotSize is negative (initialized to -1 by default), the snapshot metadata is invalid and we retrieve the latest metadata synchronously in size(), lastModifiedTime() and slice().
    // Otherwise, the snapshot metadata are used directly in those methods.



#if ENABLE(BLOB)

#include "FileError.h"
#include "URL.h"
#include "TextEncoding.h"
#include "ThreadableLoaderClient.h"
#include <wtf/Forward.h>

    TextEncoding m_encoding;
    String m_dataType;

    URL m_urlForReading;
    RefPtr<ThreadableLoader> m_loader;

    RefPtr<JSC::ArrayBuffer> m_rawData;



struct BlobRegistryContext {
    WTF_MAKE_FAST_ALLOCATED;
public:
    BlobRegistryContext(const URL& url, PassOwnPtr<BlobData> blobData)
        : url(url.copy())
        , blobData(blobData)
    {
        this->blobData->detachFromCurrentThread();
    }

    BlobRegistryContext(const URL& url, const URL& srcURL)
        : url(url.copy())
        , srcURL(srcURL.copy())
    {
    }

    BlobRegistryContext(const URL& url)
        : url(url.copy())
    {
    }

    URL url;
    URL srcURL;
    OwnPtr<BlobData> blobData;
};


    blobRegistry().registerBlobURL(blobRegistryContext->url, blobRegistryContext->blobData.release());
}

void ThreadableBlobRegistry::registerBlobURL(const URL& url, PassOwnPtr<BlobData> blobData)
{
    if (isMainThread())
        blobRegistry().registerBlobURL(url, blobData);

    blobRegistry().registerBlobURL(blobRegistryContext->url, blobRegistryContext->srcURL);
}

void ThreadableBlobRegistry::registerBlobURL(SecurityOrigin* origin, const URL& url, const URL& srcURL)
{
    // If the blob URL contains null origin, as in the context with unique security origin or file URL, save the mapping between url and origin so that the origin can be retrived when doing security origin check.
    if (origin && BlobURL::getOrigin(url) == "null")

    blobRegistry().unregisterBlobURL(blobRegistryContext->url);
}

void ThreadableBlobRegistry::unregisterBlobURL(const URL& url)
{
    if (BlobURL::getOrigin(url) == "null")
        originMap()->remove(url.string());

    }
}

PassRefPtr<SecurityOrigin> ThreadableBlobRegistry::getCachedOrigin(const URL& url)
{
    return originMap()->get(url.string());
}

#else

void ThreadableBlobRegistry::registerBlobURL(const URL&, PassOwnPtr<BlobData>)
{
}

void ThreadableBlobRegistry::registerBlobURL(SecurityOrigin*, const URL&, const URL&)
{
}

void ThreadableBlobRegistry::unregisterBlobURL(const URL&)
{
}

PassRefPtr<SecurityOrigin> ThreadableBlobRegistry::getCachedOrigin(const URL&)
{
    return 0;
}



namespace WebCore {

class BlobData;
class URL;
class SecurityOrigin;

class ThreadableBlobRegistry {
public:
    static void registerBlobURL(const URL&, PassOwnPtr<BlobData>);
    static void registerBlobURL(SecurityOrigin*, const URL&, const URL& srcURL);
    static void unregisterBlobURL(const URL&);

    // Returns the origin for the given blob URL. This is because we are not able to embed the unique security origin or the origin of file URL
    // in the blob URL.
    static PassRefPtr<SecurityOrigin> getCachedOrigin(const URL&);
};

} // namespace WebCore

Lines 239-245 void CachedFrame::clear() a/Source/WebCore/history/CachedFrame.cpp_sec1
- a/Source/WebCore/history/CachedFrame.cpp -1 / +1 lines
239	m_document = 0;	239	m_document = 0;
240	m_view = 0;	240	m_view = 0;
241	m_mousePressNode = 0;	241	m_mousePressNode = 0;
242	m_url = KURL();	242	m_url = URL();
243		243
244	m_cachedFramePlatformData.clear();	244	m_cachedFramePlatformData.clear();
245	m_cachedFrameScriptData.clear();	245	m_cachedFrameScriptData.clear();



#define CachedFrame_h

#include "DOMWindow.h"
#include "URL.h"
#include "ScriptCachedFrameData.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/RefPtr.h>


    Document* document() const { return m_document.get(); }
    FrameView* view() const { return m_view.get(); }
    const URL& url() const { return m_url; }
    bool isMainFrame() { return m_isMainFrame; }

protected:

    RefPtr<DocumentLoader> m_documentLoader;
    RefPtr<FrameView> m_view;
    RefPtr<Node> m_mousePressNode;
    URL m_url;
    OwnPtr<ScriptCachedFrameData> m_cachedFrameScriptData;
    OwnPtr<CachedFramePlatformData> m_cachedFramePlatformData;
    bool m_isMainFrame;



    iconDatabase().retainIconForPageURL(m_urlString);
}

HistoryItem::HistoryItem(const URL& url, const String& target, const String& parent, const String& title)
    : m_urlString(url.string())
    , m_originalURLString(url.string())
    , m_target(target)

    return m_lastVisitedTime;
}

URL HistoryItem::url() const
{
    return URL(ParsedURLString, m_urlString);
}

URL HistoryItem::originalURL() const
{
    return URL(ParsedURLString, m_originalURLString);
}

const String& HistoryItem::referrer() const

    notifyHistoryItemChanged(this);
}

void HistoryItem::setURL(const URL& url)
{
    pageCache()->remove(this);
    setURLString(url.string());



class FormData;
class HistoryItem;
class Image;
class URL;
class ResourceRequest;

typedef Vector<RefPtr<HistoryItem> > HistoryItemVector;

    {
        return adoptRef(new HistoryItem(urlString, title, alternateTitle, lastVisited));
    }
    static PassRefPtr<HistoryItem> create(const URL& url, const String& target, const String& parent, const String& title)
    {
        return adoptRef(new HistoryItem(url, target, parent, title));
    }

    const String& alternateTitle() const;
    
    const String& parent() const;
    URL url() const;
    URL originalURL() const;
    const String& referrer() const;
    const String& target() const;
    bool isTargetItem() const;

    void setDocumentState(const Vector<String>&);
    void clearDocumentState();

    void setURL(const URL&);
    void setURLString(const String&);
    void setOriginalURLString(const String&);
    void setReferrer(const String&);

    HistoryItem();
    HistoryItem(const String& urlString, const String& title, double lastVisited);
    HistoryItem(const String& urlString, const String& title, const String& alternateTitle, double lastVisited);
    HistoryItem(const URL& url, const String& frameName, const String& parent, const String& title);

    explicit HistoryItem(const HistoryItem&);




        return 1 << NoDocumentLoader;
    }

    URL currentURL = frame->loader().documentLoader()->url();
    URL newURL = frame->loader().provisionalDocumentLoader() ? frame->loader().provisionalDocumentLoader()->url() : URL();
    if (!newURL.isEmpty())
        PCLOG(" Determining if frame can be cached navigating from (", currentURL.string(), ") to (", newURL.string(), "):");
    else

    // Only bother logging for main frames that have actually loaded and have content.
    if (page->mainFrame().loader().stateMachine()->creatingInitialEmptyDocument())
        return;
    URL currentURL = page->mainFrame().loader().documentLoader() ? page->mainFrame().loader().documentLoader()->url() : URL();
    if (currentURL.isEmpty())
        return;
    



#include "ActiveDOMObject.h"
#include "Blob.h"
#include "BlobURL.h"
#include "URL.h"
#include "MemoryCache.h"
#include "PublicURLManager.h"
#include "ResourceRequest.h"


String DOMURL::createPublicURL(ScriptExecutionContext* scriptExecutionContext, URLRegistrable* registrable)
{
    URL publicURL = BlobURL::createPublicURL(scriptExecutionContext->securityOrigin());
    if (publicURL.isEmpty())
        return String();


    if (!scriptExecutionContext)
        return;

    URL url(URL(), urlString);
    ResourceRequest request(url);
#if ENABLE(CACHE_PARTITIONING)
    request.setCachePartition(scriptExecutionContext->topOrigin()->cachePartition());

Lines 27-33 a/Source/WebCore/html/DOMURL.h_sec1
- a/Source/WebCore/html/DOMURL.h -1 / +1 lines
27	#ifndef DOMURL_h	27	#ifndef DOMURL_h
28	#define DOMURL_h	28	#define DOMURL_h
29		29
30	#include "KURL.h"	30	#include "URL.h"
31	#include <wtf/HashSet.h>	31	#include <wtf/HashSet.h>
32	#include <wtf/PassRefPtr.h>	32	#include <wtf/PassRefPtr.h>
33	#include <wtf/RefCounted.h>	33	#include <wtf/RefCounted.h>

Lines 425-431 void FTPDirectoryDocumentParser::finish() a/Source/WebCore/html/FTPDirectoryDocument.cpp_sec1
- a/Source/WebCore/html/FTPDirectoryDocument.cpp -1 / +1 lines
425	HTMLDocumentParser::finish();	425	HTMLDocumentParser::finish();
426	}	426	}
427		427
428	FTPDirectoryDocument::FTPDirectoryDocument(Frame* frame, const KURL& url)	428	FTPDirectoryDocument::FTPDirectoryDocument(Frame* frame, const URL& url)
429	: HTMLDocument(frame, url)	429	: HTMLDocument(frame, url)
430	{	430	{
431	#if !LOG_DISABLED	431	#if !LOG_DISABLED



    
class FTPDirectoryDocument : public HTMLDocument {
public:
    static PassRefPtr<FTPDirectoryDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new FTPDirectoryDocument(frame, url));
    }

private:
    FTPDirectoryDocument(Frame*, const URL&);
    virtual PassRefPtr<DocumentParser> createParser();
};
    

Lines 328-334 static inline void recordFormStructure(const HTMLFormElement& form, StringBuilde a/Source/WebCore/html/FormController.cpp_sec1
- a/Source/WebCore/html/FormController.cpp -1 / +1 lines
328		328
329	static inline String formSignature(const HTMLFormElement& form)	329	static inline String formSignature(const HTMLFormElement& form)
330	{	330	{
331	KURL actionURL = form.getURLAttribute(actionAttr);	331	URL actionURL = form.getURLAttribute(actionAttr);
332	// Remove the query part because it might contain volatile parameters such	332	// Remove the query part because it might contain volatile parameters such
333	// as a session key.	333	// as a session key.
334	actionURL.setQuery(String());	334	actionURL.setQuery(String());



    return hasAttribute(hrefAttr);
}

URL HTMLAnchorElement::href() const
{
    return document().completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(hrefAttr)));
}


void HTMLAnchorElement::setHash(const String& value)
{
    URL url = href();
    if (value[0] == '#')
        url.setFragmentIdentifier(value.substring(1));
    else


String HTMLAnchorElement::host() const
{
    const URL& url = href();
    if (url.hostEnd() == url.pathStart())
        return url.host();
    if (isDefaultPortForProtocol(url.port(), url.protocol()))

{
    if (value.isEmpty())
        return;
    URL url = href();
    if (!url.canSetHostOrPort())
        return;


    if (i == hostLength)
        return;

    URL url = href();
    if (!url.canSetHostOrPort())
        return;



void HTMLAnchorElement::setPathname(const String& value)
{
    URL url = href();
    if (!url.canSetPathname())
        return;



void HTMLAnchorElement::setPort(const String& value)
{
    URL url = href();
    if (!url.canSetHostOrPort())
        return;



void HTMLAnchorElement::setProtocol(const String& value)
{
    URL url = href();
    url.setProtocol(value);
    setHref(url.string());
}


void HTMLAnchorElement::setSearch(const String& value)
{
    URL url = href();
    String newSearch = (value[0] == '?') ? value.substring(1) : value;
    // Make sure that '#' in the query does not leak to the hash.
    url.setQuery(newSearch.replaceWithLiteral('#', "%23"));

    return isLink() && treatLinkAsLiveForEventType(m_wasShiftKeyDownOnMouseDown ? MouseEventWithShiftKey : MouseEventWithoutShiftKey);
}

void HTMLAnchorElement::sendPings(const URL& destinationURL)
{
    if (!hasAttribute(pingAttr) || !document().settings() || !document().settings()->hyperlinkAuditingEnabled())
        return;

    StringBuilder url;
    url.append(stripLeadingAndTrailingHTMLSpaces(fastGetAttribute(hrefAttr)));
    appendServerMapMousePosition(url, event);
    URL kurl = document().completeURL(url.toString());

#if ENABLE(DOWNLOAD_ATTRIBUTE)
    if (hasAttribute(downloadAttr)) {




    virtual ~HTMLAnchorElement();

    URL href() const;
    void setHref(const AtomicString&);

    const AtomicString& name() const;

    virtual short tabIndex() const OVERRIDE FINAL;
    virtual bool draggable() const;

    void sendPings(const URL& destinationURL);

    void handleClick(Event*);




    return fastGetAttribute(targetAttr);
}

URL HTMLBaseElement::href() const
{
    // This does not use the getURLAttribute function because that will resolve relative to the document's base URL;
    // base elements like this one can be used to set that base URL. Thus we need to resolve relative to the document's

    if (attributeValue.isNull())
        return document().url();

    URL url = !document().decoder() ?
        URL(document().url(), stripLeadingAndTrailingHTMLSpaces(attributeValue)) :
        URL(document().url(), stripLeadingAndTrailingHTMLSpaces(attributeValue), document().decoder()->encoding());

    if (!url.isValid())
        return URL();

    return url;
}

Lines 31-37 class HTMLBaseElement FINAL : public HTMLElement { a/Source/WebCore/html/HTMLBaseElement.h_sec1
- a/Source/WebCore/html/HTMLBaseElement.h -1 / +1 lines
31	public:	31	public:
32	static PassRefPtr<HTMLBaseElement> create(const QualifiedName&, Document&);	32	static PassRefPtr<HTMLBaseElement> create(const QualifiedName&, Document&);
33		33
34	KURL href() const;	34	URL href() const;
35	void setHref(const AtomicString&);	35	void setHref(const AtomicString&);
36		36
37	private:	37	private:

Lines 327-333 int HTMLBodyElement::scrollWidth() a/Source/WebCore/html/HTMLBodyElement.cpp_sec1
- a/Source/WebCore/html/HTMLBodyElement.cpp -1 / +1 lines
327	return adjustForZoom(view->contentsWidth(), *frame);	327	return adjustForZoom(view->contentsWidth(), *frame);
328	}	328	}
329		329
330	void HTMLBodyElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	330	void HTMLBodyElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
331	{	331	{
332	HTMLElement::addSubresourceAttributeURLs(urls);	332	HTMLElement::addSubresourceAttributeURLs(urls);
333		333

Lines 89-95 private: a/Source/WebCore/html/HTMLBodyElement.h_sec1
- a/Source/WebCore/html/HTMLBodyElement.h -1 / +1 lines
89	virtual int scrollHeight();	89	virtual int scrollHeight();
90	virtual int scrollWidth();	90	virtual int scrollWidth();
91		91
92	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	92	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
93	};	93	};
94		94
95	} //namespace	95	} //namespace



#include "HTMLFrameSetElement.h"
#include "HTMLNames.h"
#include "InspectorInstrumentation.h"
#include "URL.h"
#include "Page.h"
#include "ScriptController.h"
#include "Settings.h"


using namespace HTMLNames;

HTMLDocument::HTMLDocument(Frame* frame, const URL& url, DocumentClassFlags documentClasses)
    : Document(frame, url, documentClasses | HTMLDocumentClass)
{
    clearXMLVersion();




class HTMLDocument : public Document, public CachedResourceClient {
public:
    static PassRefPtr<HTMLDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new HTMLDocument(frame, url));
    }

    static bool isCaseSensitiveAttribute(const QualifiedName&);

protected:
    HTMLDocument(Frame*, const URL&, DocumentClassFlags = 0);

private:
    virtual PassRefPtr<Element> createElement(const AtomicString& tagName, ExceptionCode&);

Lines 211-217 const AtomicString& HTMLEmbedElement::imageSourceURL() const a/Source/WebCore/html/HTMLEmbedElement.cpp_sec1
- a/Source/WebCore/html/HTMLEmbedElement.cpp -1 / +1 lines
211	return getAttribute(srcAttr);	211	return getAttribute(srcAttr);
212	}	212	}
213		213
214	void HTMLEmbedElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	214	void HTMLEmbedElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
215	{	215	{
216	HTMLPlugInImageElement::addSubresourceAttributeURLs(urls);	216	HTMLPlugInImageElement::addSubresourceAttributeURLs(urls);
217		217

Lines 47-53 private: a/Source/WebCore/html/HTMLEmbedElement.h_sec1
- a/Source/WebCore/html/HTMLEmbedElement.h -1 / +1 lines
47		47
48	virtual void updateWidget(PluginCreationOption);	48	virtual void updateWidget(PluginCreationOption);
49		49
50	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	50	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
51		51
52	void parametersForPlugin(Vector<String>& paramNames, Vector<String>& paramValues);	52	void parametersForPlugin(Vector<String>& paramNames, Vector<String>& paramValues);
53	};	53	};



#include "FrameView.h"
#include "HTMLNames.h"
#include "HTMLParserIdioms.h"
#include "URL.h"
#include "Page.h"
#include "RenderWidget.h"
#include "ScriptController.h"

    if (m_URL.isEmpty())
        return true;

    const URL& completeURL = document().completeURL(m_URL);

    if (protocolIsJavaScript(completeURL)) { 
        Document* contentDoc = this->contentDocument();

    }
}

URL HTMLFrameElementBase::location() const
{
    if (fastHasAttribute(srcdocAttr))
        return URL(ParsedURLString, "about:srcdoc");
    return document().completeURL(getAttribute(srcAttr));
}


Lines 31-37 namespace WebCore { a/Source/WebCore/html/HTMLFrameElementBase.h_sec1
- a/Source/WebCore/html/HTMLFrameElementBase.h -1 / +1 lines
31		31
32	class HTMLFrameElementBase : public HTMLFrameOwnerElement {	32	class HTMLFrameElementBase : public HTMLFrameOwnerElement {
33	public:	33	public:
34	KURL location() const;	34	URL location() const;
35	void setLocation(const String&);	35	void setLocation(const String&);
36		36
37	virtual ScrollbarMode scrollingMode() const { return m_scrolling; }	37	virtual ScrollbarMode scrollingMode() const { return m_scrolling; }



    setAttribute(heightAttr, String::number(value));
}

URL HTMLImageElement::src() const
{
    return document().completeURL(getAttribute(srcAttr));
}

    return m_imageLoader.imageComplete();
}

void HTMLImageElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
{
    HTMLElement::addSubresourceAttributeURLs(urls);





    void setHeight(int);

    URL src() const;
    void setSrc(const String&);

    void setWidth(int);


    virtual bool draggable() const;

    virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;

    virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
    virtual void removedFrom(ContainerNode*) OVERRIDE;



        setSize(size);
}

URL HTMLInputElement::src() const
{
    return document().completeURL(fastGetAttribute(srcAttr));
}

    HTMLTextFormControlElement::didMoveToNewDocument(oldDocument);
}

void HTMLInputElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
{
    HTMLTextFormControlElement::addSubresourceAttributeURLs(urls);




class HTMLOptionElement;
class Icon;
class InputType;
class URL;
class ListAttributeTargetObserver;
struct DateTimeChooserParameters;


    void setSize(unsigned);
    void setSize(unsigned, ExceptionCode&);

    URL src() const;

    virtual int maxLength() const;
    void setMaxLength(int, ExceptionCode&);

    virtual void documentWillSuspendForPageCache() OVERRIDE;
#endif

    virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;

    bool needsSuspensionCallback();
    void registerForSuspensionCallbackIfNeeded();



    }

    String type = m_type.lower();
    URL url = getNonEmptyURLAttribute(hrefAttr);

    if (!m_linkLoader.loadLink(m_relAttribute, type, m_sizes->toString(), url, &document()))
        return;

    HTMLElement::finishParsingChildren();
}

void HTMLLinkElement::setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet* cachedStyleSheet)
{
    if (!inDocument()) {
        ASSERT(!m_sheet);

    return attribute.name().localName() == hrefAttr || HTMLElement::isURLAttribute(attribute);
}

URL HTMLLinkElement::href() const
{
    return document().completeURL(getAttribute(hrefAttr));
}

    return m_sizes->toString();
}

void HTMLLinkElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
{
    HTMLElement::addSubresourceAttributeURLs(urls);




namespace WebCore {

class HTMLLinkElement;
class URL;

template<typename T> class EventSender;
typedef EventSender<HTMLLinkElement> LinkEventSender;

    static PassRefPtr<HTMLLinkElement> create(const QualifiedName&, Document&, bool createdByParser);
    virtual ~HTMLLinkElement();

    URL href() const;
    String rel() const;

    virtual String target() const;

    virtual void removedFrom(ContainerNode*) OVERRIDE;

    // from CachedResourceClient
    virtual void setCSSStyleSheet(const String& href, const URL& baseURL, const String& charset, const CachedCSSStyleSheet* sheet);
    virtual bool sheetLoaded();
    virtual void notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred);
    virtual void startLoadingDynamicSheet();

private:
    HTMLLinkElement(const QualifiedName&, Document&, bool createdByParser);

    virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;

    virtual void finishParsingChildren();




}
    
#if !LOG_DISABLED
static String urlForLoggingMedia(const URL& url)
{
    static const unsigned maximumURLLengthForLogging = 128;


    return m_networkState;
}

String HTMLMediaElement::canPlayType(const String& mimeType, const String& keySystem, const URL& url) const
{
    MediaPlayer::SupportsType support = MediaPlayer::supportsType(ContentType(mimeType), keySystem, url, this);
    String canPlay;

        m_loadState = LoadingFromSrcAttr;

        // If the src attribute's value is the empty string ... jump down to the failed step below
        URL mediaURL = getNonEmptyURLAttribute(srcAttr);
        if (mediaURL.isEmpty()) {
            mediaLoadingFailed(MediaPlayer::FormatError);
            LOG(Media, "HTMLMediaElement::selectMediaResource, empty 'src'");

{
    ContentType contentType((String()));
    String keySystem;
    URL mediaURL = selectNextSourceChild(&contentType, &keySystem, Complain);
    if (!mediaURL.isValid()) {
        waitForSourceChange();
        return;

    loadResource(mediaURL, contentType, keySystem);
}

static URL createFileURLForApplicationCacheResource(const String& path)
{
    // URL should have a function to create a url from a path, but it does not. This function
    // is not suitable because URL::setPath uses encodeWithURLEscapeSequences, which it notes
    // does not correctly escape '#' and '?'. This function works for our purposes because
    // app cache media files are always created with encodeForFileName(createCanonicalUUIDString()).

#if USE(CF) && PLATFORM(WIN)
    RetainPtr<CFURLRef> cfURL = adoptCF(CFURLCreateWithFileSystemPath(0, path.createCFString().get(), kCFURLWindowsPathStyle, false));
    URL url(cfURL.get());
#else
    URL url;

    url.setProtocol(ASCIILiteral("file"));
    url.setPath(path);

    return url;
}

void HTMLMediaElement::loadResource(const URL& initialURL, ContentType& contentType, const String& keySystem)
{
    ASSERT(isSafeToLoadURL(initialURL, Complain));


        return;
    }

    URL url = initialURL;
    if (!frame->loader().willLoadMediaElementURL(url)) {
        mediaLoadingFailed(MediaPlayer::FormatError);
        return;


#endif

bool HTMLMediaElement::isSafeToLoadURL(const URL& url, InvalidURLAction actionIfInvalid)
{
    if (!url.isValid()) {
        LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%s) -> FALSE because url is invalid", urlForLoggingMedia(url).utf8().data());

    m_asyncEventQueue.enqueueEvent(event.release());
}

void HTMLMediaElement::mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL)
{
    MediaKeyEventInit initializer;
    initializer.keySystem = keySystem;


#if !LOG_DISABLED
    if (trackElement->hasTagName(trackTag)) {
        URL url = trackElement->getNonEmptyURLAttribute(srcAttr);
        LOG(Media, "HTMLMediaElement::didRemoveTrack - 'src' is %s", urlForLoggingMedia(url).utf8().data());
    }
#endif

    RefPtr<HTMLSourceElement> currentSourceNode = m_currentSourceNode;
    RefPtr<Node> nextNode = m_nextChildNodeToConsider;

    URL nextURL = selectNextSourceChild(0, 0, DoNothing);

    m_currentSourceNode = currentSourceNode;
    m_nextChildNodeToConsider = nextNode;

    return nextURL.isValid();
}

URL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, String* keySystem, InvalidURLAction actionIfInvalid)
{
#if !LOG_DISABLED
    // Don't log if this was just called to find out if there are any valid <source> elements.

        if (shouldLog)
            LOG(Media, "HTMLMediaElement::selectNextSourceChild -> 0x0000, \"\"");
#endif
        return URL();
    }

    URL mediaURL;
    HTMLSourceElement* source = 0;
    String type;
    String system;

    if (shouldLog)
        LOG(Media, "HTMLMediaElement::selectNextSourceChild -> %p, %s", m_currentSourceNode.get(), canUseSourceElement ? urlForLoggingMedia(mediaURL).utf8().data() : "");
#endif
    return canUseSourceElement ? mediaURL : URL();
}

void HTMLMediaElement::sourceWasAdded(HTMLSourceElement* source)


#if !LOG_DISABLED
    if (source->hasTagName(sourceTag)) {
        URL url = source->getNonEmptyURLAttribute(srcAttr);
        LOG(Media, "HTMLMediaElement::sourceWasAdded - 'src' is %s", urlForLoggingMedia(url).utf8().data());
    }
#endif


#if !LOG_DISABLED
    if (source->hasTagName(sourceTag)) {
        URL url = source->getNonEmptyURLAttribute(srcAttr);
        LOG(Media, "HTMLMediaElement::sourceWasRemoved - 'src' is %s", urlForLoggingMedia(url).utf8().data());
    }
#endif

    m_player->setMediaPlayerProxy(proxy);
}

void HTMLMediaElement::getPluginProxyParams(URL& url, Vector<String>& names, Vector<String>& values)
{
    Ref<HTMLMediaElement> protect(*this); // selectNextSourceChild may fire 'beforeload', which can make arbitrary DOM mutations.



    if (isVideo()) {
        HTMLVideoElement* video = toHTMLVideoElement(this);
        URL posterURL = video->posterImageURL();
        if (!posterURL.isEmpty() && frame && frame->loader().willLoadMediaElementURL(posterURL)) {
            names.append(ASCIILiteral("_media_element_poster_"));
            values.append(posterURL.string());


    LOG(Media, "HTMLMediaElement::createMediaPlayerProxy");

    URL url;
    Vector<String> paramNames;
    Vector<String> paramValues;


    Vector<String> paramNames;
    Vector<String> paramValues;
    // FIXME: Rename kurl to something more sensible.
    URL kurl;

    mediaElement->getPluginProxyParams(kurl, paramNames, paramValues);
    // FIXME: What if document().frame() is 0?



class Event;
class HTMLSourceElement;
class HTMLTrackElement;
class URL;
class MediaController;
class MediaControls;
class MediaError;


// network state
    void setSrc(const String&);
    const URL& currentSrc() const { return m_currentSrc; }

    enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
    NetworkState networkState() const;


    PassRefPtr<TimeRanges> buffered() const;
    void load();
    String canPlayType(const String& mimeType, const String& keySystem = String(), const URL& = URL()) const;

// ready state
    ReadyState readyState() const;

    void setNeedWidgetUpdate(bool needWidgetUpdate) { m_needWidgetUpdate = needWidgetUpdate; }
    void deliverNotification(MediaPlayerProxyNotificationType notification);
    void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
    void getPluginProxyParams(URL& url, Vector<String>& names, Vector<String>& values);
    void createMediaPlayerProxy();
    void updateWidget(PluginCreationOption);
#endif

#endif

    enum InvalidURLAction { DoNothing, Complain };
    bool isSafeToLoadURL(const URL&, InvalidURLAction);

    const String& mediaGroup() const;
    void setMediaGroup(const String&);

#if ENABLE(ENCRYPTED_MEDIA)
    virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& keySystem, const String& sessionId) OVERRIDE;
    virtual void mediaPlayerKeyError(MediaPlayer*, const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode) OVERRIDE;
    virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL) OVERRIDE;
    virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength) OVERRIDE;
#endif


    
    // loading
    void selectMediaResource();
    void loadResource(const URL&, ContentType&, const String& keySystem);
    void scheduleNextSourceChild();
    void loadNextSourceChild();
    void userCancelledLoad();

    void waitForSourceChange();
    void prepareToPlay();

    URL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);

    void mediaLoadingFailed(MediaPlayer::NetworkState);


    NetworkState m_networkState;
    ReadyState m_readyState;
    ReadyState m_readyStateMaximum;
    URL m_currentSrc;

    RefPtr<MediaError> m_error;


Lines 466-472 bool HTMLObjectElement::containsJavaApplet() const a/Source/WebCore/html/HTMLObjectElement.cpp_sec1
- a/Source/WebCore/html/HTMLObjectElement.cpp -1 / +1 lines
466	return false;	466	return false;
467	}	467	}
468		468
469	void HTMLObjectElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	469	void HTMLObjectElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
470	{	470	{
471	HTMLPlugInImageElement::addSubresourceAttributeURLs(urls);	471	HTMLPlugInImageElement::addSubresourceAttributeURLs(urls);
472		472

Lines 82-88 private: a/Source/WebCore/html/HTMLObjectElement.h_sec1
- a/Source/WebCore/html/HTMLObjectElement.h -1 / +1 lines
82		82
83	virtual RenderWidget* renderWidgetForJSBindings() const;	83	virtual RenderWidget* renderWidgetForJSBindings() const;
84		84
85	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	85	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
86		86
87	virtual void updateWidget(PluginCreationOption);	87	virtual void updateWidget(PluginCreationOption);
88	void updateDocNamedItem();	88	void updateDocNamedItem();

Lines 66-72 bool HTMLParamElement::isURLAttribute(const Attribute& attribute) const a/Source/WebCore/html/HTMLParamElement.cpp_sec1
- a/Source/WebCore/html/HTMLParamElement.cpp -1 / +1 lines
66	return HTMLElement::isURLAttribute(attribute);	66	return HTMLElement::isURLAttribute(attribute);
67	}	67	}
68		68
69	void HTMLParamElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	69	void HTMLParamElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
70	{	70	{
71	HTMLElement::addSubresourceAttributeURLs(urls);	71	HTMLElement::addSubresourceAttributeURLs(urls);
72		72

Lines 40-46 private: a/Source/WebCore/html/HTMLParamElement.h_sec1
- a/Source/WebCore/html/HTMLParamElement.h -1 / +1 lines
40	HTMLParamElement(const QualifiedName&, Document&);	40	HTMLParamElement(const QualifiedName&, Document&);
41		41
42	virtual bool isURLAttribute(const Attribute&) const OVERRIDE;	42	virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
43	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	43	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
44	};	44	};
45		45
46	ELEMENT_TYPE_CASTS(HTMLParamElement)	46	ELEMENT_TYPE_CASTS(HTMLParamElement)



        m_serviceType = mimeTypeFromDataURL(m_url);

    if (Frame* frame = document().frame()) {
        URL completedURL = document().completeURL(m_url);
        return frame->loader().client().objectContentType(completedURL, m_serviceType, shouldPreferPlugInsForImages()) == ObjectContentImage;
    }


// depending on <param> values.
bool HTMLPlugInImageElement::allowedToLoadFrameURL(const String& url)
{
    URL completeURL = document().completeURL(url);

    if (contentFrame() && protocolIsJavaScript(completeURL)
        && !document().securityOrigin()->canAccess(contentDocument()->securityOrigin()))

bool HTMLPlugInImageElement::wouldLoadAsNetscapePlugin(const String& url, const String& serviceType)
{
    ASSERT(document().frame());
    URL completedURL;
    if (!url.isEmpty())
        completedURL = document().completeURL(url);


            HTMLPlugInElement* plugInElement = toHTMLPlugInElement(node);
            if (plugInElement->isPlugInImageElement()) {
                HTMLPlugInImageElement* plugInImageElement = toHTMLPlugInImageElement(node);
                const URL& loadedURL = plugInImageElement->loadedUrl();
                String otherMimeType = plugInImageElement->loadedMimeType();
                if (plugInOrigin == loadedURL.host() && mimeType == otherMimeType)
                    plugInList.append(plugInImageElement);

        toPluginViewBase(widget)->beginSnapshottingRunningPlugin();
}

void HTMLPlugInImageElement::subframeLoaderWillCreatePlugIn(const URL& url)
{
    LOG(Plugins, "%p Plug-in URL: %s", this, m_url.utf8().data());
    LOG(Plugins, "   Actual URL: %s", url.string().utf8().data());




    const String& serviceType() const { return m_serviceType; }
    const String& url() const { return m_url; }
    const URL& loadedUrl() const { return m_loadedUrl; }

    const String loadedMimeType() const
    {

    void restartSnapshottedPlugIn();

    // Plug-in URL might not be the same as url() with overriding parameters.
    void subframeLoaderWillCreatePlugIn(const URL& plugInURL);
    void subframeLoaderDidCreatePlugIn(const Widget*);

    void setIsPrimarySnapshottedPlugIn(bool);

    OwnPtr<HTMLImageLoader> m_imageLoader;
    String m_serviceType;
    String m_url;
    URL m_loadedUrl;

    static void updateWidgetCallback(Node*, unsigned = 0);
    virtual void didAttachRenderers() OVERRIDE;



    return fastHasAttribute(asyncAttr) || forceAsync();
}

URL HTMLScriptElement::src() const
{
    return document().completeURL(sourceAttributeValue());
}

void HTMLScriptElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
{
    HTMLElement::addSubresourceAttributeURLs(urls);




    String text() const { return scriptContent(); }
    void setText(const String&);

    URL src() const;

    void setAsync(bool);
    bool async() const;


    virtual bool isURLAttribute(const Attribute&) const OVERRIDE;

    virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;

    virtual String sourceAttributeValue() const;
    virtual String charsetAttributeValue() const;

Lines 269-275 void HTMLStyleElement::notifyLoadedSheetAndAllCriticalSubresources(bool errorOcc a/Source/WebCore/html/HTMLStyleElement.cpp_sec1
- a/Source/WebCore/html/HTMLStyleElement.cpp -1 / +1 lines
269	m_firedLoad = true;	269	m_firedLoad = true;
270	}	270	}
271		271
272	void HTMLStyleElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	272	void HTMLStyleElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
273	{	273	{
274	HTMLElement::addSubresourceAttributeURLs(urls);	274	HTMLElement::addSubresourceAttributeURLs(urls);
275		275

Lines 77-83 private: a/Source/WebCore/html/HTMLStyleElement.h_sec1
- a/Source/WebCore/html/HTMLStyleElement.h -1 / +1 lines
77	virtual void notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred);	77	virtual void notifyLoadedSheetAndAllCriticalSubresources(bool errorOccurred);
78	virtual void startLoadingDynamicSheet() { m_styleSheetOwner.startLoadingDynamicSheet(document()); }	78	virtual void startLoadingDynamicSheet() { m_styleSheetOwner.startLoadingDynamicSheet(document()); }
79		79
80	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	80	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
81		81
82	#if ENABLE(STYLE_SCOPED)	82	#if ENABLE(STYLE_SCOPED)
83	void scopedAttributeChanged(bool);	83	void scopedAttributeChanged(bool);

Lines 159-165 String HTMLTableCellElement::scope() const a/Source/WebCore/html/HTMLTableCellElement.cpp_sec1
- a/Source/WebCore/html/HTMLTableCellElement.cpp -1 / +1 lines
159	return getAttribute(scopeAttr);	159	return getAttribute(scopeAttr);
160	}	160	}
161		161
162	void HTMLTableCellElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	162	void HTMLTableCellElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
163	{	163	{
164	HTMLTablePartElement::addSubresourceAttributeURLs(urls);	164	HTMLTablePartElement::addSubresourceAttributeURLs(urls);
165		165

Lines 60-66 private: a/Source/WebCore/html/HTMLTableCellElement.h_sec1
- a/Source/WebCore/html/HTMLTableCellElement.h -1 / +1 lines
60		60
61	virtual bool isURLAttribute(const Attribute&) const OVERRIDE;	61	virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
62		62
63	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	63	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
64	};	64	};
65		65
66	HTMLTableCellElement* toHTMLTableCellElement(Node* node);	66	HTMLTableCellElement* toHTMLTableCellElement(Node* node);

Lines 570-576 String HTMLTableElement::summary() const a/Source/WebCore/html/HTMLTableElement.cpp_sec1
- a/Source/WebCore/html/HTMLTableElement.cpp -1 / +1 lines
570	return getAttribute(summaryAttr);	570	return getAttribute(summaryAttr);
571	}	571	}
572		572
573	void HTMLTableElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	573	void HTMLTableElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
574	{	574	{
575	HTMLElement::addSubresourceAttributeURLs(urls);	575	HTMLElement::addSubresourceAttributeURLs(urls);
576		576

Lines 79-85 private: a/Source/WebCore/html/HTMLTableElement.h_sec1
- a/Source/WebCore/html/HTMLTableElement.h -1 / +1 lines
79	// Used to obtain either a solid or outset border decl and to deal with the frame and rules attributes.	79	// Used to obtain either a solid or outset border decl and to deal with the frame and rules attributes.
80	virtual const StylePropertySet* additionalPresentationAttributeStyle() OVERRIDE;	80	virtual const StylePropertySet* additionalPresentationAttributeStyle() OVERRIDE;
81		81
82	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	82	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
83		83
84	enum TableRules { UnsetRules, NoneRules, GroupsRules, RowsRules, ColsRules, AllRules };	84	enum TableRules { UnsetRules, NoneRules, GroupsRules, RowsRules, ColsRules, AllRules };
85	enum CellBorders { NoBorders, SolidBorders, InsetBorders, SolidBordersColsOnly, SolidBordersRowsOnly };	85	enum CellBorders { NoBorders, SolidBorders, InsetBorders, SolidBordersColsOnly, SolidBordersRowsOnly };



using namespace HTMLNames;

#if !LOG_DISABLED
static String urlForLoggingTrack(const URL& url)
{
    static const unsigned maximumURLLengthForLogging = 128;
    

    HTMLElement::parseAttribute(name, value);
}

URL HTMLTrackElement::src() const
{
    return document().completeURL(getAttribute(srcAttr));
}

    setReadyState(HTMLTrackElement::LOADING);

    // 7. Let URL be the track URL of the track element.
    URL url = getNonEmptyURLAttribute(srcAttr);

    // 8. If the track element's parent is a media element then let CORS mode be the state of the parent media
    // element's crossorigin content attribute. Otherwise, let CORS mode be No CORS.

    ensureTrack().scheduleLoad(url);
}

bool HTMLTrackElement::canLoadUrl(const URL& url)
{
    if (!RuntimeEnabledFeatures::sharedFeatures().webkitVideoTrackEnabled())
        return false;



public:
    static PassRefPtr<HTMLTrackElement> create(const QualifiedName&, Document&);

    URL src() const;
    void setSrc(const String&);

    String kind();

    virtual void textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue>);

    LoadableTextTrack& ensureTrack();
    virtual bool canLoadUrl(const URL&);

    RefPtr<LoadableTextTrack> m_track;
    Timer<HTMLTrackElement> m_loadTimer;



void HTMLVideoElement::setDisplayMode(DisplayMode mode)
{
    DisplayMode oldMode = displayMode();
    URL poster = posterImageURL();

    if (!poster.isEmpty()) {
        // We have a poster path, but only show it until the user triggers display by playing or seeking and the

}
#endif

URL HTMLVideoElement::posterImageURL() const
{
    String url = stripLeadingAndTrailingHTMLSpaces(imageSourceURL());
    if (url.isEmpty())
        return URL();
    return document().completeURL(url);
}


Lines 69-75 public: a/Source/WebCore/html/HTMLVideoElement.h_sec1
- a/Source/WebCore/html/HTMLVideoElement.h -1 / +1 lines
69		69
70	bool shouldDisplayPosterImage() const { return displayMode() == Poster \|\| displayMode() == PosterWaitingForVideo; }	70	bool shouldDisplayPosterImage() const { return displayMode() == Poster \|\| displayMode() == PosterWaitingForVideo; }
71		71
72	KURL posterImageURL() const;	72	URL posterImageURL() const;
73		73
74	private:	74	private:
75	HTMLVideoElement(const QualifiedName&, Document&, bool);	75	HTMLVideoElement(const QualifiedName&, Document&, bool);

Lines 49-55 namespace WebCore { a/Source/WebCore/html/HTMLViewSourceDocument.cpp_sec1
- a/Source/WebCore/html/HTMLViewSourceDocument.cpp -1 / +1 lines
49		49
50	using namespace HTMLNames;	50	using namespace HTMLNames;
51		51
52	HTMLViewSourceDocument::HTMLViewSourceDocument(Frame* frame, const KURL& url, const String& mimeType)	52	HTMLViewSourceDocument::HTMLViewSourceDocument(Frame* frame, const URL& url, const String& mimeType)
53	: HTMLDocument(frame, url)	53	: HTMLDocument(frame, url)
54	, m_type(mimeType)	54	, m_type(mimeType)
55	{	55	{




class HTMLViewSourceDocument FINAL : public HTMLDocument {
public:
    static PassRefPtr<HTMLViewSourceDocument> create(Frame* frame, const URL& url, const String& mimeType)
    {
        return adoptRef(new HTMLViewSourceDocument(frame, url, mimeType));
    }

    void addSource(const String&, HTMLToken&);

private:
    HTMLViewSourceDocument(Frame*, const URL&, const String& mimeType);

    // Returns HTMLViewSourceParser or TextDocumentParser based on m_type.
    virtual PassRefPtr<DocumentParser> createParser();

Lines 177-183 void ImageDocumentParser::finish() a/Source/WebCore/html/ImageDocument.cpp_sec1
- a/Source/WebCore/html/ImageDocument.cpp -1 / +1 lines
177		177
178	// --------	178	// --------
179		179
180	ImageDocument::ImageDocument(Frame* frame, const KURL& url)	180	ImageDocument::ImageDocument(Frame* frame, const URL& url)
181	: HTMLDocument(frame, url, ImageDocumentClass)	181	: HTMLDocument(frame, url, ImageDocumentClass)
182	, m_imageElement(0)	182	, m_imageElement(0)
183	, m_imageSizeIsKnown(false)	183	, m_imageSizeIsKnown(false)




class ImageDocument FINAL : public HTMLDocument {
public:
    static PassRefPtr<ImageDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new ImageDocument(frame, url));
    }

    void imageClicked(int x, int y);

private:
    ImageDocument(Frame*, const URL&);

    virtual PassRefPtr<DocumentParser> createParser();
    

Lines 118-124 void MediaDocumentParser::appendBytes(DocumentWriter, const char, size_t) a/Source/WebCore/html/MediaDocument.cpp_sec1
- a/Source/WebCore/html/MediaDocument.cpp -1 / +1 lines
118	finish();	118	finish();
119	}	119	}
120		120
121	MediaDocument::MediaDocument(Frame* frame, const KURL& url)	121	MediaDocument::MediaDocument(Frame* frame, const URL& url)
122	: HTMLDocument(frame, url, MediaDocumentClass)	122	: HTMLDocument(frame, url, MediaDocumentClass)
123	, m_replaceMediaElementTimer(this, &MediaDocument::replaceMediaElementTimerFired)	123	, m_replaceMediaElementTimer(this, &MediaDocument::replaceMediaElementTimerFired)
124	{	124	{




class MediaDocument FINAL : public HTMLDocument {
public:
    static PassRefPtr<MediaDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new MediaDocument(frame, url));
    }

    void mediaElementSawUnsupportedTracks();

private:
    MediaDocument(Frame*, const URL&);

    virtual PassRefPtr<DocumentParser> createParser();


Lines 75-81 double MediaFragmentURIParser::invalidTimeValue() a/Source/WebCore/html/MediaFragmentURIParser.cpp_sec1
- a/Source/WebCore/html/MediaFragmentURIParser.cpp -1 / +1 lines
75	return MediaPlayer::invalidTime();	75	return MediaPlayer::invalidTime();
76	}	76	}
77		77
78	MediaFragmentURIParser::MediaFragmentURIParser(const KURL& url)	78	MediaFragmentURIParser::MediaFragmentURIParser(const URL& url)
79	: m_url(url)	79	: m_url(url)
80	, m_timeFormat(None)	80	, m_timeFormat(None)
81	, m_startTime(MediaPlayer::invalidTime())	81	, m_startTime(MediaPlayer::invalidTime())




#if ENABLE(VIDEO)

#include "URL.h"
#include <wtf/Vector.h>

namespace WebCore {

class URL;

class MediaFragmentURIParser FINAL {
public:
    
    MediaFragmentURIParser(const URL&);

    double startTime();
    double endTime();

    bool parseNPTFragment(const LChar*, unsigned length, double& startTime, double& endTime);
    bool parseNPTTime(const LChar*, unsigned length, unsigned& offset, double& time);

    URL m_url;
    TimeFormat m_timeFormat;
    double m_startTime;
    double m_endTime;

Lines 131-137 void PluginDocumentParser::appendBytes(DocumentWriter, const char, size_t) a/Source/WebCore/html/PluginDocument.cpp_sec1
- a/Source/WebCore/html/PluginDocument.cpp -1 / +1 lines
131	}	131	}
132	}	132	}
133		133
134	PluginDocument::PluginDocument(Frame* frame, const KURL& url)	134	PluginDocument::PluginDocument(Frame* frame, const URL& url)
135	: HTMLDocument(frame, url, PluginDocumentClass)	135	: HTMLDocument(frame, url, PluginDocumentClass)
136	, m_shouldLoadPluginManually(true)	136	, m_shouldLoadPluginManually(true)
137	{	137	{




class PluginDocument FINAL : public HTMLDocument {
public:
    static PassRefPtr<PluginDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new PluginDocument(frame, url));
    }

    bool shouldLoadPluginManually() { return m_shouldLoadPluginManually; }

private:
    PluginDocument(Frame*, const URL&);

    virtual PassRefPtr<DocumentParser> createParser() OVERRIDE;





#if ENABLE(BLOB)

#include "URL.h"
#include "URLRegistry.h"
#include <wtf/text/StringHash.h>

namespace WebCore {

void PublicURLManager::registerURL(SecurityOrigin* origin, const URL& url, URLRegistrable* registrable)
{
    RegistryURLMap::iterator found = m_registryToURL.add(&registrable->registry(), URLSet()).iterator;
    found->key->registerURL(origin, url, registrable);
    found->value.add(url.string());
}

void PublicURLManager::revoke(const URL& url)
{
    for (RegistryURLMap::iterator i = m_registryToURL.begin(); i != m_registryToURL.end(); ++i) {
        if (i->value.contains(url.string())) {

{
    for (RegistryURLMap::iterator i = m_registryToURL.begin(); i != m_registryToURL.end(); ++i) {
        for (URLSet::iterator j = i->value.begin(); j != i->value.end(); ++j)
            i->key->unregisterURL(URL(ParsedURLString, *j));
    }

    m_registryToURL.clear();




namespace WebCore {

class URL;
class ScriptExecutionContext;
class SecurityOrigin;
class URLRegistry;

public:
    static OwnPtr<PublicURLManager> create() { return adoptPtr(new PublicURLManager); }

    void registerURL(SecurityOrigin*, const URL&, URLRegistrable*);
    void revoke(const URL&);
    void contextDestroyed();

private:

Lines 29-35 a/Source/WebCore/html/TextDocument.cpp_sec1
- a/Source/WebCore/html/TextDocument.cpp -1 / +1 lines
29		29
30	namespace WebCore {	30	namespace WebCore {
31		31
32	TextDocument::TextDocument(Frame* frame, const KURL& url)	32	TextDocument::TextDocument(Frame* frame, const URL& url)
33	: HTMLDocument(frame, url)	33	: HTMLDocument(frame, url)
34	{	34	{
35	setCompatibilityMode(QuirksMode);	35	setCompatibilityMode(QuirksMode);




class TextDocument FINAL : public HTMLDocument {
public:
    static PassRefPtr<TextDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new TextDocument(frame, url));
    }

private:
    TextDocument(Frame*, const URL&);
    
    virtual PassRefPtr<DocumentParser> createParser();
};



#include "HTMLInputElement.h"
#include "InputTypeNames.h"
#include "LocalizedStrings.h"
#include "URL.h"
#include <wtf/PassOwnPtr.h>

namespace WebCore {


bool URLInputType::typeMismatchFor(const String& value) const
{
    return !value.isEmpty() && !URL(URL(), value).isValid();
}

bool URLInputType::typeMismatch() const




namespace WebCore {

class URL;
class SecurityOrigin;
class URLRegistry;


    WTF_MAKE_FAST_ALLOCATED;
public:
    virtual ~URLRegistry() { }
    virtual void registerURL(SecurityOrigin*, const URL&, URLRegistrable*) = 0;
    virtual void unregisterURL(const URL&) = 0;

    // This is an optional API
    virtual URLRegistrable* lookup(const String&) { ASSERT_NOT_REACHED(); return 0; }



#include "HTMLImageElement.h"
#include "HTMLVideoElement.h"
#include "Image.h"
#include "URL.h"
#include "SecurityOrigin.h"

namespace WebCore {

    return false;
}

bool CanvasRenderingContext::wouldTaintOrigin(const URL& url)
{
    if (!canvas()->originClean() || m_cleanURLs.contains(url.string()))
        return false;

    return false;
}

void CanvasRenderingContext::checkOrigin(const URL& url)
{
    if (wouldTaintOrigin(url))
        canvas()->setOriginTainted();



class HTMLCanvasElement;
class HTMLImageElement;
class HTMLVideoElement;
class URL;
class WebGLObject;

class CanvasRenderingContext : public ScriptWrappable {

    bool wouldTaintOrigin(const HTMLCanvasElement*);
    bool wouldTaintOrigin(const HTMLImageElement*);
    bool wouldTaintOrigin(const HTMLVideoElement*);
    bool wouldTaintOrigin(const URL&);

    template<class T> void checkOrigin(const T* arg)
    {
        if (wouldTaintOrigin(arg))
            canvas()->setOriginTainted();
    }
    void checkOrigin(const URL&);

private:
    HTMLCanvasElement* m_canvas;

Lines 5559-5565 bool WebGLRenderingContext::validateHTMLImageElement(const char* functionName, H a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp_sec1
- a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp -1 / +1 lines
5559	synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no image");	5559	synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no image");
5560	return false;	5560	return false;
5561	}	5561	}
5562	const KURL& url = image->cachedImage()->response().url();	5562	const URL& url = image->cachedImage()->response().url();
5563	if (url.isNull() \|\| url.isEmpty() \|\| !url.isValid()) {	5563	if (url.isNull() \|\| url.isEmpty() \|\| !url.isValid()) {
5564	synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid image");	5564	synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid image");
5565	return false;	5565	return false;

Lines 222-228 void CSSPreloadScanner::emitRule() a/Source/WebCore/html/parser/CSSPreloadScanner.cpp_sec1
- a/Source/WebCore/html/parser/CSSPreloadScanner.cpp -1 / +1 lines
222	if (ruleEqualIgnoringCase(m_rule, "import")) {	222	if (ruleEqualIgnoringCase(m_rule, "import")) {
223	String url = parseCSSStringOrURL(m_ruleValue.data(), m_ruleValue.size());	223	String url = parseCSSStringOrURL(m_ruleValue.data(), m_ruleValue.size());
224	if (!url.isEmpty()) {	224	if (!url.isEmpty()) {
225	KURL baseElementURL; // FIXME: This should be passed in from the HTMLPreloadScaner via scan()!	225	URL baseElementURL; // FIXME: This should be passed in from the HTMLPreloadScaner via scan()!
226	OwnPtr<PreloadRequest> request = PreloadRequest::create("css", url, baseElementURL, CachedResource::CSSStyleSheet);	226	OwnPtr<PreloadRequest> request = PreloadRequest::create("css", url, baseElementURL, CachedResource::CSSStyleSheet);
227	// FIXME: Should this be including the charset in the preload request?	227	// FIXME: Should this be including the charset in the preload request?
228	m_requests->append(request.release());	228	m_requests->append(request.release());

Lines 27-33 a/Source/WebCore/html/parser/HTMLParserIdioms.cpp_sec1
- a/Source/WebCore/html/parser/HTMLParserIdioms.cpp -1 / +1 lines
27		27
28	#include "Decimal.h"	28	#include "Decimal.h"
29	#include "HTMLIdentifier.h"	29	#include "HTMLIdentifier.h"
30	#include "KURL.h"	30	#include "URL.h"
31	#include "QualifiedName.h"	31	#include "QualifiedName.h"
32	#include <limits>	32	#include <limits>
33	#include <wtf/MathExtras.h>	33	#include <wtf/MathExtras.h>



    }
#endif

    OwnPtr<PreloadRequest> createPreloadRequest(const URL& predictedBaseURL)
    {
        if (!shouldPreload())
            return nullptr;

    float m_deviceScaleFactor;
};

TokenPreloadScanner::TokenPreloadScanner(const URL& documentURL, float deviceScaleFactor)
    : m_documentURL(documentURL)
    , m_inStyle(false)
    , m_deviceScaleFactor(deviceScaleFactor)

{
    ASSERT(m_predictedBaseElementURL.isEmpty());
    if (const typename Token::Attribute* hrefAttribute = token.getAttributeItem(hrefAttr))
        m_predictedBaseElementURL = URL(m_documentURL, stripLeadingAndTrailingHTMLSpaces(hrefAttribute->value)).copy();
}

HTMLPreloadScanner::HTMLPreloadScanner(const HTMLParserOptions& options, const URL& documentURL, float deviceScaleFactor)
    : m_scanner(documentURL, deviceScaleFactor)
    , m_tokenizer(HTMLTokenizer::create(options))
{

    m_source.append(source);
}

void HTMLPreloadScanner::scan(HTMLResourcePreloader* preloader, const URL& startingBaseElementURL)
{
    ASSERT(isMainThread()); // HTMLTokenizer::updateStateFor only works on the main thread.




class TokenPreloadScanner {
    WTF_MAKE_NONCOPYABLE(TokenPreloadScanner); WTF_MAKE_FAST_ALLOCATED;
public:
    explicit TokenPreloadScanner(const URL& documentURL, float deviceScaleFactor = 1.0);
    ~TokenPreloadScanner();

    void scan(const HTMLToken&, PreloadRequestStream& requests);

    void scan(const CompactHTMLToken&, PreloadRequestStream& requests);
#endif

    void setPredictedBaseElementURL(const URL& url) { m_predictedBaseElementURL = url; }

    // A TokenPreloadScannerCheckpoint is valid until the next call to rewindTo,
    // at which point all outstanding checkpoints are invalidated.

    void updatePredictedBaseURL(const Token&);

    struct Checkpoint {
        Checkpoint(const URL& predictedBaseElementURL, bool inStyle
#if ENABLE(TEMPLATE_ELEMENT)
            , size_t templateCount
#endif

        {
        }

        URL predictedBaseElementURL;
        bool inStyle;
#if ENABLE(TEMPLATE_ELEMENT)
        size_t templateCount;

    };

    CSSPreloadScanner m_cssScanner;
    const URL m_documentURL;
    URL m_predictedBaseElementURL;
    bool m_inStyle;
    float m_deviceScaleFactor;


class HTMLPreloadScanner {
    WTF_MAKE_NONCOPYABLE(HTMLPreloadScanner); WTF_MAKE_FAST_ALLOCATED;
public:
    HTMLPreloadScanner(const HTMLParserOptions&, const URL& documentURL, float deviceScaleFactor = 1.0);
    ~HTMLPreloadScanner();

    void appendToEnd(const SegmentedString&);
    void scan(HTMLResourcePreloader*, const URL& documentBaseElementURL);

private:
    TokenPreloadScanner m_scanner;

Lines 45-51 bool PreloadRequest::isSafeToSendToAnotherThread() const a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp_sec1
- a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp -1 / +1 lines
45	&& m_baseURL.isSafeToSendToAnotherThread();	45	&& m_baseURL.isSafeToSendToAnotherThread();
46	}	46	}
47		47
48	KURL PreloadRequest::completeURL(Document* document)	48	URL PreloadRequest::completeURL(Document* document)
49	{	49	{
50	return document->completeURL(m_resourceURL, m_baseURL.isEmpty() ? document->url() : m_baseURL);	50	return document->completeURL(m_resourceURL, m_baseURL.isEmpty() ? document->url() : m_baseURL);
51	}	51	}




class PreloadRequest {
public:
    static OwnPtr<PreloadRequest> create(const String& initiator, const String& resourceURL, const URL& baseURL, CachedResource::Type resourceType, const String& mediaAttribute)
    {
        return adoptPtr(new PreloadRequest(initiator, resourceURL, baseURL, resourceType, mediaAttribute));
    }

    static OwnPtr<PreloadRequest> create(const String& initiator, const String& resourceURL, const URL& baseURL, CachedResource::Type resourceType)
    {
        return adoptPtr(new PreloadRequest(initiator, resourceURL, baseURL, resourceType, String()));
    }

    CachedResource::Type resourceType() const { return m_resourceType; }

private:
    PreloadRequest(const String& initiator, const String& resourceURL, const URL& baseURL, CachedResource::Type resourceType, const String& mediaAttribute)
        : m_initiator(initiator)
        , m_resourceURL(resourceURL.isolatedCopy())
        , m_baseURL(baseURL.copy())

    {
    }

    URL completeURL(Document*);

    String m_initiator;
    String m_resourceURL;
    URL m_baseURL;
    String m_charset;
    CachedResource::Type m_resourceType;
    String m_mediaAttribute;



    m_document = 0;
}

static URL documentURLForScriptExecution(Document* document)
{
    if (!document || !document->frame())
        return URL();

    // Use the URL of the currently active document for this frame.
    return document->frame()->document()->url();



#include "HTMLParamElement.h"
#include "HTMLParserIdioms.h"
#include "InspectorValues.h"
#include "URL.h"
#include "Settings.h"
#include "TextEncoding.h"
#include "TextResourceDecoder.h"


static inline String decodeStandardURLEscapeSequences(const String& string, const TextEncoding& encoding)
{
    // We use decodeEscapeSequences() instead of decodeURLEscapeSequences() (declared in URL.h) to
    // avoid platform-specific URL decoding differences (e.g. URLGoogle).
    return decodeEscapeSequences<URLEscapeSequence>(string, encoding);
}


        String errorDetails;
        unsigned errorPosition = 0;
        String reportURL;
        URL xssProtectionReportURL;

        // Process the X-XSS-Protection header, then mix in the CSP header's value.
        ContentSecurityPolicy::ReflectedXSSDisposition xssProtectionHeader = parseXSSProtectionHeader(headerValue, errorDetails, errorPosition, reportURL);

            if (MixedContentChecker::isMixedContent(document->securityOrigin(), xssProtectionReportURL)) {
                errorDetails = "insecure reporting URL for secure page";
                xssProtectionHeader = ContentSecurityPolicy::ReflectedXSSInvalid;
                xssProtectionReportURL = URL();
            }
        }
        if (xssProtectionHeader == ContentSecurityPolicy::ReflectedXSSInvalid)

    if (m_documentURL.host().isEmpty())
        return false;

    URL resourceURL(m_documentURL, url);
    return (m_documentURL.host() == resourceURL.host() && resourceURL.query().isEmpty());
}





#include "HTMLToken.h"
#include "HTTPParsers.h"
#include "URL.h"
#include "SuffixTree.h"
#include "TextEncoding.h"
#include <wtf/PassOwnPtr.h>

    bool isContainedInRequest(const String&);
    bool isLikelySafeResource(const String& url);

    URL m_documentURL;
    bool m_isEnabled;

    ContentSecurityPolicy::ReflectedXSSDisposition m_xssProtection;



#ifndef XSSAuditorDelegate_h
#define XSSAuditorDelegate_h

#include "URL.h"
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/Vector.h>

    explicit XSSAuditorDelegate(Document*);

    void didBlockScript(const XSSInfo&);
    void setReportURL(const URL& url) { m_reportURL = url; }

private:
    PassRefPtr<FormData> generateViolationReport();

    Document* m_document;
    bool m_didSendNotifications;
    URL m_reportURL;
};

typedef Vector<OwnPtr<XSSInfo> > XSSInfoStream;

Lines 54-60 void LoadableTextTrack::clearClient() a/Source/WebCore/html/track/LoadableTextTrack.cpp_sec1
- a/Source/WebCore/html/track/LoadableTextTrack.cpp -1 / +1 lines
54	TextTrack::clearClient();	54	TextTrack::clearClient();
55	}	55	}
56		56
57	void LoadableTextTrack::scheduleLoad(const KURL& url)	57	void LoadableTextTrack::scheduleLoad(const URL& url)
58	{	58	{
59	if (url == m_url)	59	if (url == m_url)
60	return;	60	return;



public:
    virtual ~LoadableTextTrackClient() { }
    
    virtual bool canLoadUrl(LoadableTextTrack*, const URL&) { return false; }
    virtual void loadingCompleted(LoadableTextTrack*, bool /* loadingFailed */) { }
};


    }
    virtual ~LoadableTextTrack();

    void scheduleLoad(const URL&);

    virtual void clearClient();


    HTMLTrackElement* m_trackElement;
    Timer<LoadableTextTrack> m_loadTimer;
    OwnPtr<TextTrackLoader> m_loader;
    URL m_url;
    bool m_isDefault;
};
} // namespace WebCore



{
    RefPtr<Document> newDocument;
    if (m_document->isHTMLDocument())
        newDocument = HTMLDocument::create(0, URL());
    else if (m_document->isXHTMLDocument())
        newDocument = HTMLDocument::createXHTML(0, URL());
#if ENABLE(SVG)
    else if (m_document->isSVGDocument())
        newDocument = Document::create(0, URL());
#endif

    ASSERT(newDocument);



    m_injectedScriptManager->injectedScriptHost()->clearInspectedObjects();
}

bool InspectorAgent::isMainResourceLoader(DocumentLoader* loader, const URL& requestUrl)
{
    return m_inspectedPage->frameIsMainFrame(loader->frame()) && requestUrl == loader->requestURL();
}

    m_pendingInspectData.second = hints;
}

URL InspectorAgent::inspectedURL() const
{
    return m_inspectedPage->mainFrame().document()->url();
}

URL InspectorAgent::inspectedURLWithoutFragment() const
{
    URL url = inspectedURL();
    url.removeFragmentIdentifier();
    return url;
}



class InspectorFrontend;
class InspectorObject;
class InstrumentingAgents;
class URL;
class Page;

typedef String ErrorString;

    void enable(ErrorString*);
    void disable(ErrorString*);

    URL inspectedURL() const;
    URL inspectedURLWithoutFragment() const;

    InspectorFrontend* frontend() const { return m_frontend; }


    void toggleRecordButton(bool);
#endif

    bool isMainResourceLoader(DocumentLoader*, const URL& requestUrl);

    Page* m_inspectedPage;
    InspectorFrontend* m_frontend;

Lines 683-689 String InspectorDebuggerAgent::sourceMapURLForScript(const Script& script) a/Source/WebCore/inspector/InspectorDebuggerAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorDebuggerAgent.cpp -1 / +1 lines
683		683
684	if (!script.url.isEmpty()) {	684	if (!script.url.isEmpty()) {
685	if (InspectorPageAgent* pageAgent = m_instrumentingAgents->inspectorPageAgent()) {	685	if (InspectorPageAgent* pageAgent = m_instrumentingAgents->inspectorPageAgent()) {
686	CachedResource* resource = pageAgent->cachedResource(pageAgent->mainFrame(), KURL(ParsedURLString, script.url));	686	CachedResource* resource = pageAgent->cachedResource(pageAgent->mainFrame(), URL(ParsedURLString, script.url));
687	if (resource) {	687	if (resource) {
688	String sourceMapHeader = resource->response().httpHeaderField(sourceMapHTTPHeader);	688	String sourceMapHeader = resource->response().httpHeaderField(sourceMapHTTPHeader);
689	if (!sourceMapHeader.isEmpty())	689	if (!sourceMapHeader.isEmpty())



#include "InspectorPageAgent.h"
#include "InspectorState.h"
#include "InstrumentingAgents.h"
#include "URL.h"
#include "LocalFileSystem.h"
#include "MIMETypeRegistry.h"
#include "Metadata.h"

    void readDirectoryEntries();

    RefPtr<RequestDirectoryContentCallback> m_requestCallback;
    URL m_url;
    RefPtr<Array<TypeBuilder::FileSystem::Entry> > m_entries;
    RefPtr<DirectoryReader> m_directoryReader;
};

        , m_url(ParsedURLString, url) { }

    RefPtr<RequestMetadataCallback> m_requestCallback;
    URL m_url;
    String m_path;
    bool m_isDirectory;
};

        , m_charset(charset) { }

    RefPtr<RequestFileContentCallback> m_requestCallback;
    URL m_url;
    bool m_readAsText;
    int m_start;
    long long m_end;


class DeleteEntryRequest : public VoidCallback {
public:
    static PassRefPtr<DeleteEntryRequest> create(PassRefPtr<DeleteEntryCallback> requestCallback, const URL& url)
    {
        return adoptRef(new DeleteEntryRequest(requestCallback, url));
    }

        m_requestCallback->sendSuccess(static_cast<int>(errorCode));
    }

    DeleteEntryRequest(PassRefPtr<DeleteEntryCallback> requestCallback, const URL& url)
        : m_requestCallback(requestCallback)
        , m_url(url) { }

    RefPtr<DeleteEntryCallback> m_requestCallback;
    URL m_url;
};

void DeleteEntryRequest::start(ScriptExecutionContext* scriptExecutionContext)

    if (!assertEnabled(error))
        return;

    URL url(ParsedURLString, urlString);

    ScriptExecutionContext* scriptExecutionContext = assertScriptExecutionContextForOrigin(error, SecurityOrigin::create(url).get());
    if (!scriptExecutionContext)

Lines 322-328 void InspectorFrontendHost::removeFileSystem(const String& fileSystemPath) a/Source/WebCore/inspector/InspectorFrontendHost.cpp_sec1
- a/Source/WebCore/inspector/InspectorFrontendHost.cpp -1 / +1 lines
322	PassRefPtr<DOMFileSystem> InspectorFrontendHost::isolatedFileSystem(const String& fileSystemName, const String& rootURL)	322	PassRefPtr<DOMFileSystem> InspectorFrontendHost::isolatedFileSystem(const String& fileSystemName, const String& rootURL)
323	{	323	{
324	ScriptExecutionContext* context = m_frontendPage->mainFrame().document();	324	ScriptExecutionContext* context = m_frontendPage->mainFrame().document();
325	return DOMFileSystem::create(context, fileSystemName, FileSystemTypeIsolated, KURL(ParsedURLString, rootURL), AsyncFileSystem::create());	325	return DOMFileSystem::create(context, fileSystemName, FileSystemTypeIsolated, URL(ParsedURLString, rootURL), AsyncFileSystem::create());
326	}	326	}
327	#endif	327	#endif
328		328



        resourceAgent->documentThreadableLoaderStartedLoadingForClient(identifier, client);
}

void InspectorInstrumentation::willLoadXHRImpl(InstrumentingAgents* instrumentingAgents, ThreadableLoaderClient* client, const String& method, const URL& url, bool async, PassRefPtr<FormData> formData, const HTTPHeaderMap& headers, bool includeCredentials)
{
    if (InspectorResourceAgent* resourceAgent = instrumentingAgents->inspectorResourceAgent())
        resourceAgent->willLoadXHR(client, method, url, async, formData, headers, includeCredentials);

    return false;
}

void InspectorInstrumentation::didStartWorkerGlobalScopeImpl(InstrumentingAgents* instrumentingAgents, WorkerGlobalScopeProxy* workerGlobalScopeProxy, const URL& url)
{
    if (InspectorWorkerAgent* workerAgent = instrumentingAgents->inspectorWorkerAgent())
        workerAgent->didStartWorkerGlobalScope(workerGlobalScopeProxy, url);

#endif

#if ENABLE(WEB_SOCKETS)
void InspectorInstrumentation::didCreateWebSocketImpl(InstrumentingAgents* instrumentingAgents, unsigned long identifier, const URL& requestURL, const URL&, const String& protocol, Document* document)
{
    InspectorAgent* inspectorAgent = instrumentingAgents->inspectorAgent();
    if (!inspectorAgent || !inspectorAgent->developerExtrasEnabled())



class InspectorInstrumentation;
class InspectorTimelineAgent;
class InstrumentingAgents;
class URL;
class Node;
class PseudoElement;
class RenderLayer;

    static void didFinishLoading(Frame*, DocumentLoader*, unsigned long identifier, double finishTime);
    static void didFailLoading(Frame*, DocumentLoader*, unsigned long identifier, const ResourceError&);
    static void documentThreadableLoaderStartedLoadingForClient(ScriptExecutionContext*, unsigned long identifier, ThreadableLoaderClient*);
    static void willLoadXHR(ScriptExecutionContext*, ThreadableLoaderClient*, const String&, const URL&, bool, PassRefPtr<FormData>, const HTTPHeaderMap&, bool);
    static void didFailXHRLoading(ScriptExecutionContext*, ThreadableLoaderClient*);
    static void didFinishXHRLoading(ScriptExecutionContext*, ThreadableLoaderClient*, unsigned long identifier, const String& sourceString, const String& url, const String& sendURL, unsigned sendLineNumber);
    static void didReceiveXHRResponse(ScriptExecutionContext*, unsigned long identifier);


#if ENABLE(WORKERS)
    static bool shouldPauseDedicatedWorkerOnStart(ScriptExecutionContext*);
    static void didStartWorkerGlobalScope(ScriptExecutionContext*, WorkerGlobalScopeProxy*, const URL&);
    static void workerGlobalScopeTerminated(ScriptExecutionContext*, WorkerGlobalScopeProxy*);
    static void willEvaluateWorkerScript(WorkerGlobalScope*, int workerThreadStartMode);
#endif

#if ENABLE(WEB_SOCKETS)
    static void didCreateWebSocket(Document*, unsigned long identifier, const URL& requestURL, const URL& documentURL, const String& protocol);
    static void willSendWebSocketHandshakeRequest(Document*, unsigned long identifier, const ResourceRequest&);
    static void didReceiveWebSocketHandshakeResponse(Document*, unsigned long identifier, const ResourceResponse&);
    static void didCloseWebSocket(Document*, unsigned long identifier);

    static void didFinishLoadingImpl(InstrumentingAgents*, unsigned long identifier, DocumentLoader*, double finishTime);
    static void didFailLoadingImpl(InstrumentingAgents*, unsigned long identifier, DocumentLoader*, const ResourceError&);
    static void documentThreadableLoaderStartedLoadingForClientImpl(InstrumentingAgents*, unsigned long identifier, ThreadableLoaderClient*);
    static void willLoadXHRImpl(InstrumentingAgents*, ThreadableLoaderClient*, const String&, const URL&, bool, PassRefPtr<FormData>, const HTTPHeaderMap&, bool);
    static void didFailXHRLoadingImpl(InstrumentingAgents*, ThreadableLoaderClient*);
    static void didFinishXHRLoadingImpl(InstrumentingAgents*, ThreadableLoaderClient*, unsigned long identifier, const String& sourceString, const String& url, const String& sendURL, unsigned sendLineNumber);
    static void didReceiveXHRResponseImpl(InstrumentingAgents*, unsigned long identifier);


#if ENABLE(WORKERS)
    static bool shouldPauseDedicatedWorkerOnStartImpl(InstrumentingAgents*);
    static void didStartWorkerGlobalScopeImpl(InstrumentingAgents*, WorkerGlobalScopeProxy*, const URL&);
    static void workerGlobalScopeTerminatedImpl(InstrumentingAgents*, WorkerGlobalScopeProxy*);
#endif

#if ENABLE(WEB_SOCKETS)
    static void didCreateWebSocketImpl(InstrumentingAgents*, unsigned long identifier, const URL& requestURL, const URL& documentURL, const String& protocol, Document*);
    static void willSendWebSocketHandshakeRequestImpl(InstrumentingAgents*, unsigned long identifier, const ResourceRequest&, Document*);
    static void didReceiveWebSocketHandshakeResponseImpl(InstrumentingAgents*, unsigned long identifier, const ResourceResponse&, Document*);
    static void didCloseWebSocketImpl(InstrumentingAgents*, unsigned long identifier, Document*);

#endif
}

inline void InspectorInstrumentation::willLoadXHR(ScriptExecutionContext* context, ThreadableLoaderClient* client, const String& method, const URL& url, bool async, PassRefPtr<FormData> formData, const HTTPHeaderMap& headers, bool includeCredentials)
{
#if ENABLE(INSPECTOR)
    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForContext(context))

    return false;
}

inline void InspectorInstrumentation::didStartWorkerGlobalScope(ScriptExecutionContext* context, WorkerGlobalScopeProxy* proxy, const URL& url)
{
#if ENABLE(INSPECTOR)
    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForContext(context))



#if ENABLE(WEB_SOCKETS)
inline void InspectorInstrumentation::didCreateWebSocket(Document* document, unsigned long identifier, const URL& requestURL, const URL& documentURL, const String& protocol)
{
#if ENABLE(INSPECTOR)
    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(document))



}

// static
void InspectorPageAgent::resourceContent(ErrorString* errorString, Frame* frame, const URL& url, String* result, bool* base64Encoded)
{
    DocumentLoader* loader = assertDocumentLoader(errorString, frame);
    if (!loader)

    return String();
}

CachedResource* InspectorPageAgent::cachedResource(Frame* frame, const URL& url)
{
    CachedResource* cachedResource = frame->document()->cachedResourceLoader()->cachedResource(url);
    if (!cachedResource) {

    return result;
}

static Vector<URL> allResourcesURLsForFrame(Frame* frame)
{
    Vector<URL> result;

    result.append(frame->loader().documentLoader()->url());



    for (Frame* frame = mainFrame(); frame; frame = frame->tree().traverseNext(mainFrame())) {
        Document* document = frame->document();
        Vector<URL> allURLs = allResourcesURLsForFrame(frame);
        for (Vector<URL>::const_iterator it = allURLs.begin(); it != allURLs.end(); ++it) {
            Vector<Cookie> docCookiesList;
            rawCookiesImplemented = getRawCookies(document, URL(ParsedURLString, *it), docCookiesList);
            if (!rawCookiesImplemented) {
                // FIXME: We need duplication checking for the String representation of cookies.
                //


void InspectorPageAgent::deleteCookie(ErrorString*, const String& cookieName, const String& url)
{
    URL parsedURL(ParsedURLString, url);
    for (Frame* frame = &m_page->mainFrame(); frame; frame = frame->tree().traverseNext(&m_page->mainFrame()))
        WebCore::deleteCookie(frame->document(), parsedURL, cookieName);
}

    if (!frame)
        return;

    resourceContent(errorString, frame, URL(ParsedURLString, url), content, base64Encoded);
}

static bool textContentForCachedResource(CachedResource* cachedResource, String* result)

    if (!loader)
        return;

    URL kurl(ParsedURLString, url);

    String content;
    bool success = false;



class InspectorOverlay;
class InspectorState;
class InstrumentingAgents;
class URL;
class Page;
class RegularExpression;
class SharedBuffer;


    static bool cachedResourceContent(CachedResource*, String* result, bool* base64Encoded);
    static bool sharedBufferContent(PassRefPtr<SharedBuffer>, const String& textEncodingName, bool withBase64Encode, String* result);
    static void resourceContent(ErrorString*, Frame*, const URL&, String* result, bool* base64Encoded);
    static String sourceMapURLForResource(CachedResource*);

    static PassRefPtr<SharedBuffer> resourceData(Frame*, const URL&, String* textEncodingName);
    static CachedResource* cachedResource(Frame*, const URL&);
    static TypeBuilder::Page::ResourceType::Enum resourceTypeJson(ResourceType);
    static ResourceType cachedResourceType(const CachedResource&);
    static TypeBuilder::Page::ResourceType::Enum cachedResourceTypeJson(const CachedResource&);

Lines 43-49 a/Source/WebCore/inspector/InspectorProfilerAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorProfilerAgent.cpp -1 / +1 lines
43	#include "InspectorState.h"	43	#include "InspectorState.h"
44	#include "InspectorValues.h"	44	#include "InspectorValues.h"
45	#include "InstrumentingAgents.h"	45	#include "InstrumentingAgents.h"
46	#include "KURL.h"	46	#include "URL.h"
47	#include "Page.h"	47	#include "Page.h"
48	#include "PageScriptDebugServer.h"	48	#include "PageScriptDebugServer.h"
49	#include "ScriptHeapSnapshot.h"	49	#include "ScriptHeapSnapshot.h"



#include "InspectorState.h"
#include "InspectorValues.h"
#include "InstrumentingAgents.h"
#include "URL.h"
#include "MemoryCache.h"
#include "NetworkResourcesData.h"
#include "Page.h"

    m_resourcesData->setXHRReplayData(requestId, xhrReplayData);
}

void InspectorResourceAgent::willLoadXHR(ThreadableLoaderClient* client, const String& method, const URL& url, bool async, PassRefPtr<FormData> formData, const HTTPHeaderMap& headers, bool includeCredentials)
{
    RefPtr<XHRReplayData> xhrReplayData = XHRReplayData::create(method, url, async, formData, includeCredentials);
    HTTPHeaderMap::const_iterator end = headers.end();


#if ENABLE(WEB_SOCKETS)

void InspectorResourceAgent::didCreateWebSocket(unsigned long identifier, const URL& requestURL)
{
    m_frontend->webSocketCreated(IdentifiersFactory::requestId(identifier), requestURL.string());
}



class InspectorPageAgent;
class InspectorState;
class InstrumentingAgents;
class URL;
class NetworkResourcesData;
class Page;
class ResourceError;

    void didReceiveScriptResponse(unsigned long identifier);

    void documentThreadableLoaderStartedLoadingForClient(unsigned long identifier, ThreadableLoaderClient*);
    void willLoadXHR(ThreadableLoaderClient*, const String& method, const URL&, bool async, PassRefPtr<FormData> body, const HTTPHeaderMap& headers, bool includeCrendentials);
    void didFailXHRLoading(ThreadableLoaderClient*);
    void didFinishXHRLoading(ThreadableLoaderClient*, unsigned long identifier, const String& sourceString);
    void didReceiveXHRResponse(unsigned long identifier);

    PassRefPtr<TypeBuilder::Network::Initiator> buildInitiatorObject(Document*);

#if ENABLE(WEB_SOCKETS)
    void didCreateWebSocket(unsigned long identifier, const URL& requestURL);
    void willSendWebSocketHandshakeRequest(unsigned long identifier, const ResourceRequest&);
    void didReceiveWebSocketHandshakeResponse(unsigned long identifier, const ResourceResponse&);
    void didCloseWebSocket(unsigned long identifier);

Lines 1382-1388 bool InspectorStyleSheet::resourceStyleSheetText(String* result) const a/Source/WebCore/inspector/InspectorStyleSheet.cpp_sec1
- a/Source/WebCore/inspector/InspectorStyleSheet.cpp -1 / +1 lines
1382		1382
1383	String error;	1383	String error;
1384	bool base64Encoded;	1384	bool base64Encoded;
1385	InspectorPageAgent::resourceContent(&error, ownerDocument()->frame(), KURL(ParsedURLString, m_pageStyleSheet->href()), result, &base64Encoded);	1385	InspectorPageAgent::resourceContent(&error, ownerDocument()->frame(), URL(ParsedURLString, m_pageStyleSheet->href()), result, &base64Encoded);
1386	return error.isEmpty() && !base64Encoded;	1386	return error.isEmpty() && !base64Encoded;
1387	}	1387	}
1388		1388

Lines 434-440 void InspectorTimelineAgent::didFireAnimationFrame() a/Source/WebCore/inspector/InspectorTimelineAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorTimelineAgent.cpp -1 / +1 lines
434	}	434	}
435		435
436	#if ENABLE(WEB_SOCKETS)	436	#if ENABLE(WEB_SOCKETS)
437	void InspectorTimelineAgent::didCreateWebSocket(unsigned long identifier, const KURL& url, const String& protocol, Frame* frame)	437	void InspectorTimelineAgent::didCreateWebSocket(unsigned long identifier, const URL& url, const String& protocol, Frame* frame)
438	{	438	{
439	appendRecord(TimelineRecordFactory::createWebSocketCreateData(identifier, url, protocol), TimelineRecordType::WebSocketCreate, true, frame);	439	appendRecord(TimelineRecordFactory::createWebSocketCreateData(identifier, url, protocol), TimelineRecordType::WebSocketCreate, true, frame);
440	}	440	}



class InspectorState;
class InstrumentingAgents;
class IntRect;
class URL;
class Page;
class RenderObject;
class ResourceRequest;

    void didFireAnimationFrame();

#if ENABLE(WEB_SOCKETS)
    void didCreateWebSocket(unsigned long identifier, const URL&, const String& protocol, Frame*);
    void willSendWebSocketHandshakeRequest(unsigned long identifier, Frame*);
    void didReceiveWebSocketHandshakeResponse(unsigned long identifier, Frame*);
    void didDestroyWebSocket(unsigned long identifier, Frame*);



#include "InspectorState.h"
#include "InspectorValues.h"
#include "InstrumentingAgents.h"
#include "URL.h"
#include "WorkerGlobalScopeProxy.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/RefPtr.h>

    return m_state->getBoolean(WorkerAgentState::autoconnectToWorkers);
}

void InspectorWorkerAgent::didStartWorkerGlobalScope(WorkerGlobalScopeProxy* workerGlobalScopeProxy, const URL& url)
{
    m_dedicatedWorkers.set(workerGlobalScopeProxy, url.string());
    if (m_inspectorFrontend && m_state->getBoolean(WorkerAgentState::workerInspectionEnabled))



class InspectorObject;
class InspectorState;
class InstrumentingAgents;
class URL;
class WorkerGlobalScopeProxy;

typedef String ErrorString;


    // Called from InspectorInstrumentation
    bool shouldPauseDedicatedWorkerOnStart();
    void didStartWorkerGlobalScope(WorkerGlobalScopeProxy*, const URL&);
    void workerGlobalScopeTerminated(WorkerGlobalScopeProxy*);

    // Called from InspectorBackendDispatcher



namespace WebCore {


PassRefPtr<XHRReplayData> XHRReplayData::create(const String &method, const URL& url, bool async, PassRefPtr<FormData> formData, bool includeCredentials)
{
    return adoptRef(new XHRReplayData(method, url, async, formData, includeCredentials));
}

    m_headers.set(key, value);
}

XHRReplayData::XHRReplayData(const String &method, const URL& url, bool async, PassRefPtr<FormData> formData, bool includeCredentials)
    : m_method(method)
    , m_url(url)
    , m_async(async)




#include "HTTPHeaderMap.h"
#include "InspectorPageAgent.h"
#include "URL.h"
#include "TextResourceDecoder.h"
#include <wtf/Deque.h>
#include <wtf/HashMap.h>


class XHRReplayData : public RefCounted<XHRReplayData> {
public:
    static PassRefPtr<XHRReplayData> create(const String &method, const URL&, bool async, PassRefPtr<FormData>, bool includeCredentials);

    void addHeader(const AtomicString& key, const String& value);
    const String& method() const { return m_method; }
    const URL& url() const { return m_url; }
    bool async() const { return m_async; }
    PassRefPtr<FormData> formData() const { return m_formData; }
    const HTTPHeaderMap& headers() const { return m_headers; }
    bool includeCredentials() const { return m_includeCredentials; }
private:
    XHRReplayData(const String &method, const URL&, bool async, PassRefPtr<FormData>, bool includeCredentials);

    String m_method;
    URL m_url;
    bool m_async;
    RefPtr<FormData> m_formData;
    HTTPHeaderMap m_headers;



#define TimelineRecordFactory_h

#include "InspectorValues.h"
#include "URL.h"
#include "LayoutRect.h"
#include <wtf/Forward.h>
#include <wtf/text/WTFString.h>

        static void appendLayoutRoot(InspectorObject* data, const FloatQuad&);

#if ENABLE(WEB_SOCKETS)
        static inline PassRefPtr<InspectorObject> createWebSocketCreateData(unsigned long identifier, const URL& url, const String& protocol)
        {
            RefPtr<InspectorObject> data = InspectorObject::create();
            data->setNumber("identifier", identifier);



#define LOCAL_SESSION(document) NetworkStorageSession session(networkingContext(document));
#endif

String cookies(const Document* document, const URL& url)
{
    LOCAL_SESSION(document)
    return platformStrategies()->cookiesStrategy()->cookiesForDOM(session, document->firstPartyForCookies(), url);
}

void setCookies(Document* document, const URL& url, const String& cookieString)
{
    LOCAL_SESSION(document)
    platformStrategies()->cookiesStrategy()->setCookiesFromDOM(session, document->firstPartyForCookies(), url, cookieString);

    return platformStrategies()->cookiesStrategy()->cookiesEnabled(session, document->firstPartyForCookies(), document->cookieURL());
}

String cookieRequestHeaderFieldValue(const Document* document, const URL& url)
{
    LOCAL_SESSION(document)
    return platformStrategies()->cookiesStrategy()->cookieRequestHeaderFieldValue(session, document->firstPartyForCookies(), url);
}

bool getRawCookies(const Document* document, const URL& url, Vector<Cookie>& cookies)
{
    LOCAL_SESSION(document)
    return platformStrategies()->cookiesStrategy()->getRawCookies(session, document->firstPartyForCookies(), url, cookies);
}

void deleteCookie(const Document* document, const URL& url, const String& cookieName)
{
    LOCAL_SESSION(document)
    platformStrategies()->cookiesStrategy()->deleteCookie(session, url, cookieName);



namespace WebCore {

class Document;
class URL;
struct Cookie;

// Functions in this file take a Document pointer to determine which cookie storage to use. We should merge that into call sites, and use PlatformCookieJar directly.

// These two functions implement document.cookie API, with special rules for HttpOnly cookies.
String cookies(const Document*, const URL&);
void setCookies(Document*, const URL&, const String& cookieString);

bool cookiesEnabled(const Document*);
String cookieRequestHeaderFieldValue(const Document*, const URL&);
bool getRawCookies(const Document*, const URL&, Vector<Cookie>&);
void deleteCookie(const Document*, const URL&, const String& cookieName);

}




    return cache;
}

void CrossOriginPreflightResultCache::appendEntry(const String& origin, const URL& url, PassOwnPtr<CrossOriginPreflightResultCacheItem> preflightResult)
{
    ASSERT(isMainThread());
    m_preflightHashMap.set(make_pair(origin, url), preflightResult);
}

bool CrossOriginPreflightResultCache::canSkipPreflight(const String& origin, const URL& url, StoredCredentials includeCredentials, const String& method, const HTTPHeaderMap& requestHeaders)
{
    ASSERT(isMainThread());
    CrossOriginPreflightResultHashMap::iterator cacheIt = m_preflightHashMap.find(make_pair(origin, url));



#ifndef CrossOriginPreflightResultCache_h
#define CrossOriginPreflightResultCache_h

#include "URLHash.h"
#include "ResourceHandleTypes.h"
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>

    public:
        static CrossOriginPreflightResultCache& shared();

        void appendEntry(const String& origin, const URL&, PassOwnPtr<CrossOriginPreflightResultCacheItem>);
        bool canSkipPreflight(const String& origin, const URL&, StoredCredentials, const String& method, const HTTPHeaderMap& requestHeaders);

        void empty();

    private:
        CrossOriginPreflightResultCache() { }

        typedef HashMap<std::pair<String, URL>, OwnPtr<CrossOriginPreflightResultCacheItem> > CrossOriginPreflightResultHashMap;

        CrossOriginPreflightResultHashMap m_preflightHashMap;
    };

Lines 82-88 void DocumentLoadTiming::setNavigationStart(double navigationStart) a/Source/WebCore/loader/DocumentLoadTiming.cpp_sec1
- a/Source/WebCore/loader/DocumentLoadTiming.cpp -1 / +1 lines
82	m_navigationStart = navigationStart;	82	m_navigationStart = navigationStart;
83	}	83	}
84		84
85	void DocumentLoadTiming::addRedirect(const KURL& redirectingUrl, const KURL& redirectedUrl)	85	void DocumentLoadTiming::addRedirect(const URL& redirectingUrl, const URL& redirectedUrl)
86	{	86	{
87	m_redirectCount++;	87	m_redirectCount++;
88	if (!m_redirectStart)	88	if (!m_redirectStart)



namespace WebCore {

class Frame;
class URL;

class DocumentLoadTiming {
public:


    void markNavigationStart();
    void setNavigationStart(double);
    void addRedirect(const URL& redirectingUrl, const URL& redirectedUrl);

    void markUnloadEventStart() { m_unloadEventStart = monotonicallyIncreasingTime(); }
    void markUnloadEventEnd() { m_unloadEventEnd = monotonicallyIncreasingTime(); }



    return m_request;
}

const URL& DocumentLoader::url() const
{
    return request().url();
}

void DocumentLoader::replaceRequestURLForSameDocumentNavigation(const URL& url)
{
    m_originalRequestCopy.setURL(url);
    m_request.setURL(url);


void DocumentLoader::handleSubstituteDataLoadNow(DocumentLoaderTimer*)
{
    URL url = m_substituteData.responseURL();
    if (url.isEmpty())
        url = m_request.url();
    ResourceResponse response(url, m_substituteData.mimeType(), m_substituteData.content()->size(), m_substituteData.textEncoding(), "");

    if (isStopping())
        return;

    URL url = m_request.url();
    const String& mimeType = m_response.mimeType();
    
    switch (policy) {

#if USE(CFNETWORK) || PLATFORM(MAC)
    // Workaround for <rdar://problem/6060782>
    if (m_response.isNull())
        m_response = ResourceResponse(URL(), "text/html", 0, String(), String());
#endif

    // There is a bug in CFNetwork where callbacks can be dispatched even when loads are deferred.

    m_archiveResourceCollection->addResource(resource);
}

PassRefPtr<Archive> DocumentLoader::popArchiveForSubframe(const String& frameName, const URL& url)
{
    return m_archiveResourceCollection ? m_archiveResourceCollection->popSubframeArchive(frameName, url) : PassRefPtr<Archive>(0);
}

}
#endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)

ArchiveResource* DocumentLoader::archiveResourceForURL(const URL& url) const
{
    if (!m_archiveResourceCollection)
        return 0;

    return ArchiveResource::create(data, r.url(), r.mimeType(), r.textEncodingName(), frame()->tree().uniqueName());
}

PassRefPtr<ArchiveResource> DocumentLoader::subresource(const URL& url) const
{
    if (!isCommitted())
        return 0;

    const CachedResourceLoader::DocumentResourceMap& allResources = m_cachedResourceLoader->allCachedResources();
    CachedResourceLoader::DocumentResourceMap::const_iterator end = allResources.end();
    for (CachedResourceLoader::DocumentResourceMap::const_iterator it = allResources.begin(); it != end; ++it) {
        RefPtr<ArchiveResource> subresource = this->subresource(URL(ParsedURLString, it->value->url()));
        if (subresource)
            subresources.append(subresource.release());
    }

    frameLoader()->didChangeTitle(this);
}

URL DocumentLoader::urlForHistory() const
{
    // Return the URL to be used for history and B/F list.
    // Returns nil for WebDataProtocol URLs that aren't alternates

    return m_substituteData.isValid() || m_response.httpStatusCode() >= 400;
}

const URL& DocumentLoader::originalURL() const
{
    return m_originalRequestCopy.url();
}

const URL& DocumentLoader::requestURL() const
{
    return request().url();
}

const URL& DocumentLoader::responseURL() const
{
    return m_response.url();
}

URL DocumentLoader::documentURL() const
{
    URL url = substituteData().responseURL();
#if ENABLE(WEB_ARCHIVE)
    if (url.isEmpty() && m_archive && m_archive->type() == Archive::WebArchive)
        url = m_archive->mainResource()->url();

    return m_response.mimeType();
}

const URL& DocumentLoader::unreachableURL() const
{
    return m_substituteData.failingURL();
}



        const SubstituteData& substituteData() const { return m_substituteData; }

        // FIXME: This is the same as requestURL(). We should remove one of them.
        const URL& url() const;
        const URL& unreachableURL() const;

        const URL& originalURL() const;
        const URL& requestURL() const;
        const URL& responseURL() const;
        const String& responseMIMEType() const;

        void replaceRequestURLForSameDocumentNavigation(const URL&);
        bool isStopping() const { return m_isStopping; }
        void stopLoading();
        void setCommitted(bool committed) { m_committed = committed; }

        void setArchive(PassRefPtr<Archive>);
        void addAllArchiveResources(Archive*);
        void addArchiveResource(PassRefPtr<ArchiveResource>);
        PassRefPtr<Archive> popArchiveForSubframe(const String& frameName, const URL&);
        SharedBuffer* parsedArchiveData() const;

        bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&);
#endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)

        // Return the ArchiveResource for the URL only when loading an Archive
        ArchiveResource* archiveResourceForURL(const URL&) const;

        PassRefPtr<ArchiveResource> mainResource() const;

        // Return an ArchiveResource for the URL, either creating from live data or
        // pulling from the ArchiveResourceCollection
        PassRefPtr<ArchiveResource> subresource(const URL&) const;
        void getSubresources(Vector<PassRefPtr<ArchiveResource> >&) const;



        void stopRecordingResponses();
        const StringWithDirection& title() const { return m_pageTitle; }

        URL urlForHistory() const;
        bool urlForHistoryReflectsFailure() const;

        // These accessors accommodate WebCore's somewhat fickle custom of creating history

    private:

        // The URL of the document resulting from this DocumentLoader.
        URL documentURL() const;
        Document* document() const;

        void setRequest(const ResourceRequest&);



void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, SecurityCheckPolicy securityCheck)
{
    // Any credential should have been removed from the cross-site requests.
    const URL& requestURL = request.url();
    m_options.securityCheck = securityCheck;
    ASSERT(m_sameOriginRequest || requestURL.user().isEmpty());
    ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());

    didFinishLoading(identifier, 0.0);
}

bool DocumentThreadableLoader::isAllowedRedirect(const URL& url)
{
    if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
        return true;



namespace WebCore {
    class CachedRawResource;
    class Document;
    class URL;
    class ResourceRequest;
    class SecurityOrigin;
    class ThreadableLoaderClient;

        void preflightFailure(unsigned long identifier, const String& url, const String& errorDescription);

        void loadRequest(const ResourceRequest&, SecurityCheckPolicy);
        bool isAllowedRedirect(const URL&);

        SecurityOrigin* securityOrigin() const;





void DocumentWriter::begin()
{
    begin(URL());
}

PassRefPtr<Document> DocumentWriter::createDocument(const URL& url)
{
    if (!m_frame->loader().stateMachine()->isDisplayingInitialEmptyDocument() && m_frame->loader().client().shouldAlwaysUsePluginDocument(m_mimeType))
        return PluginDocument::create(m_frame, url);

    return DOMImplementation::createDocument(m_mimeType, m_frame, url, m_frame->inViewSourceMode());
}

void DocumentWriter::begin(const URL& urlReference, bool dispatch, Document* ownerDocument)
{
    // We grab a local copy of the URL because it's easy for callers to supply
    // a URL that will be deallocated during the execution of this function.
    // For example, see <https://bugs.webkit.org/show_bug.cgi?id=66360>.
    URL url = urlReference;

    // Create a new document before clearing the frame, because it may need to
    // inherit an aliased security context.



#ifndef DocumentWriter_h
#define DocumentWriter_h

#include "URL.h"
#include <wtf/text/WTFString.h>

namespace WebCore {

    void replaceDocument(const String&, Document* ownerDocument);

    void begin();
    void begin(const URL&, bool dispatchWindowObjectAvailable = true, Document* ownerDocument = 0);
    void addData(const char* bytes, size_t length);
    void end();
    

    void setDocumentWasLoadedAsPartOfNavigation();

private:
    PassRefPtr<Document> createDocument(const URL&);
    void clear();

    Frame* m_frame;



    return DocumentLoader::create(request, substituteData);
}

PassRefPtr<Frame> EmptyFrameLoaderClient::createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int)
{
    return 0;
}

PassRefPtr<Widget> EmptyFrameLoaderClient::createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool)
{
    return 0;
}

{
}

PassRefPtr<Widget> EmptyFrameLoaderClient::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&)
{
    return 0;
}

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
PassRefPtr<Widget> EmptyFrameLoaderClient::createMediaPlayerProxyPlugin(const IntSize&, HTMLMediaElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&)
{
    return 0;
}



    virtual void dispatchDidHandleOnloadEvents() { }
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() { }
    virtual void dispatchDidCancelClientRedirect() { }
    virtual void dispatchWillPerformClientRedirect(const URL&, double, double) { }
    virtual void dispatchDidChangeLocationWithinPage() { }
    virtual void dispatchDidPushStateWithinPage() { }
    virtual void dispatchDidReplaceStateWithinPage() { }

    virtual void frameLoadCompleted() { }
    virtual void restoreViewState() { }
    virtual void provisionalLoadStarted() { }
    virtual bool shouldTreatURLAsSameAsCurrent(const URL&) const { return false; }
    virtual void didFinishLoad() { }
    virtual void prepareForDataSourceReplacement() { }

    virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) OVERRIDE;
    virtual void setTitle(const StringWithDirection&, const URL&) { }

    virtual String userAgent(const URL&) { return ""; }

    virtual void savePlatformDataToCachedFrame(CachedFrame*) { }
    virtual void transitionToCommittedFromCachedFrame(CachedFrame*) { }

    virtual void saveViewStateToItem(HistoryItem*) { }
    virtual bool canCachePage() const { return false; }
    virtual void didDisplayInsecureContent() { }
    virtual void didRunInsecureContent(SecurityOrigin*, const URL&) { }
    virtual void didDetectXSS(const URL&, bool) { }
    virtual PassRefPtr<Frame> createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int) OVERRIDE;
    virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool) OVERRIDE;
    virtual void recreatePlugin(Widget*) OVERRIDE;
    virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&) OVERRIDE;
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
    virtual PassRefPtr<Widget> createMediaPlayerProxyPlugin(const IntSize&, HTMLMediaElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&) OVERRIDE;
    virtual void hideMediaPlayerProxyPlugin(Widget*) { }
    virtual void showMediaPlayerProxyPlugin(Widget*) { }
#endif

    virtual ObjectContentType objectContentType(const URL&, const String&, bool) { return ObjectContentType(); }
    virtual String overrideMediaType() const { return String(); }

    virtual void redirectDataToPlugin(Widget*) { }

#endif
    virtual void contextMenuItemSelected(ContextMenuItem*, const ContextMenu*) { }

    virtual void downloadURL(const URL&) { }
    virtual void copyImageToClipboard(const HitTestResult&) { }
    virtual void searchWithGoogle(const Frame*) { }
    virtual void lookUpInDictionary(Frame*) { }



    return ++nextIdentifier;
}

static void appendMailtoPostFormDataToURL(URL& url, const FormData& data, const String& encodingType)
{
    String body = data.flattenToString();



void FormSubmission::Attributes::parseAction(const String& action)
{
    // FIXME: Can we parse into a URL?
    m_action = stripLeadingAndTrailingHTMLSpaces(action);
}


    m_acceptCharset = other.m_acceptCharset;
}

inline FormSubmission::FormSubmission(Method method, const URL& action, const String& target, const String& contentType, PassRefPtr<FormState> state, PassRefPtr<FormData> data, const String& boundary, bool lockHistory, PassRefPtr<Event> event)
    : m_method(method)
    , m_action(action)
    , m_target(target)

    }
    
    Document& document = form->document();
    URL actionURL = document.completeURL(copiedAttributes.action().isEmpty() ? document.url().string() : copiedAttributes.action());
    bool isMailtoForm = actionURL.protocolIs("mailto");
    bool isMultiPartForm = false;
    String encodingType = copiedAttributes.encodingType();

    return adoptRef(new FormSubmission(copiedAttributes.method(), actionURL, targetOrBaseTarget, encodingType, formState.release(), formData.release(), boundary, lockHistory, event));
}

URL FormSubmission::requestURL() const
{
    if (m_method == FormSubmission::PostMethod)
        return m_action;

    URL requestURL(m_action);
    requestURL.setQuery(m_formData->flattenToString());    
    return requestURL;
}



#define FormSubmission_h

#include "FormState.h"
#include "URL.h"

namespace WebCore {



    void populateFrameLoadRequest(FrameLoadRequest&);
    
    URL requestURL() const;

    Method method() const { return m_method; }
    const URL& action() const { return m_action; }
    const String& target() const { return m_target; }
    void clearTarget() { m_target = String(); }
    const String& contentType() const { return m_contentType; }

    void setOrigin(const String& origin) { m_origin = origin; }

private:
    FormSubmission(Method, const URL& action, const String& target, const String& contentType, PassRefPtr<FormState>, PassRefPtr<FormData>, const String& boundary, bool lockHistory, PassRefPtr<Event>);

    // FIXME: Hold an instance of Attributes instead of individual members.
    Method m_method;
    URL m_action;
    String m_target;
    String m_contentType;
    RefPtr<FormState> m_formState;



void FrameLoader::init()
{
    // This somewhat odd set of steps gives the frame an initial empty document.
    setPolicyDocumentLoader(m_client.createDocumentLoader(ResourceRequest(URL(ParsedURLString, emptyString())), SubstituteData()).get());
    setProvisionalDocumentLoader(m_policyDocumentLoader.get());
    m_provisionalDocumentLoader->startLoadingMainResource();
    m_frame.document()->cancelParsing();

    }
}

void FrameLoader::changeLocation(SecurityOrigin* securityOrigin, const URL& url, const String& referrer, bool lockHistory, bool lockBackForwardList, bool refresh)
{
    urlSelected(FrameLoadRequest(securityOrigin, ResourceRequest(url, referrer, refresh ? ReloadIgnoringCacheData : UseProtocolCachePolicy), "_self"),
        0, lockHistory, lockBackForwardList, MaybeSendReferrer, ReplaceDocumentIfJavaScriptURL);
}

void FrameLoader::urlSelected(const URL& url, const String& passedTarget, PassRefPtr<Event> triggeringEvent, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer shouldSendReferrer)
{
    urlSelected(FrameLoadRequest(m_frame.document()->securityOrigin(), ResourceRequest(url), passedTarget),
        triggeringEvent, lockHistory, lockBackForwardList, shouldSendReferrer, DoNotReplaceDocumentIfJavaScriptURL);

    }

    if (protocolIsJavaScript(submission->action())) {
        if (!m_frame.document()->contentSecurityPolicy()->allowFormAction(URL(submission->action())))
            return;
        m_isExecutingJavaScriptFormAction = true;
        m_frame.script().executeIfJavaScriptURL(submission->action(), DoNotReplaceDocumentIfJavaScriptURL);

    m_frame.navigationScheduler().scheduleRedirect(delay, url);
}

void FrameLoader::setOutgoingReferrer(const URL& url)
{
    m_outgoingReferrer = url.strippedForUseAsReferrer();
}

    m_frame.document()->implicitClose();
}

void FrameLoader::loadURLIntoChildFrame(const URL& url, const String& referer, Frame* childFrame)
{
    ASSERT(childFrame);


    if (!mainResource)
        return;
        
    SubstituteData substituteData(mainResource->data(), mainResource->mimeType(), mainResource->textEncoding(), URL());
    
    ResourceRequest request(mainResource->url());
#if PLATFORM(MAC)

}
#endif // ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)

ObjectContentType FrameLoader::defaultObjectContentType(const URL& url, const String& mimeTypeIn, bool shouldPreferPlugInsForImages)
{
    String mimeType = mimeTypeIn;


    return m_frame.document()->securityOrigin()->toString();
}

bool FrameLoader::checkIfFormActionAllowedByCSP(const URL& url) const
{
    if (m_submittedFormURL.isEmpty())
        return true;


void FrameLoader::resetMultipleFormSubmissionProtection()
{
    m_submittedFormURL = URL();
}

void FrameLoader::updateFirstPartyForCookies()

        setFirstPartyForCookies(m_frame.document()->url());
}

void FrameLoader::setFirstPartyForCookies(const URL& url)
{
    for (Frame* frame = &m_frame; frame; frame = frame->tree().traverseNext(&m_frame))
        frame->document()->setFirstPartyForCookies(url);


// This does the same kind of work that didOpenURL does, except it relies on the fact
// that a higher level already checked that the URLs match and the scrolling is the right thing to do.
void FrameLoader::loadInSameDocument(const URL& url, PassRefPtr<SerializedScriptValue> stateObject, bool isNewNavigation)
{
    // If we have a state object, we cannot also be a new navigation.
    ASSERT(!stateObject || (stateObject && !isNewNavigation));

    // Update the data source's request with the new URL to fake the URL change
    URL oldURL = m_frame.document()->url();
    m_frame.document()->setURL(url);
    setOutgoingReferrer(url);
    documentLoader()->replaceRequestURLForSameDocumentNavigation(url);

    // Protect frame from getting blown away inside dispatchBeforeLoadEvent in loadWithDocumentLoader.
    Ref<Frame> protect(m_frame);

    URL url = request.resourceRequest().url();

    ASSERT(m_frame.document());
    if (!request.requester()->canDisplay(url)) {

    }
}

void FrameLoader::loadURL(const URL& newURL, const String& referrer, const String& frameName, bool lockHistory, FrameLoadType newLoadType,
    PassRefPtr<Event> event, PassRefPtr<FormState> prpFormState)
{
    if (m_inStopAllLoaders)

    }
}

SubstituteData FrameLoader::defaultSubstituteDataForURL(const URL& url)
{
    if (!shouldTreatURLAsSrcdocDocument(url))
        return SubstituteData();
    String srcdoc = m_frame.ownerElement()->fastGetAttribute(srcdocAttr);
    ASSERT(!srcdoc.isNull());
    CString encodedSrcdoc = srcdoc.utf8();
    return SubstituteData(SharedBuffer::create(encodedSrcdoc.data(), encodedSrcdoc.length()), "text/html", "UTF-8", URL());
}

void FrameLoader::load(const FrameLoadRequest& passedRequest)

    RefPtr<FormState> formState = prpFormState;
    bool isFormSubmission = formState;

    const URL& newURL = loader->request().url();
    const String& httpMethod = loader->request().httpMethod();

    if (shouldPerformFragmentNavigation(isFormSubmission, httpMethod, policyChecker().loadType(), newURL)) {

    return activeDocumentLoader()->originalRequest();
}

bool FrameLoader::willLoadMediaElementURL(URL& url)
{
    ResourceRequest request(url);



bool FrameLoader::shouldReloadToHandleUnreachableURL(DocumentLoader* docLoader)
{
    URL unreachableURL = docLoader->unreachableURL();

    if (unreachableURL.isEmpty())
        return false;

        return;

    ResourceRequest request = m_documentLoader->request();
    URL unreachableURL = m_documentLoader->unreachableURL();
    if (!unreachableURL.isEmpty())
        request.setURL(unreachableURL);


    loadWithDocumentLoader(loader.get(), FrameLoadTypeReload, 0);
}

void FrameLoader::reloadWithOverrideURL(const URL& overrideUrl, bool endToEndReload)
{
    if (!m_documentLoader)
        return;


    // Replace error-page URL with the URL we were trying to reach.
    ResourceRequest initialRequest = m_documentLoader->request();
    URL unreachableURL = m_documentLoader->unreachableURL();
    if (!unreachableURL.isEmpty())
        initialRequest.setURL(unreachableURL);


    m_sentRedirectNotification = false;
}

void FrameLoader::clientRedirected(const URL& url, double seconds, double fireDate, bool lockBackForwardList)
{
    m_client.dispatchWillPerformClientRedirect(url, seconds, fireDate);
    

    m_quickRedirectComing = (lockBackForwardList || history().currentItemShouldBeReplaced()) && m_documentLoader && !m_isExecutingJavaScriptFormAction;
}

bool FrameLoader::shouldReload(const URL& currentURL, const URL& destinationURL)
{
    // This function implements the rule: "Don't reload if navigating by fragment within
    // the same URL, but do reload if going to a new URL or to the same URL with no

    // Don't re-emit the load event.
    m_didCallImplicitClose = true;

    URL url = cachedFrame.url();

    // FIXME: I suspect this block of code doesn't do anything.
    if (url.protocolIsInHTTPFamily() && !url.host().isEmpty() && url.path().isEmpty())

                if (pdl == m_provisionalDocumentLoader)
                    clearProvisionalLoad();
                else if (activeDocumentLoader()) {
                    URL unreachableURL = activeDocumentLoader()->unreachableURL();
                    if (!unreachableURL.isEmpty() && unreachableURL == pdl->request().url())
                        shouldReset = false;
                }

    m_provisionalDocumentLoader->startLoadingMainResource();
}

static URL originatingURLFromBackForwardList(Page* page)
{
    // FIXME: Can this logic be replaced with m_frame.document()->firstPartyForCookies()?
    // It has the same meaning of "page a user thinks is the current one".

    URL originalURL;
    int backCount = page->backForward().backCount();
    for (int backIndex = 0; backIndex <= backCount; backIndex++) {
        // FIXME: At one point we had code here to check a "was user gesture" flag.

            return originalURL;
    }

    return URL();
}

void FrameLoader::setOriginalURLForDownloadRequest(ResourceRequest& request)
{
    URL originalURL;
    
    // If there is no referrer, assume that the download was initiated directly, so current document is
    // completely unrelated to it. See <rdar://problem/5294691>.

            hostOnlyURLString = makeString(originalURL.protocol(), "://", originalURL.host());

        // FIXME: Rename firstPartyForCookies back to mainDocumentURL. It was a mistake to think that it was only used for cookies.
        request.setFirstPartyForCookies(URL(URL(), hostOnlyURLString));
    }
}


    return count;
}

String FrameLoader::userAgent(const URL& url) const
{
    String userAgent = m_client.userAgent(url);
    InspectorInstrumentation::applyUserAgentOverride(&m_frame, &userAgent);

    // bunch of parameters that would come in here and then be built back up to a ResourceRequest.  In case
    // any caller depends on the immutability of the original ResourceRequest, I'm rebuilding a ResourceRequest
    // from scratch as it did all along.
    const URL& url = inRequest.url();
    RefPtr<FormData> formData = inRequest.httpBody();
    const String& contentType = inRequest.httpContentType();
    String origin = inRequest.httpOrigin();


    if (m_state == FrameStateProvisional && m_provisionalDocumentLoader) {
        if (m_submittedFormURL == m_provisionalDocumentLoader->originalRequestCopy().url())
            m_submittedFormURL = URL();
            
        // We might have made a page cache item, but now we're bailing out due to an error before we ever
        // transitioned to the new page (before WebFrameState == commit).  The goal here is to restore any state

    loadInSameDocument(request.url(), 0, !isRedirect);
}

bool FrameLoader::shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType loadType, const URL& url)
{
    // We don't do this if we are submitting a form with method other than "GET", explicitly reloading,
    // currently displaying a frameset, or if the URL does not have a fragment.

        && !m_frame.document()->isFrameSet();
}

void FrameLoader::scrollToFragmentWithParentBoundary(const URL& url)
{
    FrameView* view = m_frame.view();
    if (!view)

    }

    if (!shouldClose)
        m_submittedFormURL = URL();

    m_currentNavigationHasShownBeforeUnloadConfirmPanel = false;
    return shouldClose;

    request.setHTTPUserAgent(userAgent);
}

bool FrameLoader::shouldInterruptLoadForXFrameOptions(const String& content, const URL& url, unsigned long requestIdentifier)
{
    FeatureObserver::observe(m_frame.document(), FeatureObserver::XFrameOptions);


    commitProvisionalLoad();
}

bool FrameLoader::shouldTreatURLAsSameAsCurrent(const URL& url) const
{
    if (!history().currentItem())
        return false;
    return url == history().currentItem()->url() || url == history().currentItem()->originalURL();
}

bool FrameLoader::shouldTreatURLAsSrcdocDocument(const URL& url) const
{
    if (!equalIgnoringCase(url.string(), "about:srcdoc"))
        return false;

        return;
    }

    URL itemURL = item->url();
    URL itemOriginalURL = item->originalURL();
    URL currentURL;
    if (documentLoader())
        currentURL = documentLoader()->url();
    RefPtr<FormData> formData = item->formData();



    void setupForReplace();

    // FIXME: These are all functions which start loads. We have too many.
    void loadURLIntoChildFrame(const URL&, const String& referer, Frame*);
    void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
        PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer);


#endif
    unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data);

    void changeLocation(SecurityOrigin*, const URL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
    void urlSelected(const URL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer);
    void submitForm(PassRefPtr<FormSubmission>);

    void reload(bool endToEndReload = false);
    void reloadWithOverrideEncoding(const String& overrideEncoding);
    void reloadWithOverrideURL(const URL& overrideUrl, bool endToEndReload = false);

    void open(CachedFrameBase&);
    void loadItem(HistoryItem*, FrameLoadType);

    const ResourceRequest& initialRequest() const;
    void receivedMainResourceError(const ResourceError&);

    bool willLoadMediaElementURL(URL&);

    void handleFallbackContent();


    void didChangeTitle(DocumentLoader*);
    void didChangeIcons(IconType);

    bool shouldTreatURLAsSrcdocDocument(const URL&) const;

    FrameLoadType loadType() const;


    void receivedFirstData();

    void handledOnloadEvents();
    String userAgent(const URL&) const;

    void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
    void dispatchDidClearWindowObjectsInAllWorlds();

    void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
    SandboxFlags effectiveSandboxFlags() const;

    bool checkIfFormActionAllowedByCSP(const URL&) const;

    Frame* opener();
    void setOpener(Frame*);


    void frameDetached();

    void setOutgoingReferrer(const URL&);

    void loadDone();
    void finishedParsing();


    void applyUserAgent(ResourceRequest&);

    bool shouldInterruptLoadForXFrameOptions(const String&, const URL&, unsigned long requestIdentifier);

    void completed();
    bool allAncestorsAreComplete() const; // including this
    void clientRedirected(const URL&, double delay, double fireDate, bool lockBackForwardList);
    void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);

    // FIXME: This is public because this asynchronous callback from the FrameLoaderClient


    bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }

    static ObjectContentType defaultObjectContentType(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages);

    bool quickRedirectComing() const { return m_quickRedirectComing; }



    void loadProgressingStatusChanged();

    const URL& previousURL() const { return m_previousURL; }

    void forcePageTransitionIfNeeded();


    void loadProvisionalItemFromCachedPage();

    void updateFirstPartyForCookies();
    void setFirstPartyForCookies(const URL&);
    
    void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);


    void transitionToCommitted(CachedPage*);
    void frameLoadCompleted();

    SubstituteData defaultSubstituteDataForURL(const URL&);

    static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
    static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);

    void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
    void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);

    bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const URL&);
    void scrollToFragmentWithParentBoundary(const URL&);

    void checkLoadCompleteForThisFrame();



    void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
        const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
    void loadURL(const URL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
        bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         

    void reloadWithRequest(const ResourceRequest&, bool endToEndReload);

    bool shouldReload(const URL& currentURL, const URL& destinationURL);

    void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);

    void detachChildren();
    void closeAndRemoveChild(Frame*);

    void loadInSameDocument(const URL&, PassRefPtr<SerializedScriptValue> stateObject, bool isNewNavigation);

    void prepareForLoadStart();
    void provisionalLoadStarted();

    void scheduleCheckLoadComplete();
    void startCheckCompleteTimer();

    bool shouldTreatURLAsSameAsCurrent(const URL&) const;

    void dispatchGlobalObjectAvailableInAllWorlds();



    bool m_needsClear;

    URL m_submittedFormURL;

    Timer<FrameLoader> m_checkTimer;
    bool m_shouldCallCheckCompleted;


    RefPtr<FrameNetworkingContext> m_networkingContext;

    URL m_previousURL;
    RefPtr<HistoryItem> m_requestedHistoryItem;
    OwnPtr<PageActivityAssertionToken> m_activityAssertion;
};



#endif
    class HTMLPlugInElement;
    class IntSize;
    class URL;
    class MessageEvent;
    class NavigationAction;
    class Page;

        virtual void dispatchDidHandleOnloadEvents() = 0;
        virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() = 0;
        virtual void dispatchDidCancelClientRedirect() = 0;
        virtual void dispatchWillPerformClientRedirect(const URL&, double interval, double fireDate) = 0;
        virtual void dispatchDidNavigateWithinPage() { }
        virtual void dispatchDidChangeLocationWithinPage() = 0;
        virtual void dispatchDidPushStateWithinPage() = 0;

        // The indicated security origin has run active content (such as a
        // script) from an insecure source.  Note that the insecure content can
        // spread to other frames in the same origin.
        virtual void didRunInsecureContent(SecurityOrigin*, const URL&) = 0;
        virtual void didDetectXSS(const URL&, bool didBlockEntirePage) = 0;

        virtual ResourceError cancelledError(const ResourceRequest&) = 0;
        virtual ResourceError blockedError(const ResourceRequest&) = 0;

        virtual void prepareForDataSourceReplacement() = 0;

        virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) = 0;
        virtual void setTitle(const StringWithDirection&, const URL&) = 0;

        virtual String userAgent(const URL&) = 0;
        
        virtual void savePlatformDataToCachedFrame(CachedFrame*) = 0;
        virtual void transitionToCommittedFromCachedFrame(CachedFrame*) = 0;

        virtual bool canCachePage() const = 0;
        virtual void convertMainResourceLoadToDownload(DocumentLoader*, const ResourceRequest&, const ResourceResponse&) = 0;

        virtual PassRefPtr<Frame> createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight) = 0;
        virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually) = 0;
        virtual void recreatePlugin(Widget*) = 0;
        virtual void redirectDataToPlugin(Widget* pluginWidget) = 0;

        virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL& baseURL, const Vector<String>& paramNames, const Vector<String>& paramValues) = 0;

        virtual void dispatchDidFailToStartPlugin(const PluginView*) const { }
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
        virtual PassRefPtr<Widget> createMediaPlayerProxyPlugin(const IntSize&, HTMLMediaElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&) = 0;
        virtual void hideMediaPlayerProxyPlugin(Widget*) = 0;
        virtual void showMediaPlayerProxyPlugin(Widget*) = 0;
#endif

        virtual ObjectContentType objectContentType(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages) = 0;
        virtual String overrideMediaType() const = 0;

        virtual void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*) = 0;

#endif

        virtual bool shouldAlwaysUsePluginDocument(const String& /*mimeType*/) const { return false; }
        virtual bool shouldLoadMediaElementURL(const URL&) const { return true; }

        virtual void didChangeScrollOffset() { }

        virtual bool allowScript(bool enabledPerSettings) { return enabledPerSettings; }
        virtual bool allowScriptFromSource(bool enabledPerSettings, const URL&) { return enabledPerSettings; }
        virtual bool allowPlugins(bool enabledPerSettings) { return enabledPerSettings; }
        virtual bool allowImage(bool enabledPerSettings, const URL&) { return enabledPerSettings; }
        virtual bool allowDisplayingInsecureContent(bool enabledPerSettings, SecurityOrigin*, const URL&) { return enabledPerSettings; }
        virtual bool allowRunningInsecureContent(bool enabledPerSettings, SecurityOrigin*, const URL&) { return enabledPerSettings; }

        // This callback notifies the client that the frame was about to run
        // JavaScript but did not because allowScript returned false. We

        virtual void didNotAllowPlugins() { }

        // Clients that generally disallow universal access can make exceptions for particular URLs.
        virtual bool shouldForceUniversalAccessFromLocalURL(const URL&) { return false; }

        virtual PassRefPtr<FrameNetworkingContext> createNetworkingContext() = 0;

        virtual bool shouldPaintBrokenImage(const URL&) const { return true; }

        // Returns true if the embedder intercepted the postMessage call
        virtual bool willCheckAndDispatchMessageEvent(SecurityOrigin* /*target*/, MessageEvent*) const { return false; }




namespace WebCore {

static inline void addVisitedLink(Page* page, const URL& url)
{
    platformStrategies()->visitedLinkStrategy()->addVisitedLink(page, visitedLinkHash(url.string()));
}

    FrameLoader& frameLoader = m_frame.loader();

    bool needPrivacy = m_frame.settings().privateBrowsingEnabled();
    const URL& historyURL = frameLoader.documentLoader()->urlForHistory();

    if (!frameLoader.documentLoader()->isClientRedirect()) {
        if (!historyURL.isEmpty()) {

#endif
    
    bool needPrivacy = m_frame.settings().privateBrowsingEnabled();
    const URL& historyURL = m_frame.loader().documentLoader()->urlForHistory();

    if (m_frame.loader().documentLoader()->isClientRedirect()) {
        if (!m_currentItem && !m_frame.tree().parent()) {

    }

    bool needPrivacy = m_frame.settings().privateBrowsingEnabled();
    const URL& historyURL = m_frame.loader().documentLoader()->urlForHistory();

    if (!historyURL.isEmpty() && !needPrivacy) {
        if (Page* page = m_frame.page())

    DocumentLoader* documentLoader = m_frame.loader().documentLoader();
    ASSERT(documentLoader);

    URL unreachableURL = documentLoader->unreachableURL();

    URL url;
    URL originalURL;

    if (!unreachableURL.isEmpty()) {
        url = unreachableURL;

    if (m_frame.settings().privateBrowsingEnabled())
        return;

    addVisitedLink(page, URL(ParsedURLString, urlString));
    m_frame.loader().client().updateGlobalHistory();

}

        return;

    ASSERT(m_frame.page());
    addVisitedLink(m_frame.page(), URL(ParsedURLString, urlString));
    m_frame.loader().client().updateGlobalHistory();
}




    m_cachedLinkResource = 0;
}

bool LinkLoader::loadLink(const LinkRelAttribute& relAttribute, const String& type, const String& sizes, const URL& href, Document* document)
                          const String& sizes, const KURL& href, Document* document)
{
    // We'll record this URL per document, even if we later only use it in top level frames
    if (relAttribute.m_iconType != InvalidIcon && href.isValid() && !href.isEmpty()) {



namespace WebCore {

class Document;
class URL;
struct LinkRelAttribute;

// The LinkLoader can load link rel types icon, dns-prefetch, subresource and prefetch.

    virtual void notifyFinished(CachedResource*);

    void released();
    bool loadLink(const LinkRelAttribute&, const String& type, const String& sizes, const URL&, Document*);

private:
    void linkLoadTimerFired(Timer<LinkLoader>*);



}

// static
bool MixedContentChecker::isMixedContent(SecurityOrigin* securityOrigin, const URL& url)
{
    if (securityOrigin->protocol() != "https")
        return false; // We only care about HTTPS security origins.

    return !SecurityOrigin::isSecure(url);
}

bool MixedContentChecker::canDisplayInsecureContent(SecurityOrigin* securityOrigin, const URL& url) const
{
    if (!isMixedContent(securityOrigin, url))
        return true;

    return allowed;
}

bool MixedContentChecker::canRunInsecureContent(SecurityOrigin* securityOrigin, const URL& url) const
{
    if (!isMixedContent(securityOrigin, url))
        return true;

    return allowed;
}

void MixedContentChecker::logWarning(bool allowed, const String& action, const URL& target) const
{
    String message = makeString((allowed ? "" : "[blocked] "), "The page at ", m_frame->document()->url().stringCenterEllipsizedToLength(), " ", action, " insecure content from ", target.stringCenterEllipsizedToLength(), ".\n");
    m_frame->document()->addConsoleMessage(SecurityMessageSource, WarningMessageLevel, message);




class Frame;
class FrameLoaderClient;
class URL;
class SecurityOrigin;

class MixedContentChecker {

public:
    MixedContentChecker(Frame*);

    bool canDisplayInsecureContent(SecurityOrigin*, const URL&) const;
    bool canRunInsecureContent(SecurityOrigin*, const URL&) const;
    static bool isMixedContent(SecurityOrigin*, const URL&);

private:
    // FIXME: This should probably have a separate client from FrameLoader.
    FrameLoaderClient& client() const;

    void logWarning(bool allowed, const String& action, const URL&) const;

    Frame* m_frame;
};




#include "Event.h"
#include "FrameLoaderTypes.h"
#include "URL.h"
#include "ResourceRequest.h"
#include <wtf/Forward.h>



        bool isEmpty() const { return m_resourceRequest.url().isEmpty(); }

        URL url() const { return m_resourceRequest.url(); }
        const ResourceRequest& resourceRequest() const { return m_resourceRequest; }

        NavigationType type() const { return m_type; }



    virtual void fire(Frame* frame)
    {
        UserGestureIndicator gestureIndicator(wasUserGesture() ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
        frame->loader().changeLocation(m_securityOrigin.get(), URL(ParsedURLString, m_url), m_referrer, lockHistory(), lockBackForwardList(), false);
    }

    virtual void didStartTimer(Frame* frame, Timer<NavigationScheduler>* timer)

        m_haveToldClient = true;

        UserGestureIndicator gestureIndicator(wasUserGesture() ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
        frame->loader().clientRedirected(URL(ParsedURLString, m_url), delay(), currentTime() + timer->nextFireInterval(), lockBackForwardList());
    }

    virtual void didStopTimer(Frame* frame, bool newLoadInProgress)

    virtual void fire(Frame* frame)
    {
        UserGestureIndicator gestureIndicator(wasUserGesture() ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
        bool refresh = equalIgnoringFragmentIdentifier(frame->document()->url(), URL(ParsedURLString, url()));
        frame->loader().changeLocation(securityOrigin(), URL(ParsedURLString, url()), referrer(), lockHistory(), lockBackForwardList(), refresh);
    }
};


    virtual void fire(Frame* frame)
    {
        UserGestureIndicator gestureIndicator(wasUserGesture() ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
        frame->loader().changeLocation(securityOrigin(), URL(ParsedURLString, url()), referrer(), lockHistory(), lockBackForwardList(), true);
    }
};



    // If the URL we're going to navigate to is the same as the current one, except for the
    // fragment part, we don't need to schedule the location change.
    URL parsedURL(ParsedURLString, url);
    if (parsedURL.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(m_frame->document()->url(), parsedURL)) {
        loader.changeLocation(securityOrigin, m_frame->document()->completeURL(url), referrer, lockHistory, lockBackForwardList);
        return;

{
    if (!shouldScheduleNavigation())
        return;
    const URL& url = m_frame->document()->url();
    if (url.isEmpty())
        return;





namespace WebCore {

void PingLoader::loadImage(Frame* frame, const URL& url)
{
    if (!frame->document()->securityOrigin()->canDisplay(url)) {
        FrameLoader::reportLocalLoadFailed(frame, url);

}

// http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html#hyperlink-auditing
void PingLoader::sendPing(Frame* frame, const URL& pingURL, const URL& destinationURL)
{
    ResourceRequest request(pingURL);
#if PLATFORM(BLACKBERRY)

    UNUSED_PARAM(leakedPingLoader);
}

void PingLoader::sendViolationReport(Frame* frame, const URL& reportURL, PassRefPtr<FormData> report)
{
    ResourceRequest request(reportURL);
#if PLATFORM(BLACKBERRY)




class FormData;
class Frame;
class URL;
class ResourceError;
class ResourceHandle;
class ResourceResponse;

class PingLoader : private ResourceHandleClient {
    WTF_MAKE_NONCOPYABLE(PingLoader); WTF_MAKE_FAST_ALLOCATED;
public:
    static void loadImage(Frame*, const URL& url);
    static void sendPing(Frame*, const URL& pingURL, const URL& destinationURL);
    static void sendViolationReport(Frame*, const URL& reportURL, PassRefPtr<FormData> report);

    virtual ~PingLoader();





class PlaceholderDocument FINAL : public Document {
public:
    static PassRefPtr<PlaceholderDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new PlaceholderDocument(frame, url));
    }

private:
    virtual void createRenderTree() OVERRIDE;

    PlaceholderDocument(Frame* frame, const URL& url)
        : Document(frame, url)
    {
    }



#include "Frame.h"
#include "FrameLoader.h"
#include "InspectorInstrumentation.h"
#include "URL.h"
#include "LoaderStrategy.h"
#include "Logging.h"
#include "NetscapePlugInStreamLoader.h"

// Match the parallel connection count used by the networking layer.
static unsigned maxRequestsInFlightPerHost;

ResourceLoadScheduler::HostInformation* ResourceLoadScheduler::hostForURL(const URL& url, CreateHostPolicy createHostPolicy)
{
    if (!url.protocolIsInHTTPFamily())
        return m_nonHTTPProtocolHost;

    scheduleServePendingRequests();
}

void ResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader* resourceLoader, const URL& redirectURL)
{
    HostInformation* oldHost = hostForURL(resourceLoader->url());
    ASSERT(oldHost);




class CachedResource;
class Frame;
class URL;
class NetscapePlugInStreamLoader;
class NetscapePlugInStreamLoaderClient;
class ResourceLoader;

    virtual PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, CachedResource*, const ResourceRequest&, ResourceLoadPriority, const ResourceLoaderOptions&);
    virtual PassRefPtr<NetscapePlugInStreamLoader> schedulePluginStreamLoad(Frame*, NetscapePlugInStreamLoaderClient*, const ResourceRequest&);
    virtual void remove(ResourceLoader*);
    virtual void crossOriginRedirectReceived(ResourceLoader*, const URL& redirectURL);
    
    virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriorityVeryLow);
    virtual void suspendPendingRequests();

        FindOnly
    };
    
    HostInformation* hostForURL(const URL&, CreateHostPolicy = FindOnly);
    void servePendingRequests(HostInformation*, ResourceLoadPriority);

    typedef HashMap<String, HostInformation*, StringHash> HostMap;



class DocumentLoader;
class Frame;
class FrameLoader;
class URL;
class ResourceBuffer;
class ResourceHandle;


    virtual bool shouldCacheResponse(ResourceHandle*, CFCachedURLResponseRef) OVERRIDE;
#endif

    const URL& url() const { return m_request.url(); } 
    ResourceHandle* handle() const { return m_handle.get(); }
    bool shouldSendResourceLoadCallbacks() const { return m_options.sendLoadCallbacks == SendCallbacks; }
    void setSendCallbackPolicy(SendCallbackPolicy sendLoadCallbacks) { m_options.sendLoadCallbacks = sendLoadCallbacks; }

Lines 47-53 private: a/Source/WebCore/loader/SinkDocument.cpp_sec1
- a/Source/WebCore/loader/SinkDocument.cpp -1 / +1 lines
47	virtual void appendBytes(DocumentWriter, const char, size_t) { }	47	virtual void appendBytes(DocumentWriter, const char, size_t) { }
48	};	48	};
49		49
50	SinkDocument::SinkDocument(Frame* frame, const KURL& url)	50	SinkDocument::SinkDocument(Frame* frame, const URL& url)
51	: HTMLDocument(frame, url)	51	: HTMLDocument(frame, url)
52	{	52	{
53	setCompatibilityMode(QuirksMode);	53	setCompatibilityMode(QuirksMode);




class SinkDocument FINAL : public HTMLDocument {
public:
    static PassRefPtr<SinkDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new SinkDocument(frame, url));
    }

private:
    SinkDocument(Frame*, const URL&);
    
    virtual PassRefPtr<DocumentParser> createParser();
};



bool SubframeLoader::requestFrame(HTMLFrameOwnerElement* ownerElement, const String& urlString, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList)
{
    // Support for <frame src="javascript:string">
    URL scriptURL;
    URL url;
    if (protocolIsJavaScript(urlString)) {
        scriptURL = completeURL(urlString); // completeURL() encodes the URL.
        url = blankURL();

    
bool SubframeLoader::resourceWillUsePlugin(const String& url, const String& mimeType, bool shouldPreferPlugInsForImages)
{
    URL completedURL;
    if (!url.isEmpty())
        completedURL = completeURL(url);


    return shouldUsePlugin(completedURL, mimeType, shouldPreferPlugInsForImages, false, useFallback);
}

bool SubframeLoader::pluginIsLoadable(HTMLPlugInImageElement* pluginElement, const URL& url, const String& mimeType)
{
    if (MIMETypeRegistry::isJavaAppletMIMEType(mimeType)) {
        if (!m_frame->settings().isJavaEnabled())

    return true;
}

bool SubframeLoader::requestPlugin(HTMLPlugInImageElement* ownerElement, const URL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
{
    // Application plug-ins are plug-ins implemented by the user agent, for example Qt plug-ins,
    // as opposed to third-party code such as Flash. The user agent decides whether or not they are

    if (!renderer)
        return false;

    URL completedURL;
    if (!url.isEmpty())
        completedURL = completeURL(url);


}

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
PassRefPtr<Widget> SubframeLoader::loadMediaPlayerProxyPlugin(Node* node, const URL& url,
    const Vector<String>& paramNames, const Vector<String>& paramValues)
{
    ASSERT(node->hasTagName(videoTag) || isHTMLAudioElement(node));

    URL completedURL;
    if (!url.isEmpty())
        completedURL = completeURL(url);


    }

    if (!codeBaseURLString.isEmpty()) {
        URL codeBaseURL = completeURL(codeBaseURLString);
        if (!element->document().securityOrigin()->canDisplay(codeBaseURL)) {
            FrameLoader::reportLocalLoadFailed(m_frame, codeBaseURL.string());
            return 0;


    if (baseURLString.isEmpty())
        baseURLString = m_frame->document()->baseURL().string();
    URL baseURL = completeURL(baseURLString);

    RefPtr<Widget> widget;
    if (allowPlugins(AboutToInstantiatePlugin))

    return widget;
}

Frame* SubframeLoader::loadOrRedirectSubframe(HTMLFrameOwnerElement* ownerElement, const URL& url, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList)
{
    Frame* frame = ownerElement->contentFrame();
    if (frame)

    return ownerElement->contentFrame();
}

Frame* SubframeLoader::loadSubframe(HTMLFrameOwnerElement* ownerElement, const URL& url, const String& name, const String& referrer)
{
    RefPtr<Frame> protect(m_frame);


    return allowed;
}

bool SubframeLoader::shouldUsePlugin(const URL& url, const String& mimeType, bool shouldPreferPlugInsForImages, bool hasFallback, bool& useFallback)
{
    if (m_frame->loader().client().shouldAlwaysUsePluginDocument(mimeType)) {
        useFallback = false;

    return m_frame->document();
}

bool SubframeLoader::loadPlugin(HTMLPlugInImageElement* pluginElement, const URL& url, const String& mimeType,
    const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
{
    RenderEmbeddedObject* renderer = pluginElement->renderEmbeddedObject();

    return true;
}

URL SubframeLoader::completeURL(const String& url) const
{
    ASSERT(m_frame->document());
    return m_frame->document()->completeURL(url);



class HTMLFrameOwnerElement;
class HTMLPlugInImageElement;
class IntSize;
class URL;
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
class Node;
#endif

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
    // FIXME: This should take Element* instead of Node*, or better yet the
    // specific type of Element which this code depends on.
    PassRefPtr<Widget> loadMediaPlayerProxyPlugin(Node*, const URL&, const Vector<String>& paramNames, const Vector<String>& paramValues);
#endif

    PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const Vector<String>& paramNames, const Vector<String>& paramValues);

    bool resourceWillUsePlugin(const String& url, const String& mimeType, bool shouldPreferPlugInsForImages);

private:
    bool requestPlugin(HTMLPlugInImageElement*, const URL&, const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
    Frame* loadOrRedirectSubframe(HTMLFrameOwnerElement*, const URL&, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList);
    Frame* loadSubframe(HTMLFrameOwnerElement*, const URL&, const String& name, const String& referrer);
    bool loadPlugin(HTMLPlugInImageElement*, const URL&, const String& mimeType,
        const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);

    bool shouldUsePlugin(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages, bool hasFallback, bool& useFallback);
    bool pluginIsLoadable(HTMLPlugInImageElement*, const URL&, const String& mimeType);

    Document* document() const;

    bool m_containsPlugins;
    Frame* m_frame;

    URL completeURL(const String&) const;
};

} // namespace WebCore

Lines 123-129 bool SubresourceLoader::isSubresourceLoader() a/Source/WebCore/loader/SubresourceLoader.cpp_sec1
- a/Source/WebCore/loader/SubresourceLoader.cpp -1 / +1 lines
123	void SubresourceLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)	123	void SubresourceLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
124	{	124	{
125	// Store the previous URL because the call to ResourceLoader::willSendRequest will modify it.	125	// Store the previous URL because the call to ResourceLoader::willSendRequest will modify it.
126	KURL previousURL = request().url();	126	URL previousURL = request().url();
127	Ref<SubresourceLoader> protect(*this);	127	Ref<SubresourceLoader> protect(*this);
128		128
129	ASSERT(!newRequest.isNull());	129	ASSERT(!newRequest.isNull());



#ifndef SubstituteData_h
#define SubstituteData_h

#include "URL.h"
#include "SharedBuffer.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>

        }

        SubstituteData(PassRefPtr<SharedBuffer> content, const String& mimeType,
                const String& textEncoding, const URL& failingURL,
                const URL& responseURL = URL(), bool shouldRevealToSessionHistory = false)
            : m_content(content)
            , m_mimeType(mimeType)
            , m_textEncoding(textEncoding)

        const SharedBuffer* content() const { return m_content.get(); }
        const String& mimeType() const { return m_mimeType; }
        const String& textEncoding() const { return m_textEncoding; }
        const URL& failingURL() const { return m_failingURL; }
        const URL& responseURL() const { return m_responseURL; }
        
    private:
        RefPtr<SharedBuffer> m_content;
        String m_mimeType;
        String m_textEncoding;
        URL m_failingURL;
        URL m_responseURL;
        bool m_shouldRevealToSessionHistory;
    };





#include <wtf/RefCounted.h>

#include "URL.h"
#include "ResourceResponse.h"
#include "SharedBuffer.h"


public:
    virtual ~SubstituteResource() { }

    const URL& url() const { return m_url; }
    const ResourceResponse& response() const { return m_response; }
    SharedBuffer* data() const { return m_data.get(); }

protected:
    SubstituteResource(const URL& url, const ResourceResponse& response, PassRefPtr<SharedBuffer> data)
        : m_url(url)
        , m_response(response)
        , m_data(data)

    }
    
private:
    URL m_url;
    ResourceResponse m_response;
    RefPtr<SharedBuffer> m_data;
};

Lines 146-152 void TextTrackLoader::notifyFinished(CachedResource* resource) a/Source/WebCore/loader/TextTrackLoader.cpp_sec1
- a/Source/WebCore/loader/TextTrackLoader.cpp -1 / +1 lines
146	cancelLoad();	146	cancelLoad();
147	}	147	}
148		148
149	bool TextTrackLoader::load(const KURL& url, const String& crossOriginMode)	149	bool TextTrackLoader::load(const URL& url, const String& crossOriginMode)
150	{	150	{
151	cancelLoad();	151	cancelLoad();
152		152

Lines 64-70 public: a/Source/WebCore/loader/TextTrackLoader.h_sec1
- a/Source/WebCore/loader/TextTrackLoader.h -1 / +1 lines
64	}	64	}
65	virtual ~TextTrackLoader();	65	virtual ~TextTrackLoader();
66		66
67	bool load(const KURL&, const String& crossOriginMode);	67	bool load(const URL&, const String& crossOriginMode);
68	void cancelLoad();	68	void cancelLoad();
69	void getNewCues(Vector<RefPtr<TextTrackCue> >& outputCues);	69	void getNewCues(Vector<RefPtr<TextTrackCue> >& outputCues);
70	#if ENABLE(WEBVTT_REGIONS)	70	#if ENABLE(WEBVTT_REGIONS)




namespace WebCore {
 
static inline bool fallbackURLLongerThan(const std::pair<URL, URL>& lhs, const std::pair<URL, URL>& rhs)
{
    return lhs.first.string().length() > rhs.first.string().length();
}

    
ApplicationCacheResource* ApplicationCache::resourceForURL(const String& url)
{
    ASSERT(!URL(ParsedURLString, url).hasFragmentIdentifier());
    return m_resources.get(url);
}    


    if (!requestIsHTTPOrHTTPSGet(request))
        return 0;

    URL url(request.url());
    if (url.hasFragmentIdentifier())
        url.removeFragmentIdentifier();

    return resourceForURL(url);
}

void ApplicationCache::setOnlineWhitelist(const Vector<URL>& onlineWhitelist)
{
    ASSERT(m_onlineWhitelist.isEmpty());
    m_onlineWhitelist = onlineWhitelist; 
}

bool ApplicationCache::isURLInOnlineWhitelist(const URL& url)
{
    size_t whitelistSize = m_onlineWhitelist.size();
    for (size_t i = 0; i < whitelistSize; ++i) {

    std::stable_sort(m_fallbackURLs.begin(), m_fallbackURLs.end(), fallbackURLLongerThan);
}

bool ApplicationCache::urlMatchesFallbackNamespace(const URL& url, URL* fallbackURL)
{
    size_t fallbackCount = m_fallbackURLs.size();
    for (size_t i = 0; i < fallbackCount; ++i) {

    
void ApplicationCache::deleteCacheForOrigin(SecurityOrigin* origin)
{
    Vector<URL> urls;
    if (!cacheStorage().manifestURLs(&urls)) {
        LOG_ERROR("Failed to retrieve ApplicationCache manifest URLs");
        return;
    }

    URL originURL(URL(), origin->toString());

    size_t count = urls.size();
    for (size_t i = 0; i < count; ++i) {



class ApplicationCacheGroup;
class ApplicationCacheResource;
class DocumentLoader;
class URL;
class ResourceRequest;
class SecurityOrigin;

typedef Vector<std::pair<URL, URL> > FallbackURLVector;

class ApplicationCache : public RefCounted<ApplicationCache> {
public:


    void setAllowsAllNetworkRequests(bool value) { m_allowAllNetworkRequests = value; }
    bool allowsAllNetworkRequests() const { return m_allowAllNetworkRequests; }
    void setOnlineWhitelist(const Vector<URL>& onlineWhitelist);
    const Vector<URL>& onlineWhitelist() const { return m_onlineWhitelist; }
    bool isURLInOnlineWhitelist(const URL&); // There is an entry in online whitelist that has the same origin as the resource's URL and that is a prefix match for the resource's URL.

    void setFallbackURLs(const FallbackURLVector&);
    const FallbackURLVector& fallbackURLs() const { return m_fallbackURLs; }
    bool urlMatchesFallbackNamespace(const URL&, URL* fallbackURL = 0);
    
#ifndef NDEBUG
    void dump();

    ApplicationCacheResource* m_manifest;

    bool m_allowAllNetworkRequests;
    Vector<URL> m_onlineWhitelist;
    FallbackURLVector m_fallbackURLs;

    // The total size of the resources belonging to this Application Cache instance.




namespace WebCore {

ApplicationCacheGroup::ApplicationCacheGroup(const URL& manifestURL, bool isCopy)
    : m_manifestURL(manifestURL)
    , m_origin(SecurityOrigin::create(manifestURL))
    , m_updateStatus(Idle)

    if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
        return 0;

    URL url(request.url());
    if (url.hasFragmentIdentifier())
        url.removeFragmentIdentifier();


    if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
        return 0;

    URL url(request.url());
    if (url.hasFragmentIdentifier())
        url.removeFragmentIdentifier();


    return 0;
}

void ApplicationCacheGroup::selectCache(Frame* frame, const URL& passedManifestURL)
{
    ASSERT(frame && frame->page());
    

        return;
    }

    URL manifestURL(passedManifestURL);
    if (manifestURL.hasFragmentIdentifier())
        manifestURL.removeFragmentIdentifier();


            mainResourceCache->group()->update(frame, ApplicationCacheUpdateWithBrowsingContext);
        } else {
            // The main resource was loaded from cache, so the cache must have an entry for it. Mark it as foreign.
            URL resourceURL(documentLoader->responseURL());
            if (resourceURL.hasFragmentIdentifier())
                resourceURL.removeFragmentIdentifier();
            ApplicationCacheResource* resource = mainResourceCache->resourceForURL(resourceURL);

{
    ASSERT(m_pendingMasterResourceLoaders.contains(loader));
    ASSERT(m_completionType == None || m_pendingEntries.isEmpty());
    URL url = loader->url();
    if (url.hasFragmentIdentifier())
        url.removeFragmentIdentifier();


    cacheUpdateFailed();
}

PassRefPtr<ResourceHandle> ApplicationCacheGroup::createResourceHandle(const URL& url, ApplicationCacheResource* newestCachedResource)
{
    ResourceRequest request(url);
    m_frame->loader().applyUserAgent(request);

    
    ASSERT(handle == m_currentHandle);

    URL url(handle->firstRequest().url());
    if (url.hasFragmentIdentifier())
        url.removeFragmentIdentifier();
    

    ASSERT(handle == m_currentHandle);

    unsigned type = m_currentResource ? m_currentResource->type() : m_pendingEntries.get(handle->firstRequest().url());
    URL url(handle->firstRequest().url());
    if (url.hasFragmentIdentifier())
        url.removeFragmentIdentifier();



    ASSERT(!m_currentHandle);
    
    m_currentHandle = createResourceHandle(URL(ParsedURLString, it->key), m_newestCache ? m_newestCache->resourceForURL(it->key) : 0);
}

void ApplicationCacheGroup::deliverDelayedMainResources()

void ApplicationCacheGroup::addEntry(const String& url, unsigned type)
{
    ASSERT(m_cacheBeingUpdated);
    ASSERT(!URL(ParsedURLString, url).hasFragmentIdentifier());
    
    // Don't add the URL if we already have an master resource in the cache
    // (i.e., the main resource finished loading before the manifest).



#define ApplicationCacheGroup_h

#include "DOMApplicationCache.h"
#include "URL.h"
#include "ResourceHandleClient.h"
#include "SharedBuffer.h"
#include <wtf/Noncopyable.h>

class ApplicationCacheGroup : ResourceHandleClient {
    WTF_MAKE_NONCOPYABLE(ApplicationCacheGroup); WTF_MAKE_FAST_ALLOCATED;
public:
    ApplicationCacheGroup(const URL& manifestURL, bool isCopy = false);    
    ~ApplicationCacheGroup();
    
    enum UpdateStatus { Idle, Checking, Downloading };

    static ApplicationCache* cacheForMainRequest(const ResourceRequest&, DocumentLoader*);
    static ApplicationCache* fallbackCacheForMainRequest(const ResourceRequest&, DocumentLoader*);
    
    static void selectCache(Frame*, const URL& manifestURL);
    static void selectCacheWithoutManifestURL(Frame*);
    
    const URL& manifestURL() const { return m_manifestURL; }
    const SecurityOrigin* origin() const { return m_origin.get(); }
    UpdateStatus updateStatus() const { return m_updateStatus; }
    void setUpdateStatus(UpdateStatus status);


    void scheduleReachedMaxAppCacheSizeCallback();

    PassRefPtr<ResourceHandle> createResourceHandle(const URL&, ApplicationCacheResource* newestCachedResource);

    // For normal resource loading, WebKit client is asked about each resource individually. Since application cache does not belong to any particular document,
    // the existing client callback cannot be used, so assume that any client that enables application cache also wants it to use credential storage.

    
    void stopLoading();
    
    URL m_manifestURL;
    RefPtr<SecurityOrigin> m_origin;
    UpdateStatus m_updateStatus;
    



    ApplicationCacheGroup::selectCacheWithoutManifestURL(m_documentLoader->frame());
}

void ApplicationCacheHost::selectCacheWithManifest(const URL& manifestURL)
{
    ApplicationCacheGroup::selectCache(m_documentLoader->frame(), manifestURL);
}

            substituteData = SubstituteData(resource->data(),
                                            resource->response().mimeType(),
                                            resource->response().textEncodingName(),
                                            URL(),
                                            URL(),
                                            SubstituteData::ShouldRevealToSessionHistory);
        }
    }

        group->finishedLoadingMainResource(m_documentLoader);
}

bool ApplicationCacheHost::maybeLoadResource(ResourceLoader* loader, ResourceRequest& request, const URL& originalURL)
{
    if (!isApplicationCacheEnabled())
        return false;

{
    ApplicationCache* cache = applicationCache();
    if (!cache || !cache->isComplete())
        return CacheInfo(URL(), 0, 0, 0);
  
    // FIXME: Add "Creation Time" and "Update Time" to Application Caches.
    return CacheInfo(cache->manifestResource()->url(), 0, 0, cache->estimatedSizeInStorage());

    if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
        return false;

    URL fallbackURL;
    if (cache->isURLInOnlineWhitelist(request.url()))
        return false;
    if (!cache->urlMatchesFallbackNamespace(request.url(), &fallbackURL))



#ifndef ApplicationCacheHost_h
#define ApplicationCacheHost_h

#include "URL.h"
#include <wtf/Deque.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassRefPtr.h>


#if ENABLE(INSPECTOR)
        struct CacheInfo {
            CacheInfo(const URL& manifest, double creationTime, double updateTime, long long size)
                : m_manifest(manifest)
                , m_creationTime(creationTime)
                , m_updateTime(updateTime)
                , m_size(size) { }
            URL m_manifest;
            double m_creationTime;
            double m_updateTime;
            long long m_size;
        };

        struct ResourceInfo {
            ResourceInfo(const URL& resource, bool isMaster, bool isManifest, bool isFallback, bool isForeign, bool isExplicit, long long size)
                : m_resource(resource)
                , m_isMaster(isMaster)
                , m_isManifest(isManifest)

                , m_isForeign(isForeign)
                , m_isExplicit(isExplicit)
                , m_size(size) { }
            URL m_resource;
            bool m_isMaster;
            bool m_isManifest;
            bool m_isFallback;

        ~ApplicationCacheHost();

        void selectCacheWithoutManifest();
        void selectCacheWithManifest(const URL& manifestURL);

        void maybeLoadMainResource(ResourceRequest&, SubstituteData&);
        void maybeLoadMainResourceForRedirect(ResourceRequest&, SubstituteData&);

        void finishedLoadingMainResource();
        void failedLoadingMainResource();

        bool maybeLoadResource(ResourceLoader*, ResourceRequest&, const URL& originalURL);
        bool maybeLoadFallbackForRedirect(ResourceLoader*, ResourceRequest&, const ResourceResponse&);
        bool maybeLoadFallbackForResponse(ResourceLoader*, const ResourceResponse&);
        bool maybeLoadFallbackForError(ResourceLoader*, const ResourceError&);

Lines 29-35 a/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp_sec1
- a/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp -1 / +1 lines
29		29
30	namespace WebCore {	30	namespace WebCore {
31		31
32	ApplicationCacheResource::ApplicationCacheResource(const KURL& url, const ResourceResponse& response, unsigned type, PassRefPtr<SharedBuffer> data, const String& path)	32	ApplicationCacheResource::ApplicationCacheResource(const URL& url, const ResourceResponse& response, unsigned type, PassRefPtr<SharedBuffer> data, const String& path)
33	: SubstituteResource(url, response, data)	33	: SubstituteResource(url, response, data)
34	, m_type(type)	34	, m_type(type)
35	, m_storageID(0)	35	, m_storageID(0)



        Fallback = 1 << 4
    };
        
    static PassRefPtr<ApplicationCacheResource> create(const URL& url, const ResourceResponse& response, unsigned type, PassRefPtr<SharedBuffer> buffer = SharedBuffer::create(), const String& path = String())
    {
        ASSERT(!url.hasFragmentIdentifier());
        return adoptRef(new ApplicationCacheResource(url, response, type, buffer, path));

#endif
    
private:
    ApplicationCacheResource(const URL&, const ResourceResponse&, unsigned type, PassRefPtr<SharedBuffer>, const String& path);

    unsigned m_type;
    unsigned m_storageID;



#include "ApplicationCacheHost.h"
#include "ApplicationCacheResource.h"
#include "FileSystem.h"
#include "URL.h"
#include "NotImplemented.h"
#include "SQLiteStatement.h"
#include "SQLiteTransaction.h"

    Vector<Record> m_records;
};

static unsigned urlHostHash(const URL& url)
{
    unsigned hostStart = url.hostStart();
    unsigned hostEnd = url.hostEnd();

    return AlreadyHashed::avoidDeletedValue(StringHasher::computeHashAndMaskTop8Bits(urlString.characters16() + hostStart, hostEnd - hostStart));
}

ApplicationCacheGroup* ApplicationCacheStorage::loadCacheGroup(const URL& manifestURL)
{
    openDatabase(false);
    if (!m_database.isOpen())

    return group;
}    

ApplicationCacheGroup* ApplicationCacheStorage::findOrCreateCacheGroup(const URL& manifestURL)
{
    ASSERT(!manifestURL.hasFragmentIdentifier());


    return group;
}

ApplicationCacheGroup* ApplicationCacheStorage::findInMemoryCacheGroup(const URL& manifestURL) const
{
    return m_cachesInMemory.get(manifestURL);
}

        m_cacheHostSet.add(static_cast<unsigned>(statement.getColumnInt64(0)));
}    

ApplicationCacheGroup* ApplicationCacheStorage::cacheGroupForURL(const URL& url)
{
    ASSERT(!url.hasFragmentIdentifier());
    

    
    int result;
    while ((result = statement.step()) == SQLResultRow) {
        URL manifestURL = URL(ParsedURLString, statement.getColumnText(1));

        if (m_cachesInMemory.contains(manifestURL))
            continue;

    return 0;
}

ApplicationCacheGroup* ApplicationCacheStorage::fallbackCacheGroupForURL(const URL& url)
{
    ASSERT(!url.hasFragmentIdentifier());


        ASSERT(!group->isObsolete());

        if (ApplicationCache* cache = group->newestCache()) {
            URL fallbackURL;
            if (cache->isURLInOnlineWhitelist(url))
                continue;
            if (!cache->urlMatchesFallbackNamespace(url, &fallbackURL))

    
    int result;
    while ((result = statement.step()) == SQLResultRow) {
        URL manifestURL = URL(ParsedURLString, statement.getColumnText(1));

        if (m_cachesInMemory.contains(manifestURL))
            continue;

        unsigned newestCacheID = static_cast<unsigned>(statement.getColumnInt64(2));
        RefPtr<ApplicationCache> cache = loadCache(newestCacheID);

        URL fallbackURL;
        if (cache->isURLInOnlineWhitelist(url))
            continue;
        if (!cache->urlMatchesFallbackNamespace(url, &fallbackURL))

    }
    
    // Store the online whitelist
    const Vector<URL>& onlineWhitelist = cache->onlineWhitelist();
    {
        size_t whitelistSize = onlineWhitelist.size();
        for (size_t i = 0; i < whitelistSize; ++i) {


    int result;
    while ((result = cacheStatement.step()) == SQLResultRow) {
        URL url(ParsedURLString, cacheStatement.getColumnText(0));
        
        int httpStatusCode = cacheStatement.getColumnInt(1);


        return 0;
    whitelistStatement.bindInt64(1, storageID);
    
    Vector<URL> whitelist;
    while ((result = whitelistStatement.step()) == SQLResultRow) 
        whitelist.append(URL(ParsedURLString, whitelistStatement.getColumnText(0)));

    if (result != SQLResultDone)
        LOG_ERROR("Could not load cache online whitelist, error \"%s\"", m_database.lastErrorMsg());

    
    FallbackURLVector fallbackURLs;
    while ((result = fallbackStatement.step()) == SQLResultRow) 
        fallbackURLs.append(make_pair(URL(ParsedURLString, fallbackStatement.getColumnText(0)), URL(ParsedURLString, fallbackStatement.getColumnText(1))));

    if (result != SQLResultDone)
        LOG_ERROR("Could not load fallback URLs, error \"%s\"", m_database.lastErrorMsg());

    return copyStorage.storeNewestCache(groupCopy.get());
}

bool ApplicationCacheStorage::manifestURLs(Vector<URL>* urls)
{
    ASSERT(urls);
    openDatabase(false);

        return false;

    while (selectURLs.step() == SQLResultRow)
        urls->append(URL(ParsedURLString, selectURLs.getColumnText(0)));

    return true;
}


void ApplicationCacheStorage::getOriginsWithCache(HashSet<RefPtr<SecurityOrigin> >& origins)
{
    Vector<URL> urls;
    if (!manifestURLs(&urls)) {
        LOG_ERROR("Failed to retrieve ApplicationCache manifest URLs");
        return;



class ApplicationCacheGroup;
class ApplicationCacheHost;
class ApplicationCacheResource;
class URL;
class SecurityOrigin;
class SharedBuffer;
template <class T> class StorageIDJournal;

    bool storeUpdatedQuotaForOrigin(const SecurityOrigin*, int64_t quota);
    bool checkOriginQuota(ApplicationCacheGroup*, ApplicationCache* oldCache, ApplicationCache* newCache, int64_t& totalSpaceNeeded);

    ApplicationCacheGroup* cacheGroupForURL(const URL&); // Cache to load a main resource from.
    ApplicationCacheGroup* fallbackCacheGroupForURL(const URL&); // Cache that has a fallback entry to load a main resource from if normal loading fails.

    ApplicationCacheGroup* findOrCreateCacheGroup(const URL& manifestURL);
    ApplicationCacheGroup* findInMemoryCacheGroup(const URL& manifestURL) const;
    void cacheGroupDestroyed(ApplicationCacheGroup*);
    void cacheGroupMadeObsolete(ApplicationCacheGroup*);
        

    
    static bool storeCopyOfCache(const String& cacheDirectory, ApplicationCacheHost*);

    bool manifestURLs(Vector<URL>* urls);
    bool cacheGroupSize(const String& manifestURL, int64_t* size);
    bool deleteCacheGroup(const String& manifestURL);
    void vacuumDatabaseFile();

private:
    ApplicationCacheStorage();
    PassRefPtr<ApplicationCache> loadCache(unsigned storageID);
    ApplicationCacheGroup* loadCacheGroup(const URL& manifestURL);
    
    typedef StorageIDJournal<ApplicationCacheResource> ResourceStorageIDJournal;
    typedef StorageIDJournal<ApplicationCacheGroup> GroupStorageIDJournal;

Lines 41-47 a/Source/WebCore/loader/appcache/DOMApplicationCache.h_sec1
- a/Source/WebCore/loader/appcache/DOMApplicationCache.h -1 / +1 lines
41	namespace WebCore {	41	namespace WebCore {
42		42
43	class Frame;	43	class Frame;
44	class KURL;	44	class URL;
45		45
46	// FIXME: This class should be marked FINAL once <http://webkit.org/b/121747> is fixed.	46	// FIXME: This class should be marked FINAL once <http://webkit.org/b/121747> is fixed.
47	class DOMApplicationCache : public ScriptWrappable, public RefCounted<DOMApplicationCache>, public EventTargetWithInlineData, public DOMWindowProperty {	47	class DOMApplicationCache : public ScriptWrappable, public RefCounted<DOMApplicationCache>, public EventTargetWithInlineData, public DOMWindowProperty {



#include "config.h"
#include "ManifestParser.h"

#include "KURL.h"
#include "TextResourceDecoder.h"
#include "URL.h"
#include <wtf/unicode/CharacterNames.h>

using namespace std;


enum Mode { Explicit, Fallback, OnlineWhitelist, Unknown };
    
bool parseManifest(const URL& manifestURL, const char* data, int length, Manifest& manifest)
{
    ASSERT(manifest.explicitURLs.isEmpty());
    ASSERT(manifest.onlineWhitelistedURLs.isEmpty());

                continue;
            }

            URL url(manifestURL, String(line.characters(), p - line.characters()));
            
            if (!url.isValid())
                continue;

                continue;
            }
            
            URL namespaceURL(manifestURL, String(line.characters(), p - line.characters()));
            if (!namespaceURL.isValid())
                continue;
            if (namespaceURL.hasFragmentIdentifier())

            while (p < lineEnd && *p != '\t' && *p != ' ') 
                p++;

            URL fallbackURL(manifestURL, String(fallbackStart, p - fallbackStart));
            if (!fallbackURL.isValid())
                continue;
            if (fallbackURL.hasFragmentIdentifier())




namespace WebCore {

    class URL;

    struct Manifest {
        Vector<URL> onlineWhitelistedURLs;
        HashSet<String> explicitURLs;
        FallbackURLVector fallbackURLs;
        bool allowAllNetworkRequests; // Wildcard found in NETWORK section.
    };

    bool parseManifest(const URL& manifestURL, const char* data, int length, Manifest&);

}





namespace WebCore {

typedef PassRefPtr<Archive> RawDataCreationFunction(const URL&, SharedBuffer*);
typedef HashMap<String, RawDataCreationFunction*, CaseFoldingHash> ArchiveMIMETypesMap;

// The create functions in the archive classes return PassRefPtr to concrete subclasses
// of Archive. This adaptor makes the functions have a uniform return type.
template <typename ArchiveClass> static PassRefPtr<Archive> archiveFactoryCreate(const URL& url, SharedBuffer* buffer)
{
    return ArchiveClass::create(url, buffer);
}

    return !mimeType.isEmpty() && archiveMIMETypes().contains(mimeType);
}

PassRefPtr<Archive> ArchiveFactory::create(const URL& url, SharedBuffer* data, const String& mimeType)
{
    RawDataCreationFunction* function = mimeType.isEmpty() ? 0 : archiveMIMETypes().get(mimeType);
    return function ? function(url, data) : PassRefPtr<Archive>(0);

Lines 41-47 class SharedBuffer; a/Source/WebCore/loader/archive/ArchiveFactory.h_sec1
- a/Source/WebCore/loader/archive/ArchiveFactory.h -1 / +1 lines
41	class ArchiveFactory {	41	class ArchiveFactory {
42	public:	42	public:
43	static bool isArchiveMimeType(const String&);	43	static bool isArchiveMimeType(const String&);
44	static PassRefPtr<Archive> create(const KURL&, SharedBuffer* data, const String& mimeType);	44	static PassRefPtr<Archive> create(const URL&, SharedBuffer* data, const String& mimeType);
45	static void registerKnownArchiveMIMETypes();	45	static void registerKnownArchiveMIMETypes();
46	};	46	};
47		47




namespace WebCore {

inline ArchiveResource::ArchiveResource(PassRefPtr<SharedBuffer> data, const URL& url, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse& response)
    : SubstituteResource(url, response, data)
    , m_mimeType(mimeType)
    , m_textEncoding(textEncoding)

{
}

PassRefPtr<ArchiveResource> ArchiveResource::create(PassRefPtr<SharedBuffer> data, const URL& url, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse& response)
{
    if (!data)
        return 0;

    return adoptRef(new ArchiveResource(data, url, mimeType, textEncoding, frameName, response));
}

PassRefPtr<ArchiveResource> ArchiveResource::create(PassRefPtr<SharedBuffer> data, const URL& url, const ResourceResponse& response)
{
    return create(data, url, response.mimeType(), response.textEncodingName(), String(), response);
}




class ArchiveResource : public SubstituteResource {
public:
    static PassRefPtr<ArchiveResource> create(PassRefPtr<SharedBuffer>, const URL&, const ResourceResponse&);
    static PassRefPtr<ArchiveResource> create(PassRefPtr<SharedBuffer>, const URL&,
        const String& mimeType, const String& textEncoding, const String& frameName,
        const ResourceResponse& = ResourceResponse());


    bool shouldIgnoreWhenUnarchiving() const { return m_shouldIgnoreWhenUnarchiving; }

private:
    ArchiveResource(PassRefPtr<SharedBuffer>, const URL&, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse&);

    String m_mimeType;
    String m_textEncoding;



    if (!resource)
        return;

    const URL& url = resource->url(); // get before passing PassRefPtr (which sets it to 0)
    m_subresources.set(url, resource);
}

ArchiveResource* ArchiveResourceCollection::archiveResourceForURL(const URL& url)
{
    ArchiveResource* resource = m_subresources.get(url);
    if (!resource)

    return resource;
}

PassRefPtr<Archive> ArchiveResourceCollection::popSubframeArchive(const String& frameName, const URL& url)
{
    RefPtr<Archive> archive = m_subframes.take(frameName);
    if (archive)




#include "Archive.h"
#include "ArchiveResource.h"
#include "URL.h"
#include <wtf/text/WTFString.h>

#include <wtf/HashMap.h>

    void addResource(PassRefPtr<ArchiveResource>);
    void addAllResources(Archive*);
    
    ArchiveResource* archiveResourceForURL(const URL&);
    PassRefPtr<Archive> popSubframeArchive(const String& frameName, const URL&);
    
private:    
    HashMap<String, RefPtr<ArchiveResource> > m_subresources;



#include "HTMLNames.h"
#include "IconDatabase.h"
#include "Image.h"
#include "URLHash.h"
#include "Logging.h"
#include "MemoryCache.h"
#include "Page.h"

        response = createResourceResponseFromPropertyListData(resourceResponseData, resourceResponseVersion);
    }
    
    return ArchiveResource::create(SharedBuffer::wrapCFData(resourceData), URL(URL(), url), mimeType, textEncoding, frameName, response);
}

PassRefPtr<LegacyWebArchive> LegacyWebArchive::create()


PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(SharedBuffer* data)
{
    return create(URL(), data);
}

PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(const URL&, SharedBuffer* data)
{
    LOG(Archives, "LegacyWebArchive - Creating from raw data");
    

    ASSERT(frame);
    
    const ResourceResponse& response = frame->loader().documentLoader()->response();
    URL responseURL = response.url();
    
    // it's possible to have a response without a URL here
    // <rdar://problem/5454935>
    if (responseURL.isNull())
        responseURL = URL(ParsedURLString, emptyString());
        
    RefPtr<ArchiveResource> mainResource = ArchiveResource::create(utf8Buffer(markupString), responseURL, response.mimeType(), "UTF-8", frame->tree().uniqueName());

    Vector<PassRefPtr<LegacyWebArchive> > subframeArchives;
    Vector<PassRefPtr<ArchiveResource> > subresources;
    HashSet<URL> uniqueSubresources;

    size_t nodesSize = nodes.size();    
    for (size_t i = 0; i < nodesSize; ++i) {

            else
                LOG_ERROR("Unabled to archive subframe %s", childFrame->tree().uniqueName().string().utf8().data());
        } else {
            ListHashSet<URL> subresourceURLs;
            node->getSubresourceURLs(subresourceURLs);
            
            DocumentLoader* documentLoader = frame->loader().documentLoader();
            ListHashSet<URL>::iterator iterEnd = subresourceURLs.end();
            for (ListHashSet<URL>::iterator iter = subresourceURLs.begin(); iter != iterEnd; ++iter) {
                const URL& subresourceURL = *iter;
                if (uniqueSubresources.contains(subresourceURL))
                    continue;


        const String& iconURL = iconDatabase().synchronousIconURLForPageURL(responseURL);
        if (!iconURL.isEmpty() && iconDatabase().synchronousIconDataKnownForIconURL(iconURL)) {
            if (Image* iconImage = iconDatabase().synchronousIconForPageURL(responseURL, IntSize(16, 16))) {
                if (RefPtr<ArchiveResource> resource = ArchiveResource::create(iconImage->data(), URL(ParsedURLString, iconURL), "image/x-icon", "", ""))
                    subresources.append(resource.release());
            }
        }

Lines 47-53 class LegacyWebArchive : public Archive { a/Source/WebCore/loader/archive/cf/LegacyWebArchive.h_sec1
- a/Source/WebCore/loader/archive/cf/LegacyWebArchive.h -1 / +1 lines
47	public:	47	public:
48	static PassRefPtr<LegacyWebArchive> create();	48	static PassRefPtr<LegacyWebArchive> create();
49	static PassRefPtr<LegacyWebArchive> create(SharedBuffer*);	49	static PassRefPtr<LegacyWebArchive> create(SharedBuffer*);
50	static PassRefPtr<LegacyWebArchive> create(const KURL&, SharedBuffer*);	50	static PassRefPtr<LegacyWebArchive> create(const URL&, SharedBuffer*);
51	static PassRefPtr<LegacyWebArchive> create(PassRefPtr<ArchiveResource> mainResource, Vector<PassRefPtr<ArchiveResource> >& subresources, Vector<PassRefPtr<LegacyWebArchive> >& subframeArchives);	51	static PassRefPtr<LegacyWebArchive> create(PassRefPtr<ArchiveResource> mainResource, Vector<PassRefPtr<ArchiveResource> >& subresources, Vector<PassRefPtr<LegacyWebArchive> >& subframeArchives);
52	static PassRefPtr<LegacyWebArchive> create(Node, FrameFilter = 0);	52	static PassRefPtr<LegacyWebArchive> create(Node, FrameFilter = 0);
53	static PassRefPtr<LegacyWebArchive> create(Frame*);	53	static PassRefPtr<LegacyWebArchive> create(Frame*);

Lines 108-114 PassRefPtr<MHTMLArchive> MHTMLArchive::create() a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.cpp_sec1
- a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.cpp -1 / +1 lines
108	return adoptRef(new MHTMLArchive);	108	return adoptRef(new MHTMLArchive);
109	}	109	}
110		110
111	PassRefPtr<MHTMLArchive> MHTMLArchive::create(const KURL& url, SharedBuffer* data)	111	PassRefPtr<MHTMLArchive> MHTMLArchive::create(const URL& url, SharedBuffer* data)
112	{	112	{
113	// For security reasons we only load MHTML pages from local URLs.	113	// For security reasons we only load MHTML pages from local URLs.
114	if (!SchemeRegistry::shouldTreatURLSchemeAsLocal(url.protocol()))	114	if (!SchemeRegistry::shouldTreatURLSchemeAsLocal(url.protocol()))

Lines 46-52 public: a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.h_sec1
- a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.h -1 / +1 lines
46	virtual Type type() const { return MHTML; }	46	virtual Type type() const { return MHTML; }
47		47
48	static PassRefPtr<MHTMLArchive> create();	48	static PassRefPtr<MHTMLArchive> create();
49	static PassRefPtr<MHTMLArchive> create(const KURL&, SharedBuffer*);	49	static PassRefPtr<MHTMLArchive> create(const URL&, SharedBuffer*);
50		50
51	static PassRefPtr<SharedBuffer> generateMHTMLData(Page*);	51	static PassRefPtr<SharedBuffer> generateMHTMLData(Page*);
52	// Binary encoding results in smaller MHTML files but they might not work in other browsers.	52	// Binary encoding results in smaller MHTML files but they might not work in other browsers.

Lines 217-223 PassRefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHea a/Source/WebCore/loader/archive/mhtml/MHTMLParser.cpp_sec1
- a/Source/WebCore/loader/archive/mhtml/MHTMLParser.cpp -1 / +1 lines
217	// FIXME: the URL in the MIME header could be relative, we should resolve it if it is.	217	// FIXME: the URL in the MIME header could be relative, we should resolve it if it is.
218	// The specs mentions 5 ways to resolve a URL: http://tools.ietf.org/html/rfc2557#section-5	218	// The specs mentions 5 ways to resolve a URL: http://tools.ietf.org/html/rfc2557#section-5
219	// IE and Firefox (UNMht) seem to generate only absolute URLs.	219	// IE and Firefox (UNMht) seem to generate only absolute URLs.
220	KURL location = KURL(KURL(), mimeHeader.contentLocation());	220	URL location = URL(URL(), mimeHeader.contentLocation());
221	return ArchiveResource::create(contentBuffer, location, mimeHeader.contentType(), mimeHeader.charset(), String());	221	return ArchiveResource::create(contentBuffer, location, mimeHeader.contentType(), mimeHeader.charset(), String());
222	}	222	}
223		223

Lines 117-123 FontPlatformData CachedFont::platformDataFromCustomData(float size, bool bold, b a/Source/WebCore/loader/cache/CachedFont.cpp_sec1
- a/Source/WebCore/loader/cache/CachedFont.cpp -1 / +1 lines
117	bool CachedFont::ensureSVGFontData()	117	bool CachedFont::ensureSVGFontData()
118	{	118	{
119	if (!m_externalSVGDocument && !errorOccurred() && !isLoading() && m_data) {	119	if (!m_externalSVGDocument && !errorOccurred() && !isLoading() && m_data) {
120	m_externalSVGDocument = SVGDocument::create(0, KURL());	120	m_externalSVGDocument = SVGDocument::create(0, URL());
121		121
122	RefPtr<TextResourceDecoder> decoder = TextResourceDecoder::create("application/xml");	122	RefPtr<TextResourceDecoder> decoder = TextResourceDecoder::create("application/xml");
123	String svgSource = decoder->decode(m_data->data(), m_data->size());	123	String svgSource = decoder->decode(m_data->data(), m_data->size());



#include "FrameLoader.h"
#include "FrameLoaderClient.h"
#include "InspectorInstrumentation.h"
#include "URL.h"
#include "LoaderStrategy.h"
#include "Logging.h"
#include "MemoryCache.h"


    if (!m_resourceRequest.url().hasFragmentIdentifier())
        return;
    URL urlForCache = MemoryCache::removeFragmentIdentifierIfNeeded(m_resourceRequest.url());
    if (urlForCache.hasFragmentIdentifier())
        return;
    m_fragmentIdentifierForRequest = m_resourceRequest.url().fragmentIdentifier();

    // We should look into removing the expectation of that knowledge from the platform network stacks.
    ResourceRequest request(m_resourceRequest);
    if (!m_fragmentIdentifierForRequest.isNull()) {
        URL url = request.url();
        url.setFragmentIdentifier(m_fragmentIdentifierForRequest);
        request.setURL(url);
        m_fragmentIdentifierForRequest = String();

Lines 112-118 public: a/Source/WebCore/loader/cache/CachedResource.h_sec1
- a/Source/WebCore/loader/cache/CachedResource.h -1 / +1 lines
112	virtual bool shouldIgnoreHTTPStatusCodeErrors() const { return false; }	112	virtual bool shouldIgnoreHTTPStatusCodeErrors() const { return false; }
113		113
114	ResourceRequest& resourceRequest() { return m_resourceRequest; }	114	ResourceRequest& resourceRequest() { return m_resourceRequest; }
115	const KURL& url() const { return m_resourceRequest.url();}	115	const URL& url() const { return m_resourceRequest.url();}
116	#if ENABLE(CACHE_PARTITIONING)	116	#if ENABLE(CACHE_PARTITIONING)
117	const String& cachePartition() const { return m_resourceRequest.cachePartition(); }	117	const String& cachePartition() const { return m_resourceRequest.cachePartition(); }
118	#endif	118	#endif




CachedResource* CachedResourceLoader::cachedResource(const String& resourceURL) const 
{
    URL url = m_document->completeURL(resourceURL);
    return cachedResource(url); 
}

CachedResource* CachedResourceLoader::cachedResource(const URL& resourceURL) const
{
    URL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
    return m_documentResources.get(url).get(); 
}


{
    if (Frame* f = frame()) {
        if (f->loader().pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) {
            URL requestURL = request.resourceRequest().url();
            if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL, request.options(), request.forPreload()))
                PingLoader::loadImage(f, requestURL);
            return 0;


CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest& request)
{
    URL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());

#if ENABLE(CACHE_PARTITIONING)
    request.mutableResourceRequest().setCachePartition(document()->topOrigin()->cachePartition());

    return static_cast<CachedRawResource*>(requestResource(CachedResource::MainResource, request).get());
}

bool CachedResourceLoader::checkInsecureContent(CachedResource::Type type, const URL& url) const
{
    switch (type) {
    case CachedResource::Script:

    return true;
}

bool CachedResourceLoader::canRequest(CachedResource::Type type, const URL& url, const ResourceLoaderOptions& options, bool forPreload)
{
    if (document() && !document()->securityOrigin()->canDisplay(url)) {
        if (!forPreload)


CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
{
    URL url = request.resourceRequest().url();
    
    LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.stringCenterEllipsizedToLength().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload());
    

    return Use;
}

void CachedResourceLoader::printAccessDeniedMessage(const URL& url) const
{
    if (url.isNull())
        return;

    reloadImagesIfNotDeferred();
}

bool CachedResourceLoader::clientDefersImage(const URL& url) const
{
    return frame() && !frame()->loader().client().allowImage(m_imagesEnabled, url);
}

bool CachedResourceLoader::shouldDeferImageLoad(const URL& url) const
{
    return clientDefersImage(url) || !m_autoLoadImages;
}


bool CachedResourceLoader::isPreloaded(const String& urlString) const
{
    const URL& url = m_document->completeURL(urlString);

    if (m_preloads) {
        ListHashSet<CachedResource*>::iterator end = m_preloads->end();



class DocumentLoader;
class Frame;
class ImageLoader;
class URL;

// The CachedResourceLoader provides a per-context interface to the MemoryCache
// and enforces a bunch of security checks and rules for resource revalidation.

#endif

    // Logs an access denied message to the console for the specified URL.
    void printAccessDeniedMessage(const URL& url) const;

    CachedResource* cachedResource(const String& url) const;
    CachedResource* cachedResource(const URL& url) const;
    
    typedef HashMap<String, CachedResourceHandle<CachedResource> > DocumentResourceMap;
    const DocumentResourceMap& allCachedResources() const { return m_documentResources; }


    void setImagesEnabled(bool);

    bool shouldDeferImageLoad(const URL&) const;
    
    CachePolicy cachePolicy(CachedResource::Type) const;
    

    void preload(CachedResource::Type, CachedResourceRequest&, const String& charset);
    void checkForPendingPreloads();
    void printPreloadStats();
    bool canRequest(CachedResource::Type, const URL&, const ResourceLoaderOptions&, bool forPreload = false);

    static const ResourceLoaderOptions& defaultCachedResourceOptions();


    RevalidationPolicy determineRevalidationPolicy(CachedResource::Type, ResourceRequest&, bool forPreload, CachedResource* existingResource, CachedResourceRequest::DeferOption) const;
    
    bool shouldContinueAfterNotifyingLoadedFromMemoryCache(CachedResource*);
    bool checkInsecureContent(CachedResource::Type, const URL&) const;

    void garbageCollectDocumentResourcesTimerFired(Timer<CachedResourceLoader>*);
    void performPostLoadActions();

    bool clientDefersImage(const URL&) const;
    void reloadImagesIfNotDeferred();
    
    HashSet<String> m_validatedURLs;



namespace WebCore {

class CachedCSSStyleSheet;
class URL;

class CachedStyleSheetClient : public CachedResourceClient {
public:
    virtual ~CachedStyleSheetClient() { }
    static CachedResourceClientType expectedType() { return StyleSheetType; }
    virtual CachedResourceClientType resourceClientType() const { return expectedType(); }
    virtual void setCSSStyleSheet(const String& /* href */, const URL& /* baseURL */, const String& /* charset */, const CachedCSSStyleSheet*) { }
    virtual void setXSLStyleSheet(const String& /* href */, const URL& /* baseURL */, const String& /* sheet */) { }
};

} // namespace WebCore



{
}

URL MemoryCache::removeFragmentIdentifierIfNeeded(const URL& originalURL)
{
    if (!originalURL.hasFragmentIdentifier())
        return originalURL;

    // to be unique even when they differ by the fragment identifier only.
    if (!originalURL.protocolIsInHTTPFamily())
        return originalURL;
    URL url = originalURL;
    url.removeFragmentIdentifier();
    return url;
}

    revalidatingResource->clearResourceToRevalidate();
}

CachedResource* MemoryCache::resourceForURL(const URL& resourceURL)
{
    return resourceForRequest(ResourceRequest(resourceURL));
}

CachedResource* MemoryCache::resourceForRequest(const ResourceRequest& request)
{
    ASSERT(WTF::isMainThread());
    URL url = removeFragmentIdentifierIfNeeded(request.url());
#if ENABLE(CACHE_PARTITIONING)
    CachedResourceItem* item = m_resources.get(url);
    CachedResource* resource = 0;



class CachedCSSStyleSheet;
class CachedResource;
class CachedResourceLoader;
class URL;
class ResourceRequest;
class ResourceResponse;
class ScriptExecutionContext;

        TypeStatistic fonts;
    };

    CachedResource* resourceForURL(const URL&);
    CachedResource* resourceForRequest(const ResourceRequest&);
    
    bool add(CachedResource* resource);
    void remove(CachedResource* resource) { evict(resource); }

    static URL removeFragmentIdentifierIfNeeded(const URL& originalURL);
    
    void revalidationSucceeded(CachedResource* revalidatingResource, const ResourceResponse&);
    void revalidationFailed(CachedResource* revalidatingResource);



{
}

URL IconController::url()
{
    IconURLs iconURLs = urlsForTypes(Favicon);
    return iconURLs.isEmpty() ? URL() : iconURLs[0].m_iconURL;
}

IconURL IconController::iconURL(IconType iconType) const

    return iconURLs;
}

void IconController::commitToDatabase(const URL& icon)
{
    LOG(IconDatabase, "Committing iconURL %s to database for pageURLs %s and %s", icon.string().ascii().data(), m_frame->document()->url().string().ascii().data(), m_frame->loader().initialRequest().url().string().ascii().data());
    iconDatabase().setIconURLForPageURL(icon.string(), m_frame->document()->url().string());

    if (!documentCanHaveIcon(m_frame->document()->url()))
        return;

    URL iconURL(url());
    String urlString(iconURL.string());
    if (urlString.isEmpty())
        return;

        return;

    if (iconLoadDecision == IconLoadNo) {
        URL iconURL(url());
        String urlString(iconURL.string());
        if (urlString.isEmpty())
            return;

IconURL IconController::defaultURL(IconType iconType)
{
    // Don't return a favicon iconURL unless we're http or https
    URL documentURL = m_frame->document()->url();
    if (!documentURL.protocolIsInHTTPFamily())
        return IconURL();

    URL url;
    bool couldSetProtocol = url.setProtocol(documentURL.protocol());
    ASSERT_UNUSED(couldSetProtocol, couldSetProtocol);
    url.setHost(documentURL.host());




#include "IconDatabaseBase.h"
#include "IconURL.h"
#include "URL.h"

namespace WebCore {


    explicit IconController(Frame*);
    ~IconController();

    URL url();
    IconURLs urlsForTypes(int iconTypesMask);
    IconURL iconURL(IconType) const;


    void loadDecisionReceived(IconLoadDecision);
    void continueLoadWithDecision(IconLoadDecision);

    void commitToDatabase(const URL& icon);

private:
    bool appendToIconURLs(IconType, IconURLs*);

Lines 51-57 class IntSize; a/Source/WebCore/loader/icon/IconDatabase.h_sec1
- a/Source/WebCore/loader/icon/IconDatabase.h -1 / +1 lines
51	class IconDatabaseClient;	51	class IconDatabaseClient;
52	class IconRecord;	52	class IconRecord;
53	class IconSnapshot;	53	class IconSnapshot;
54	class KURL;	54	class URL;
55	class PageURLRecord;	55	class PageURLRecord;
56	class PageURLSnapshot;	56	class PageURLSnapshot;
57	class SharedBuffer;	57	class SharedBuffer;

Lines 27-33 a/Source/WebCore/loader/icon/IconDatabaseBase.cpp_sec1
- a/Source/WebCore/loader/icon/IconDatabaseBase.cpp -1 / +1 lines
27	#include "IconDatabaseBase.h"	27	#include "IconDatabaseBase.h"
28		28
29	#include "IconDatabase.h"	29	#include "IconDatabase.h"
30	#include "KURL.h"	30	#include "URL.h"
31	#include "SharedBuffer.h"	31	#include "SharedBuffer.h"
32		32
33	namespace WebCore {	33	namespace WebCore {




#import <wtf/Assertions.h>
#import <wtf/Vector.h>
#import "URL.h"
#import "LocalizedStrings.h"
#import "MIMETypeRegistry.h"
#import "WebCoreNSStringExtras.h"


    if ([filename length] == 0 || [lastPathComponent isEqualToString:@"/"]) {
        // lastPathComponent is no good, try the host.
        NSString *host = URL(url).host();
        filename = filenameByFixingIllegalCharacters(host);
        if ([filename length] == 0) {
            // Can't make a filename using this URL, use "unknown".

Lines 236-242 void CaptionUserPreferences::setCaptionsStyleSheetOverride(const String& overrid a/Source/WebCore/page/CaptionUserPreferences.cpp_sec1
- a/Source/WebCore/page/CaptionUserPreferences.cpp -1 / +1 lines
236	void CaptionUserPreferences::updateCaptionStyleSheetOveride()	236	void CaptionUserPreferences::updateCaptionStyleSheetOveride()
237	{	237	{
238	// Identify our override style sheet with a unique URL - a new scheme and a UUID.	238	// Identify our override style sheet with a unique URL - a new scheme and a UUID.
239	DEFINE_STATIC_LOCAL(KURL, captionsStyleSheetURL, (ParsedURLString, "user-captions-override:01F6AF12-C3B0-4F70-AF5E-A3E00234DC23"));	239	DEFINE_STATIC_LOCAL(URL, captionsStyleSheetURL, (ParsedURLString, "user-captions-override:01F6AF12-C3B0-4F70-AF5E-A3E00234DC23"));
240		240
241	pageGroup()->removeUserStyleSheetFromWorld(mainThreadNormalWorld(), captionsStyleSheetURL);	241	pageGroup()->removeUserStyleSheetFromWorld(mainThreadNormalWorld(), captionsStyleSheetURL);
242		242



#include "DOMWrapperWorld.h"
#include "FloatConversion.h"
#include "HTMLMediaElement.h"
#include "KURL.h"
#include "Language.h"
#include "LocalizedStrings.h"
#include "Logging.h"

#include "SoftLinking.h"
#include "TextTrackCue.h"
#include "TextTrackList.h"
#include "URL.h"
#include "UserStyleSheetTypes.h"
#include <wtf/RetainPtr.h>
#include <wtf/text/StringBuilder.h>



#include "Frame.h"
#include "InspectorInstrumentation.h"
#include "InspectorValues.h"
#include "URL.h"
#include "PingLoader.h"
#include "RuntimeEnabledFeatures.h"
#include "SchemeRegistry.h"

    {
    }

    bool matches(const URL& url) const
    {
        if (!schemeMatches(url))
            return false;

    }

private:
    bool schemeMatches(const URL& url) const
    {
        if (m_scheme.isEmpty()) {
            String protectedResourceScheme(m_policy->securityOrigin()->protocol());

        return equalIgnoringCase(url.protocol(), m_scheme);
    }

    bool hostMatches(const URL& url) const
    {
        const String& host = url.host();
        if (equalIgnoringCase(host, m_host))


    }

    bool pathMatches(const URL& url) const
    {
        if (m_path.isEmpty())
            return true;

        return path == m_path;
    }

    bool portMatches(const URL& url) const
    {
        if (m_portHasWildcard)
            return true;

    CSPSourceList(ContentSecurityPolicy*, const String& directiveName);

    void parse(const String&);
    bool matches(const URL&);
    bool allowInline() const { return m_allowInline; }
    bool allowEval() const { return m_allowEval; }


    parse(value.characters(), value.characters() + value.length());
}

bool CSPSourceList::matches(const URL& url)
{
    if (m_allowStar)
        return true;

    URL effectiveURL = SecurityOrigin::shouldUseInnerURL(url) ? SecurityOrigin::extractInnerURL(url) : url;

    for (size_t i = 0; i < m_list.size(); ++i) {
        if (m_list[i].matches(effectiveURL))

        m_sourceList.parse(value);
    }

    bool allows(const URL& url)
    {
        return m_sourceList.matches(url.isEmpty() ? policy()->url() : url);
    }

    bool allowInlineScript(const String& contextURL, const WTF::OrdinalNumber& contextLine, ContentSecurityPolicy::ReportingStatus) const;
    bool allowInlineStyle(const String& contextURL, const WTF::OrdinalNumber& contextLine, ContentSecurityPolicy::ReportingStatus) const;
    bool allowEval(JSC::ExecState*, ContentSecurityPolicy::ReportingStatus) const;
    bool allowScriptNonce(const String& nonce, const String& contextURL, const WTF::OrdinalNumber& contextLine, const URL&) const;
    bool allowPluginType(const String& type, const String& typeAttribute, const URL&, ContentSecurityPolicy::ReportingStatus) const;

    bool allowScriptFromSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowObjectFromSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowChildFrameFromSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowImageFromSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowStyleFromSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowFontFromSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowMediaFromSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowConnectToSource(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowFormAction(const URL&, ContentSecurityPolicy::ReportingStatus) const;
    bool allowBaseURI(const URL&, ContentSecurityPolicy::ReportingStatus) const;

    void gatherReportURIs(DOMStringList&) const;
    const String& evalDisabledErrorMessage() const { return m_evalDisabledErrorMessage; }
    ContentSecurityPolicy::ReflectedXSSDisposition reflectedXSSDisposition() const { return m_reflectedXSSDisposition; }
    bool isReportOnly() const { return m_reportOnly; }
    const Vector<URL>& reportURIs() const { return m_reportURIs; }

private:
    CSPDirectiveList(ContentSecurityPolicy*, ContentSecurityPolicy::HeaderType);

    void setCSPDirective(const String& name, const String& value, OwnPtr<CSPDirectiveType>&);

    SourceListDirective* operativeDirective(SourceListDirective*) const;
    void reportViolation(const String& directiveText, const String& effectiveDirective, const String& consoleMessage, const URL& blockedURL = URL(), const String& contextURL = String(), const WTF::OrdinalNumber& contextLine = WTF::OrdinalNumber::beforeFirst(), JSC::ExecState* = 0) const;

    bool checkEval(SourceListDirective*) const;
    bool checkInline(SourceListDirective*) const;
    bool checkNonce(NonceDirective*, const String&) const;
    bool checkSource(SourceListDirective*, const URL&) const;
    bool checkMediaType(MediaListDirective*, const String& type, const String& typeAttribute) const;

    void setEvalDisabledErrorMessage(const String& errorMessage) { m_evalDisabledErrorMessage = errorMessage; }

    bool checkInlineAndReportViolation(SourceListDirective*, const String& consoleMessage, const String& contextURL, const WTF::OrdinalNumber& contextLine, bool isScript) const;
    bool checkNonceAndReportViolation(NonceDirective*, const String& nonce, const String& consoleMessage, const String& contextURL, const WTF::OrdinalNumber& contextLine) const;

    bool checkSourceAndReportViolation(SourceListDirective*, const URL&, const String& effectiveDirective) const;
    bool checkMediaTypeAndReportViolation(MediaListDirective*, const String& type, const String& typeAttribute, const String& consoleMessage) const;

    bool denyIfEnforcingPolicy() const { return m_reportOnly; }

    OwnPtr<SourceListDirective> m_scriptSrc;
    OwnPtr<SourceListDirective> m_styleSrc;

    Vector<URL> m_reportURIs;

    String m_evalDisabledErrorMessage;
};

    return directives.release();
}

void CSPDirectiveList::reportViolation(const String& directiveText, const String& effectiveDirective, const String& consoleMessage, const URL& blockedURL, const String& contextURL, const WTF::OrdinalNumber& contextLine, JSC::ExecState* state) const
{
    String message = m_reportOnly ? "[Report Only] " + consoleMessage : consoleMessage;
    m_policy->reportViolation(directiveText, effectiveDirective, message, blockedURL, m_reportURIs, m_header, contextURL, contextLine, state);

    return !directive || directive->allows(nonce);
}

bool CSPDirectiveList::checkSource(SourceListDirective* directive, const URL& url) const
{
    return !directive || directive->allows(url);
}

    if (directive == m_defaultSrc)
        suffix = " Note that 'script-src' was not explicitly set, so 'default-src' is used as a fallback.";

    reportViolation(directive->text(), scriptSrc, consoleMessage + "\"" + directive->text() + "\"." + suffix + "\n", URL(), contextURL, contextLine, state);
    if (!m_reportOnly) {
        m_policy->reportBlockedScriptExecutionToInspector(directive->text());
        return false;

{
    if (checkNonce(directive, nonce))
        return true;
    reportViolation(directive->text(), scriptNonce, consoleMessage + "\"" + directive->text() + "\".\n", URL(), contextURL, contextLine);
    return denyIfEnforcingPolicy();
}


    if (typeAttribute.isEmpty())
        message = message + " When enforcing the 'plugin-types' directive, the plugin's media type must be explicitly declared with a 'type' attribute on the containing element (e.g. '<object type=\"[TYPE GOES HERE]\" ...>').";

    reportViolation(directive->text(), pluginTypes, message + "\n", URL());
    return denyIfEnforcingPolicy();
}


    if (directive == m_defaultSrc)
        suffix = makeString(" Note that '", (isScript ? "script" : "style"), "-src' was not explicitly set, so 'default-src' is used as a fallback.");

    reportViolation(directive->text(), isScript ? scriptSrc : styleSrc, consoleMessage + "\"" + directive->text() + "\"." + suffix + "\n", URL(), contextURL, contextLine);

    if (!m_reportOnly) {
        if (isScript)

    return true;
}

bool CSPDirectiveList::checkSourceAndReportViolation(SourceListDirective* directive, const URL& url, const String& effectiveDirective) const
{
    if (checkSource(directive, url))
        return true;

        checkEval(operativeDirective(m_scriptSrc.get()));
}

bool CSPDirectiveList::allowScriptNonce(const String& nonce, const String& contextURL, const WTF::OrdinalNumber& contextLine, const URL& url) const
{
    DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Refused to execute script because it violates the following Content Security Policy directive: ")));
    if (url.isEmpty())

    return checkNonceAndReportViolation(m_scriptNonce.get(), nonce, "Refused to load '" + url.stringCenterEllipsizedToLength() + "' because it violates the following Content Security Policy directive: ", contextURL, contextLine);
}

bool CSPDirectiveList::allowPluginType(const String& type, const String& typeAttribute, const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkMediaTypeAndReportViolation(m_pluginTypes.get(), type, typeAttribute, "Refused to load '" + url.stringCenterEllipsizedToLength() + "' (MIME type '" + typeAttribute + "') because it violates the following Content Security Policy Directive: ") :
        checkMediaType(m_pluginTypes.get(), type, typeAttribute);
}

bool CSPDirectiveList::allowScriptFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(operativeDirective(m_scriptSrc.get()), url, scriptSrc) :
        checkSource(operativeDirective(m_scriptSrc.get()), url);
}

bool CSPDirectiveList::allowObjectFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    if (url.isBlankURL())
        return true;

        checkSource(operativeDirective(m_objectSrc.get()), url);
}

bool CSPDirectiveList::allowChildFrameFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    if (url.isBlankURL())
        return true;

        checkSource(operativeDirective(m_frameSrc.get()), url);
}

bool CSPDirectiveList::allowImageFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(operativeDirective(m_imgSrc.get()), url, imgSrc) :
        checkSource(operativeDirective(m_imgSrc.get()), url);
}

bool CSPDirectiveList::allowStyleFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(operativeDirective(m_styleSrc.get()), url, styleSrc) :
        checkSource(operativeDirective(m_styleSrc.get()), url);
}

bool CSPDirectiveList::allowFontFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(operativeDirective(m_fontSrc.get()), url, fontSrc) :
        checkSource(operativeDirective(m_fontSrc.get()), url);
}

bool CSPDirectiveList::allowMediaFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(operativeDirective(m_mediaSrc.get()), url, mediaSrc) :
        checkSource(operativeDirective(m_mediaSrc.get()), url);
}

bool CSPDirectiveList::allowConnectToSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(operativeDirective(m_connectSrc.get()), url, connectSrc) :

        list.append(m_reportURIs[i].string());
}

bool CSPDirectiveList::allowFormAction(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(m_formAction.get(), url, formAction) :
        checkSource(m_formAction.get(), url);
}

bool CSPDirectiveList::allowBaseURI(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return reportingStatus == ContentSecurityPolicy::SendReport ?
        checkSourceAndReportViolation(m_baseURI.get(), url, baseURI) :

    return true;
}

template<bool (CSPDirectiveList::*allowed)(const String&, const String&, const WTF::OrdinalNumber&, const URL&) const>
bool isAllowedByAllWithNonce(const CSPDirectiveListVector& policies, const String& nonce, const String& contextURL, const WTF::OrdinalNumber& contextLine, const URL& url)
{
    for (size_t i = 0; i < policies.size(); ++i) {
        if (!(policies[i].get()->*allowed)(nonce, contextURL, contextLine, url))

    return true;
}

template<bool (CSPDirectiveList::*allowFromURL)(const URL&, ContentSecurityPolicy::ReportingStatus) const>
bool isAllowedByAllWithURL(const CSPDirectiveListVector& policies, const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus)
{
    if (SchemeRegistry::schemeShouldBypassContentSecurityPolicy(url.protocol()))
        return true;

    return String();
}

bool ContentSecurityPolicy::allowScriptNonce(const String& nonce, const String& contextURL, const WTF::OrdinalNumber& contextLine, const URL& url) const
{
    return isAllowedByAllWithNonce<&CSPDirectiveList::allowScriptNonce>(m_policies, nonce, contextURL, contextLine, url);
}

bool ContentSecurityPolicy::allowPluginType(const String& type, const String& typeAttribute, const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    for (size_t i = 0; i < m_policies.size(); ++i) {
        if (!m_policies[i]->allowPluginType(type, typeAttribute, url, reportingStatus))

    return true;
}

bool ContentSecurityPolicy::allowScriptFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowScriptFromSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowObjectFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowObjectFromSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowChildFrameFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowChildFrameFromSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowImageFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowImageFromSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowStyleFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowStyleFromSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowFontFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowFontFromSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowMediaFromSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowMediaFromSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowConnectToSource(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowConnectToSource>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowFormAction(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowFormAction>(m_policies, url, reportingStatus);
}

bool ContentSecurityPolicy::allowBaseURI(const URL& url, ContentSecurityPolicy::ReportingStatus reportingStatus) const
{
    return isAllowedByAllWithURL<&CSPDirectiveList::allowBaseURI>(m_policies, url, reportingStatus);
}

    return m_scriptExecutionContext->securityOrigin();
}

const URL& ContentSecurityPolicy::url() const
{
    return m_scriptExecutionContext->url();
}

URL ContentSecurityPolicy::completeURL(const String& url) const
{
    return m_scriptExecutionContext->completeURL(url);
}

    m_scriptExecutionContext->enforceSandboxFlags(mask);
}

static String stripURLForUseInReport(Document* document, const URL& url)
{
    if (!url.isValid())
        return String();

}

#if ENABLE(CSP_NEXT)
static void gatherSecurityPolicyViolationEventData(SecurityPolicyViolationEventInit& init, Document* document, const String& directiveText, const String& effectiveDirective, const URL& blockedURL, const String& header)
{
    init.documentURI = document->url().string();
    init.referrer = document->referrer();

    const ScriptCallFrame& callFrame = getFirstNonNativeFrame(stack);

    if (callFrame.lineNumber()) {
        URL source = URL(ParsedURLString, callFrame.sourceURL());
        init.sourceFile = stripURLForUseInReport(document, source);
        init.lineNumber = callFrame.lineNumber();
    }
}
#endif

void ContentSecurityPolicy::reportViolation(const String& directiveText, const String& effectiveDirective, const String& consoleMessage, const URL& blockedURL, const Vector<URL>& reportURIs, const String& header, const String& contextURL, const WTF::OrdinalNumber& contextLine, JSC::ExecState* state) const
{
    logToConsole(consoleMessage, contextURL, contextLine, state);


        const ScriptCallFrame& callFrame = getFirstNonNativeFrame(stack);

        if (callFrame.lineNumber()) {
            URL source = URL(ParsedURLString, callFrame.sourceURL());
            cspReport->setString("source-file", stripURLForUseInReport(document, source));
            cspReport->setNumber("line-number", callFrame.lineNumber());
        }



#ifndef ContentSecurityPolicy_h
#define ContentSecurityPolicy_h

#include "URL.h"
#include "ScriptState.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/RefCounted.h>

    bool allowInlineScript(const String& contextURL, const WTF::OrdinalNumber& contextLine, ReportingStatus = SendReport) const;
    bool allowInlineStyle(const String& contextURL, const WTF::OrdinalNumber& contextLine, ReportingStatus = SendReport) const;
    bool allowEval(JSC::ExecState* = 0, ReportingStatus = SendReport) const;
    bool allowScriptNonce(const String& nonce, const String& contextURL, const WTF::OrdinalNumber& contextLine, const URL& = URL()) const;
    bool allowPluginType(const String& type, const String& typeAttribute, const URL&, ReportingStatus = SendReport) const;

    bool allowScriptFromSource(const URL&, ReportingStatus = SendReport) const;
    bool allowObjectFromSource(const URL&, ReportingStatus = SendReport) const;
    bool allowChildFrameFromSource(const URL&, ReportingStatus = SendReport) const;
    bool allowImageFromSource(const URL&, ReportingStatus = SendReport) const;
    bool allowStyleFromSource(const URL&, ReportingStatus = SendReport) const;
    bool allowFontFromSource(const URL&, ReportingStatus = SendReport) const;
    bool allowMediaFromSource(const URL&, ReportingStatus = SendReport) const;
    bool allowConnectToSource(const URL&, ReportingStatus = SendReport) const;
    bool allowFormAction(const URL&, ReportingStatus = SendReport) const;
    bool allowBaseURI(const URL&, ReportingStatus = SendReport) const;

    ReflectedXSSDisposition reflectedXSSDisposition() const;


    void reportInvalidReflectedXSS(const String&) const;
    void reportMissingReportURI(const String&) const;
    void reportUnsupportedDirective(const String&) const;
    void reportViolation(const String& directiveText, const String& effectiveDirective, const String& consoleMessage, const URL& blockedURL, const Vector<URL>& reportURIs, const String& header, const String& contextURL = String(), const WTF::OrdinalNumber& contextLine = WTF::OrdinalNumber::beforeFirst(), JSC::ExecState* = 0) const;

    void reportBlockedScriptExecutionToInspector(const String& directiveText) const;

    const URL& url() const;
    URL completeURL(const String&) const;
    SecurityOrigin* securityOrigin() const;
    void enforceSandboxFlags(SandboxFlags) const;
    String evalDisabledErrorMessage() const;



    class ContextMenuItem;
    class Frame;
    class HitTestResult;
    class URL;

    class ContextMenuClient {
    public:


        virtual void contextMenuItemSelected(ContextMenuItem*, const ContextMenu*) = 0;

        virtual void downloadURL(const URL& url) = 0;
        virtual void searchWithGoogle(const Frame*) = 0;
        virtual void lookUpInDictionary(Frame*) = 0;
        virtual bool isSpeaking() = 0;



    event->setDefaultHandled();
}

static void openNewWindow(const URL& urlToLoad, Frame* frame)
{
    if (Page* oldPage = frame->page()) {
        FrameLoadRequest request(frame->document()->securityOrigin(), ResourceRequest(urlToLoad, frame->loader().outgoingReferrer()));


    if (!m_hitTestResult.isContentEditable()) {
        FrameLoader& loader = frame->loader();
        URL linkURL = m_hitTestResult.absoluteLinkURL();
        if (!linkURL.isEmpty()) {
            if (loader.client().canHandleRequest(ResourceRequest(linkURL))) {
                appendItem(OpenLinkItem, m_contextMenu.get());

            appendItem(CopyLinkItem, m_contextMenu.get());
        }

        URL imageURL = m_hitTestResult.absoluteImageURL();
        if (!imageURL.isEmpty()) {
            if (!linkURL.isEmpty())
                appendItem(*separatorItem(), m_contextMenu.get());

#endif
        }

        URL mediaURL = m_hitTestResult.absoluteMediaURL();
        if (!mediaURL.isEmpty()) {
            if (!linkURL.isEmpty() || !imageURL.isEmpty())
                appendItem(*separatorItem(), m_contextMenu.get());

        }

        FrameLoader& loader = frame->loader();
        URL linkURL = m_hitTestResult.absoluteLinkURL();
        if (!linkURL.isEmpty()) {
            if (loader.client().canHandleRequest(ResourceRequest(linkURL))) {
                appendItem(OpenLinkItem, m_contextMenu.get());



    return context->contentSecurityPolicy()->isActive();
}

template<bool (ContentSecurityPolicy::*allowWithType)(const String&, const String&, const URL&, ContentSecurityPolicy::ReportingStatus) const>
bool isAllowedWithType(ScriptExecutionContext* context, const String& type)
{
    if (!isPolicyActiveInContext(context))
        return true;

    return (context->contentSecurityPolicy()->*allowWithType)(type, type, URL(), ContentSecurityPolicy::SuppressReport);
}

template<bool (ContentSecurityPolicy::*allowWithURL)(const URL&, ContentSecurityPolicy::ReportingStatus) const>
bool isAllowedWithURL(ScriptExecutionContext* context, const String& url)
{
    if (!isPolicyActiveInContext(context))
        return true;

    URL parsedURL = context->completeURL(url);
    if (!parsedURL.isValid())
        return false; // FIXME: Figure out how to throw a JavaScript error.




#include "HTMLFrameOwnerElement.h"
#include "History.h"
#include "InspectorInstrumentation.h"
#include "URL.h"
#include "Location.h"
#include "MediaQueryList.h"
#include "MediaQueryMatcher.h"

    if (!firstFrame)
        return;

    URL completedURL = firstFrame->document()->completeURL(urlString);
    if (completedURL.isNull())
        return;



String DOMWindow::crossDomainAccessErrorMessage(DOMWindow* activeWindow)
{
    const URL& activeWindowURL = activeWindow->document()->url();
    if (activeWindowURL.isNull())
        return String();


    String message = "Blocked a frame with origin \"" + activeOrigin->toString() + "\" from accessing a frame with origin \"" + targetOrigin->toString() + "\". ";

    // Sandbox errors: Use the origin of the frames' location, rather than their actual origin (since we know that at least one will be "null").
    URL activeURL = activeWindow->document()->url();
    URL targetURL = document()->url();
    if (document()->isSandboxed(SandboxOrigin) || activeWindow->document()->isSandboxed(SandboxOrigin)) {
        message = "Blocked a frame at \"" + SecurityOrigin::create(activeURL)->toString() + "\" from accessing a frame at \"" + SecurityOrigin::create(targetURL)->toString() + "\". ";
        if (document()->isSandboxed(SandboxOrigin) && activeWindow->document()->isSandboxed(SandboxOrigin))

{
    Frame* activeFrame = activeWindow->frame();

    URL completedURL = urlString.isEmpty() ? URL(ParsedURLString, emptyString()) : firstFrame->document()->completeURL(urlString);
    if (!completedURL.isEmpty() && !completedURL.isValid()) {
        // Don't expose client code to invalid URLs.
        activeWindow->printErrorMessage("Unable to open a window with invalid URL '" + completedURL.string() + "'.\n");

        if (!activeDocument->canNavigate(targetFrame))
            return 0;

        URL completedURL = firstFrame->document()->completeURL(urlString);

        if (targetFrame->document()->domWindow()->isInsecureScriptAccess(activeWindow, completedURL))
            return targetFrame->document()->domWindow();

Lines 30-36 a/Source/WebCore/page/DOMWindow.h_sec1
- a/Source/WebCore/page/DOMWindow.h -1 / +1 lines
30	#include "ContextDestructionObserver.h"	30	#include "ContextDestructionObserver.h"
31	#include "EventTarget.h"	31	#include "EventTarget.h"
32	#include "FrameDestructionObserver.h"	32	#include "FrameDestructionObserver.h"
33	#include "KURL.h"	33	#include "URL.h"
34	#include "Supplementable.h"	34	#include "Supplementable.h"
35		35
36	namespace WebCore {	36	namespace WebCore {



        // hidden or moved out from under the cursor. Regardless, we don't want to start a drag on
        // something that's not actually under the drag origin.
        return false;
    URL linkURL = hitTestResult.absoluteLinkURL();
    URL imageURL = hitTestResult.absoluteImageURL();

    IntPoint mouseDraggedPoint = src->view()->windowToContents(dragEvent.position());

    m_draggingImageURL = URL();
    m_sourceDragOperation = srcOp;

    DragImageRef dragImage = 0;



#include "DragActions.h"
#include "DragImage.h"
#include "IntPoint.h"
#include "URL.h"

namespace WebCore {


        void setDidInitiateDrag(bool initiated) { m_didInitiateDrag = initiated; } 
        bool didInitiateDrag() const { return m_didInitiateDrag; }
        DragOperation sourceDragOperation() const { return m_sourceDragOperation; }
        const URL& draggingImageURL() const { return m_draggingImageURL; }
        void setDragOffset(const IntPoint& offset) { m_dragOffset = offset; }
        const IntPoint& dragOffset() const { return m_dragOffset; }
        DragSourceAction dragSourceAction() const { return m_dragSourceAction; }

        void doImageDrag(Element*, const IntPoint&, const IntRect&, Clipboard*, Frame*, IntPoint&);
        void doSystemDrag(DragImageRef, const IntPoint&, const IntPoint&, Clipboard*, Frame*, bool forLink);
        void cleanupAfterSystemDrag();
        void declareAndWriteDragImage(Clipboard*, Element*, const URL&, const String& label);

        Page& m_page;
        DragClient& m_client;

        bool m_didInitiateDrag;
        DragOperation m_sourceDragOperation; // Set in startDrag when a drag starts from a mouse down within WebKit
        IntPoint m_dragOffset;
        URL m_draggingImageURL;
    };

}




const unsigned long long EventSource::defaultReconnectDelay = 3000;

inline EventSource::EventSource(ScriptExecutionContext* context, const URL& url, const Dictionary& eventSourceInit)
    : ActiveDOMObject(context)
    , m_url(url)
    , m_withCredentials(false)

        return 0;
    }

    URL fullURL = context->completeURL(url);
    if (!fullURL.isValid()) {
        ec = SYNTAX_ERR;
        return 0;




#include "ActiveDOMObject.h"
#include "EventTarget.h"
#include "KURL.h"
#include "ThreadableLoaderClient.h"
#include "Timer.h"
#include "URL.h"
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>


    virtual ScriptExecutionContext* scriptExecutionContext() const OVERRIDE FINAL { return ActiveDOMObject::scriptExecutionContext(); }

private:
    EventSource(ScriptExecutionContext*, const URL&, const Dictionary&);

    virtual void refEventTarget() OVERRIDE FINAL { ref(); }
    virtual void derefEventTarget() OVERRIDE FINAL { deref(); }

    void parseEventStreamLine(unsigned pos, int fieldLength, int lineLength);
    PassRefPtr<MessageEvent> createMessageEvent();

    URL m_url;
    bool m_withCredentials;
    State m_state;


Lines 946-952 void Frame::deviceOrPageScaleFactorChanged() a/Source/WebCore/page/Frame.cpp_sec1
- a/Source/WebCore/page/Frame.cpp -1 / +1 lines
946	}	946	}
947	#endif	947	#endif
948		948
949	bool Frame::isURLAllowed(const KURL& url) const	949	bool Frame::isURLAllowed(const URL& url) const
950	{	950	{
951	// We allow one level of self-reference because some sites depend on that,	951	// We allow one level of self-reference because some sites depend on that,
952	// but we don't allow more than one.	952	// but we don't allow more than one.

Lines 193-199 namespace WebCore { a/Source/WebCore/page/Frame.h_sec1
- a/Source/WebCore/page/Frame.h -1 / +1 lines
193	void resumeActiveDOMObjectsAndAnimations();	193	void resumeActiveDOMObjectsAndAnimations();
194	bool activeDOMObjectsAndAnimationsSuspended() const { return m_activeDOMObjectsAndAnimationsSuspendedCount > 0; }	194	bool activeDOMObjectsAndAnimationsSuspended() const { return m_activeDOMObjectsAndAnimationsSuspendedCount > 0; }
195		195
196	bool isURLAllowed(const KURL&) const;	196	bool isURLAllowed(const URL&) const;
197		197
198	// ========	198	// ========
199		199

Lines 1824-1830 void FrameView::restoreScrollbar() a/Source/WebCore/page/FrameView.cpp_sec1
- a/Source/WebCore/page/FrameView.cpp -1 / +1 lines
1824	setScrollbarsSuppressed(false);	1824	setScrollbarsSuppressed(false);
1825	}	1825	}
1826		1826
1827	bool FrameView::scrollToFragment(const KURL& url)	1827	bool FrameView::scrollToFragment(const URL& url)
1828	{	1828	{
1829	// If our URL has no ref, then we have no place we need to jump to.	1829	// If our URL has no ref, then we have no place we need to jump to.
1830	// OTOH If CSS target was set previously, we want to set it to 0, recalc	1830	// OTOH If CSS target was set previously, we want to set it to 0, recalc



class FloatSize;
class Frame;
class HTMLFrameOwnerElement;
class URL;
class Node;
class Page;
class RenderBox;

    // NO OTHER PLATFORM BESIDES MAC SHOULD USE THIS METHOD.
    void adjustPageHeightDeprecated(float* newBottom, float oldTop, float oldBottom, float bottomLimit);

    bool scrollToFragment(const URL&);
    bool scrollToAnchor(const String&);
    void maintainScrollPositionAtAnchor(Node*);
    void scrollElementToRect(Element*, const IntRect&);



    m_frame->navigationScheduler().scheduleHistoryNavigation(distance);
}

URL History::urlForState(const String& urlString)
{
    URL baseURL = m_frame->document()->baseURL();
    if (urlString.isEmpty())
        return baseURL;

    return URL(baseURL, urlString);
}

void History::stateObjectAdded(PassRefPtr<SerializedScriptValue> data, const String& title, const String& urlString, StateObjectType stateObjectType, ExceptionCode& ec)

    if (!m_frame || !m_frame->page())
        return;
    
    URL fullURL = urlForState(urlString);
    if (!fullURL.isValid() || !m_frame->document()->securityOrigin()->canRequest(fullURL)) {
        ec = SECURITY_ERR;
        return;



#define History_h

#include "DOMWindowProperty.h"
#include "KURL.h"
#include "ScriptWrappable.h"
#include "SerializedScriptValue.h"
#include "URL.h"
#include <wtf/Forward.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>

private:
    explicit History(Frame*);

    URL urlForState(const String& url);

    PassRefPtr<SerializedScriptValue> stateInternal() const;




#include "ExceptionCode.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "URL.h"
#include "SecurityOrigin.h"

namespace WebCore {

{
}

inline const URL& Location::url() const
{
    ASSERT(m_frame);

    const URL& url = m_frame->document()->url();
    if (!url.isValid())
        return blankURL(); // Use "about:blank" while the page is still loading (before we have a frame).



    // Note: this is the IE spec. The NS spec swaps the two, it says
    // "The hostname property is the concatenation of the host and port properties, separated by a colon."
    const URL& url = this->url();
    return url.hasPort() ? url.host() + ":" + String::number(url.port()) : url.host();
}


    if (!m_frame)
        return String();

    const URL& url = this->url();
    return url.hasPort() ? String::number(url.port()) : "";
}


    if (!m_frame)
        return String();

    const URL& url = this->url();
    return url.path().isEmpty() ? "/" : url.path();
}


    if (!m_frame)
        return String();

    const URL& url = this->url();
    return url.query().isEmpty() ? emptyString() : "?" + url.query();
}


{
    if (!m_frame)
        return;
    URL url = m_frame->document()->url();
    if (!url.setProtocol(protocol)) {
        ec = SYNTAX_ERR;
        return;

{
    if (!m_frame)
        return;
    URL url = m_frame->document()->url();
    url.setHostAndPort(host);
    setLocation(url.string(), activeWindow, firstWindow);
}

{
    if (!m_frame)
        return;
    URL url = m_frame->document()->url();
    url.setHost(hostname);
    setLocation(url.string(), activeWindow, firstWindow);
}

{
    if (!m_frame)
        return;
    URL url = m_frame->document()->url();
    int port = portString.toInt();
    if (port < 0 || port > 0xFFFF || portString.isEmpty())
        url.removePort();

{
    if (!m_frame)
        return;
    URL url = m_frame->document()->url();
    url.setPath(pathname);
    setLocation(url.string(), activeWindow, firstWindow);
}

{
    if (!m_frame)
        return;
    URL url = m_frame->document()->url();
    url.setQuery(search);
    setLocation(url.string(), activeWindow, firstWindow);
}

{
    if (!m_frame)
        return;
    URL url = m_frame->document()->url();
    String oldFragmentIdentifier = url.fragmentIdentifier();
    String newFragmentIdentifier = hash;
    if (hash[0] == '#')




class DOMWindow;
class Frame;
class URL;

typedef int ExceptionCode;



    void setLocation(const String&, DOMWindow* activeWindow, DOMWindow* firstWindow);

    const URL& url() const;
};

} // namespace WebCore

Lines 961-967 void Page::userStyleSheetLocationChanged() a/Source/WebCore/page/Page.cpp_sec1
- a/Source/WebCore/page/Page.cpp -1 / +1 lines
961	{	961	{
962	// FIXME: Eventually we will move to a model of just being handed the sheet	962	// FIXME: Eventually we will move to a model of just being handed the sheet
963	// text instead of loading the URL ourselves.	963	// text instead of loading the URL ourselves.
964	KURL url = m_settings->userStyleSheetLocation();	964	URL url = m_settings->userStyleSheetLocation();
965		965
966	// Allow any local file URL scheme to be loaded.	966	// Allow any local file URL scheme to be loaded.
967	if (SchemeRegistry::shouldTreatURLSchemeAsLocal(url.protocol()))	967	if (SchemeRegistry::shouldTreatURLSchemeAsLocal(url.protocol()))



    pageCache()->markPagesForVistedLinkStyleRecalc();
}

void PageGroup::addVisitedLink(const URL& url)
{
    if (!shouldTrackVisitedLinks)
        return;

    return result.iterator->value.get();
}

void PageGroup::addUserScriptToWorld(DOMWrapperWorld* world, const String& source, const URL& url,
                                     const Vector<String>& whitelist, const Vector<String>& blacklist,
                                     UserScriptInjectionTime injectionTime, UserContentInjectedFrames injectedFrames)
{

    scriptsInWorld->append(userScript.release());
}

void PageGroup::addUserStyleSheetToWorld(DOMWrapperWorld* world, const String& source, const URL& url,
                                         const Vector<String>& whitelist, const Vector<String>& blacklist,
                                         UserContentInjectedFrames injectedFrames,
                                         UserStyleLevel level,

        invalidateInjectedStyleSheetCacheInAllFrames();
}

void PageGroup::removeUserScriptFromWorld(DOMWrapperWorld* world, const URL& url)
{
    ASSERT_ARG(world, world);


        m_userScripts->remove(it);
}

void PageGroup::removeUserStyleSheetFromWorld(DOMWrapperWorld* world, const URL& url)
{
    ASSERT_ARG(world, world);




    class CaptionPreferencesChangedListener;
    class CaptionUserPreferences;
#endif
    class URL;
    class GroupSettings;
    class IDBFactoryBackendInterface;
    class Page;


        bool isLinkVisited(LinkHash);

        void addVisitedLink(const URL&);
        void addVisitedLink(const UChar*, size_t);
        void addVisitedLinkHash(LinkHash);
        void removeVisitedLinks();


        StorageNamespace* transientLocalStorage(SecurityOrigin* topOrigin);

        void addUserScriptToWorld(DOMWrapperWorld*, const String& source, const URL&,
                                  const Vector<String>& whitelist, const Vector<String>& blacklist,
                                  UserScriptInjectionTime, UserContentInjectedFrames);
        void addUserStyleSheetToWorld(DOMWrapperWorld*, const String& source, const URL&,
                                      const Vector<String>& whitelist, const Vector<String>& blacklist,
                                      UserContentInjectedFrames,
                                      UserStyleLevel level = UserStyleUserLevel,
                                      UserStyleInjectionTime injectionTime = InjectInExistingDocuments);
        void removeUserScriptFromWorld(DOMWrapperWorld*, const URL&);
        void removeUserStyleSheetFromWorld(DOMWrapperWorld*, const URL&);

        void removeUserScriptsFromWorld(DOMWrapperWorld*);
        void removeUserStyleSheetsFromWorld(DOMWrapperWorld*);



    if (!frame)
        return;

    URL url = frame->document()->url();
    if (url.isValid() && !url.isBlankURL())
        return;


{
}

PageSerializer::Resource::Resource(const URL& url, const String& mimeType, PassRefPtr<SharedBuffer> data)
    : url(url)
    , mimeType(mimeType)
    , data(data)

void PageSerializer::serializeFrame(Frame* frame)
{
    Document* document = frame->document();
    URL url = document->url();
    if (!url.isValid() || url.isBlankURL()) {
        // For blank frames we generate a fake URL so they can be referenced by their containing frame.
        url = urlForBlankFrame(frame);


        if (isHTMLImageElement(element)) {
            HTMLImageElement* imageElement = toHTMLImageElement(element);
            URL url = document->completeURL(imageElement->getAttribute(HTMLNames::srcAttr));
            CachedImage* cachedImage = imageElement->cachedImage();
            addImageToResources(cachedImage, imageElement->renderer(), url);
        } else if (element->hasTagName(HTMLNames::linkTag)) {
            HTMLLinkElement* linkElement = static_cast<HTMLLinkElement*>(element);
            if (CSSStyleSheet* sheet = linkElement->sheet()) {
                URL url = document->completeURL(linkElement->getAttribute(HTMLNames::hrefAttr));
                serializeCSSStyleSheet(sheet, url);
                ASSERT(m_resourceURLs.contains(url));
            }
        } else if (isHTMLStyleElement(element)) {
            if (CSSStyleSheet* sheet = toHTMLStyleElement(element)->sheet())
                serializeCSSStyleSheet(sheet, URL());
        }
    }


        serializeFrame(childFrame);
}

void PageSerializer::serializeCSSStyleSheet(CSSStyleSheet* styleSheet, const URL& url)
{
    StringBuilder cssText;
    for (unsigned i = 0; i < styleSheet->length(); ++i) {

        // Some rules have resources associated with them that we need to retrieve.
        if (rule->type() == CSSRule::IMPORT_RULE) {
            CSSImportRule* importRule = static_cast<CSSImportRule*>(rule);
            URL importURL = document->completeURL(importRule->href());
            if (m_resourceURLs.contains(importURL))
                continue;
            serializeCSSStyleSheet(importRule->styleSheet(), importURL);

    }
}

void PageSerializer::addImageToResources(CachedImage* image, RenderObject* imageRenderer, const URL& url)
{
    if (!url.isValid() || m_resourceURLs.contains(url))
        return;


        CachedImage* image = static_cast<StyleCachedImage*>(styleImage)->cachedImage();

        URL url = document->completeURL(image->url());
        addImageToResources(image, 0, url);
    }
}

URL PageSerializer::urlForBlankFrame(Frame* frame)
{
    HashMap<Frame*, URL>::iterator iter = m_blankFrameURLs.find(frame);
    if (iter != m_blankFrameURLs.end())
        return iter->value;
    String url = "wyciwyg://frame/" + String::number(m_blankFrameCounter++);
    URL fakeURL(ParsedURLString, url);
    m_blankFrameURLs.add(frame, fakeURL);

    return fakeURL;



#ifndef PageSerializer_h
#define PageSerializer_h

#include "URL.h"
#include "URLHash.h"
#include "SharedBuffer.h"
#include <wtf/HashMap.h>
#include <wtf/ListHashSet.h>

class PageSerializer {
public:
    struct Resource {
        URL url;
        String mimeType;
        RefPtr<SharedBuffer> data;
        Resource();
        Resource(const URL&, const String& mimeType, PassRefPtr<SharedBuffer> data);
    };

    explicit PageSerializer(Vector<Resource>*);

    // vector is the top frame serialized content.
    void serialize(Page*);

    URL urlForBlankFrame(Frame*);

private:
    void serializeFrame(Frame*);

    // Serializes the stylesheet back to text and adds it to the resources if URL is not-empty.
    // It also adds any resources included in that stylesheet (including any imported stylesheets and their own resources).
    void serializeCSSStyleSheet(CSSStyleSheet*, const URL&);

    void addImageToResources(CachedImage*, RenderObject*, const URL&);
    void retrieveResourcesForProperties(const StylePropertySet*, Document*);
    void retrieveResourcesForRule(StyleRule*, Document*);

    Vector<Resource>* m_resources;
    ListHashSet<URL> m_resourceURLs;
    HashMap<Frame*, URL> m_blankFrameURLs;
    unsigned m_blankFrameCounter;
};


Lines 37-43 a/Source/WebCore/page/PerformanceResourceTiming.cpp_sec1
- a/Source/WebCore/page/PerformanceResourceTiming.cpp -1 / +1 lines
37	#include "Document.h"	37	#include "Document.h"
38	#include "DocumentLoadTiming.h"	38	#include "DocumentLoadTiming.h"
39	#include "DocumentLoader.h"	39	#include "DocumentLoader.h"
40	#include "KURL.h"	40	#include "URL.h"
41	#include "ResourceRequest.h"	41	#include "ResourceRequest.h"
42	#include "ResourceResponse.h"	42	#include "ResourceResponse.h"
43	#include "SecurityOrigin.h"	43	#include "SecurityOrigin.h"

Lines 42-48 a/Source/WebCore/page/PerformanceResourceTiming.h_sec1
- a/Source/WebCore/page/PerformanceResourceTiming.h -1 / +1 lines
42	namespace WebCore {	42	namespace WebCore {
43		43
44	class Document;	44	class Document;
45	class KURL;	45	class URL;
46	class ResourceLoadTiming;	46	class ResourceLoadTiming;
47	class ResourceRequest;	47	class ResourceRequest;
48	class ResourceResponse;	48	class ResourceResponse;




#include "BlobURL.h"
#include "FileSystem.h"
#include "URL.h"
#include "SchemeRegistry.h"
#include "SecurityPolicy.h"
#include "ThreadableBlobRegistry.h"

const int InvalidPort = 0;
const int MaxAllowedPort = 65535;

static bool schemeRequiresHost(const URL& url)
{
    // We expect URLs with these schemes to have authority components. If the
    // URL lacks an authority component, we get concerned and mark the origin

    return url.protocolIsInHTTPFamily() || url.protocolIs("ftp");
}

bool SecurityOrigin::shouldUseInnerURL(const URL& url)
{
#if ENABLE(BLOB)
    // FIXME: Blob URLs don't have inner URLs. Their form is "blob:<inner-origin>/<UUID>", so treating the part after "blob:" as a URL is incorrect.

// In general, extracting the inner URL varies by scheme. It just so happens
// that all the URL schemes we currently support that use inner URLs for their
// security origin can be parsed using this algorithm.
URL SecurityOrigin::extractInnerURL(const URL& url)
{
    if (url.innerURL())
        return *url.innerURL();
    // FIXME: Update this callsite to use the innerURL member function when
    // we finish implementing it.
    return URL(ParsedURLString, decodeURLEscapeSequences(url.path()));
}

static PassRefPtr<SecurityOrigin> getCachedOrigin(const URL& url)
{
#if ENABLE(BLOB)
    if (url.protocolIs("blob"))

    return 0;
}

static bool shouldTreatAsUniqueOrigin(const URL& url)
{
    if (!url.isValid())
        return true;

    // FIXME: Do we need to unwrap the URL further?
    URL innerURL = SecurityOrigin::shouldUseInnerURL(url) ? SecurityOrigin::extractInnerURL(url) : url;

    // FIXME: Check whether innerURL is valid.

    // For edge case URLs that were probably misparsed, make sure that the origin is unique.
    // This is an additional safety net against bugs in URL parsing, and for network back-ends that parse URLs differently,
    // and could misinterpret another component for hostname.
    if (schemeRequiresHost(innerURL) && innerURL.host().isEmpty())
        return true;

    return false;
}

SecurityOrigin::SecurityOrigin(const URL& url)
    : m_protocol(url.protocol().isNull() ? "" : url.protocol().lower())
    , m_host(url.host().isNull() ? "" : url.host().lower())
    , m_port(url.port())

{
}

PassRefPtr<SecurityOrigin> SecurityOrigin::create(const URL& url)
{
    RefPtr<SecurityOrigin> cachedOrigin = getCachedOrigin(url);
    if (cachedOrigin.get())

    m_domain = newDomain.lower();
}

bool SecurityOrigin::isSecure(const URL& url)
{
    // Invalid URLs are secure, as are URLs which have a secure protocol.
    if (!url.isValid() || SchemeRegistry::shouldTreatURLSchemeAsSecure(url.protocol()))

    return (m_filePath == other->m_filePath);
}

bool SecurityOrigin::canRequest(const URL& url) const
{
    if (m_universalAccess)
        return true;

    return false;
}

bool SecurityOrigin::taintsCanvas(const URL& url) const
{
    if (canRequest(url))
        return false;

// http or https, otherwise we ignore the nesting for the purpose of a security check. We need
// a facility for registering nesting schemes, and some generalized logic for them.
// This function should be removed as an outcome of https://bugs.webkit.org/show_bug.cgi?id=69196
static bool isFeedWithNestedProtocolInHTTPFamily(const URL& url)
{
    const String& urlString = url.string();
    if (!urlString.startsWith("feed", false))

        || urlString.startsWith("feedsearch:http:", false) || urlString.startsWith("feedsearch:https:", false);
}

bool SecurityOrigin::canDisplay(const URL& url) const
{
    if (m_universalAccess)
        return true;


PassRefPtr<SecurityOrigin> SecurityOrigin::createFromString(const String& originString)
{
    return SecurityOrigin::create(URL(URL(), originString));
}

static const char separatorCharacter = '_';

    // Make sure there's a first separator
    size_t separator1 = databaseIdentifier.find(separatorCharacter);
    if (separator1 == notFound)
        return create(URL());
        
    // Make sure there's a second separator
    size_t separator2 = databaseIdentifier.reverseFind(separatorCharacter);
    if (separator2 == notFound)
        return create(URL());
        
    // Ensure there were at least 2 separator characters. Some hostnames on intranets have
    // underscores in them, so we'll assume that any additional underscores are part of the host.
    if (separator1 == separator2)
        return create(URL());
        
    // Make sure the port section is a valid port number or doesn't exist
    bool portOkay;
    int port = databaseIdentifier.right(databaseIdentifier.length() - separator2 - 1).toInt(&portOkay);
    bool portAbsent = (separator2 == databaseIdentifier.length() - 1);
    if (!(portOkay || portAbsent))
        return create(URL());
    
    if (port < 0 || port > MaxAllowedPort)
        return create(URL());
        
    // Split out the 3 sections of data
    String protocol = databaseIdentifier.substring(0, separator1);
    String host = databaseIdentifier.substring(separator1 + 1, separator2 - separator1 - 1);
    
    host = decodeURLEscapeSequences(host);
    return create(URL(URL(), protocol + "://" + host + ":" + String::number(port) + "/"));
}

PassRefPtr<SecurityOrigin> SecurityOrigin::create(const String& protocol, const String& host, int port)

    if (port < 0 || port > MaxAllowedPort)
        return createUnique();
    String decodedHost = decodeURLEscapeSequences(host);
    return create(URL(URL(), protocol + "://" + host + ":" + String::number(port) + "/"));
}

String SecurityOrigin::databaseIdentifier() const 




namespace WebCore {

class URL;

class SecurityOrigin : public ThreadSafeRefCounted<SecurityOrigin> {
public:

        BlockAllStorage
    };

    static PassRefPtr<SecurityOrigin> create(const URL&);
    static PassRefPtr<SecurityOrigin> createUnique();

    static PassRefPtr<SecurityOrigin> createFromDatabaseIdentifier(const String&);

    // Generally, we add URL schemes to this list when WebKit support them. For
    // example, we don't include the "jar" scheme, even though Firefox
    // understands that "jar" uses an inner URL for it's security origin.
    static bool shouldUseInnerURL(const URL&);
    static URL extractInnerURL(const URL&);

    // Create a deep copy of this SecurityOrigin. This method is useful
    // when marshalling a SecurityOrigin to another thread.

    // Returns true if a given URL is secure, based either directly on its
    // own protocol, or, when relevant, on the protocol of its "inner URL"
    // Protocols like blob: and filesystem: fall into this latter category.
    static bool isSecure(const URL&);

    // Returns true if this SecurityOrigin can script objects in the given
    // SecurityOrigin. For example, call this function before allowing

    // Returns true if this SecurityOrigin can read content retrieved from
    // the given URL. For example, call this function before issuing
    // XMLHttpRequests.
    bool canRequest(const URL&) const;

    // Returns true if drawing an image from this URL taints a canvas from
    // this security origin. For example, call this function before
    // drawing an image onto an HTML canvas element with the drawImage API.
    bool taintsCanvas(const URL&) const;

    // Returns true if this SecurityOrigin can receive drag content from the
    // initiator. For example, call this function before allowing content to be

    // Returns true if |document| can display content from the given URL (e.g.,
    // in an iframe or as an image). For example, web sites generally cannot
    // display content from the user's files system.
    bool canDisplay(const URL&) const;

    // Returns true if this SecurityOrigin can load local resources, such
    // as images, iframes, and style sheets, and can link to local URLs.


private:
    SecurityOrigin();
    explicit SecurityOrigin(const URL&);
    explicit SecurityOrigin(const SecurityOrigin*);

    // FIXME: Rename this function to something more semantic.

Lines 29-35 a/Source/WebCore/page/SecurityOriginHash.h_sec1
- a/Source/WebCore/page/SecurityOriginHash.h -1 / +1 lines
29	#ifndef SecurityOriginHash_h	29	#ifndef SecurityOriginHash_h
30	#define SecurityOriginHash_h	30	#define SecurityOriginHash_h
31		31
32	#include "KURL.h"	32	#include "URL.h"
33	#include "SecurityOrigin.h"	33	#include "SecurityOrigin.h"
34	#include <wtf/RefPtr.h>	34	#include <wtf/RefPtr.h>
35		35



#include "config.h"
#include "SecurityPolicy.h"

#include "URL.h"
#include <wtf/MainThread.h>
#include "OriginAccessEntry.h"
#include "SecurityOrigin.h"

    return originAccessMap;
}

bool SecurityPolicy::shouldHideReferrer(const URL& url, const String& referrer)
{
    bool referrerIsSecureURL = protocolIs(referrer, "https");
    bool referrerIsWebURL = referrerIsSecureURL || protocolIs(referrer, "http");

    return !URLIsSecureURL;
}

String SecurityPolicy::generateReferrerHeader(ReferrerPolicy referrerPolicy, const URL& url, const String& referrer)
{
    if (referrer.isEmpty())
        return String();

    return false;
}

bool SecurityPolicy::isAccessToURLWhiteListed(const SecurityOrigin* activeOrigin, const URL& url)
{
    RefPtr<SecurityOrigin> targetOrigin = SecurityOrigin::create(url);
    return isAccessWhiteListed(activeOrigin, targetOrigin.get());




namespace WebCore {

class URL;
class SecurityOrigin;

class SecurityPolicy {

    // True if the referrer should be omitted according to the
    // ReferrerPolicyDefault. If you intend to send a referrer header, you
    // should use generateReferrerHeader instead.
    static bool shouldHideReferrer(const URL&, const String& referrer);

    // Returns the referrer modified according to the referrer policy for a
    // navigation to a given URL. If the referrer returned is empty, the
    // referrer header should be omitted.
    static String generateReferrerHeader(ReferrerPolicy, const URL&, const String& referrer);

    enum LocalLoadPolicy {
        AllowLocalLoadsForAll, // No restriction on local loads.

    static void resetOriginAccessWhitelists();

    static bool isAccessWhiteListed(const SecurityOrigin* activeOrigin, const SecurityOrigin* targetOrigin);
    static bool isAccessToURLWhiteListed(const SecurityOrigin* activeOrigin, const URL&);
};

} // namespace WebCore

Lines 414-420 void Settings::setPrivateBrowsingEnabled(bool privateBrowsingEnabled) a/Source/WebCore/page/Settings.cpp_sec1
- a/Source/WebCore/page/Settings.cpp -1 / +1 lines
414	m_page->privateBrowsingStateChanged();	414	m_page->privateBrowsingStateChanged();
415	}	415	}
416		416
417	void Settings::setUserStyleSheetLocation(const KURL& userStyleSheetLocation)	417	void Settings::setUserStyleSheetLocation(const URL& userStyleSheetLocation)
418	{	418	{
419	if (m_userStyleSheetLocation == userStyleSheetLocation)	419	if (m_userStyleSheetLocation == userStyleSheetLocation)
420	return;	420	return;



#include "EditingBehaviorTypes.h"
#include "FontRenderingMode.h"
#include "IntSize.h"
#include "URL.h"
#include "SecurityOrigin.h"
#include "SettingsMacros.h"
#include "Timer.h"

        void setDNSPrefetchingEnabled(bool);
        bool dnsPrefetchingEnabled() const { return m_dnsPrefetchingEnabled; }

        void setUserStyleSheetLocation(const URL&);
        const URL& userStyleSheetLocation() const { return m_userStyleSheetLocation; }

        void setNeedsAdobeFrameReloadingQuirk(bool);
        bool needsAcrobatFrameReloadingQuirk() const { return m_needsAdobeFrameReloadingQuirk; }

        Page* m_page;

        String m_mediaTypeOverride;
        URL m_userStyleSheetLocation;
        RefPtr<FontGenericFamilies> m_fontGenericFamilies;
        SecurityOrigin::StorageBlockingPolicy m_storageBlockingPolicy;
#if ENABLE(TEXT_AUTOSIZING)



#include "config.h"
#include "UserContentURLPattern.h"

#include "URL.h"
#include <wtf/StdLibExtras.h>

namespace WebCore {

bool UserContentURLPattern::matchesPatterns(const URL& url, const Vector<String>& whitelist, const Vector<String>& blacklist)
{
    // In order for a URL to be a match it has to be present in the whitelist and not present in the blacklist.
    // If there is no whitelist at all, then all URLs are assumed to be in the whitelist.

    return true;
}

bool UserContentURLPattern::matches(const URL& test) const
{
    if (m_invalid)
        return false;

    return matchesPath(test);
}

bool UserContentURLPattern::matchesHost(const URL& test) const
{
    const String& host = test.host();
    if (equalIgnoringCase(host, m_host))

    }
};

bool UserContentURLPattern::matchesPath(const URL& test) const
{
    MatchTester match(m_path, test.path());
    return match.test();




namespace WebCore {

class URL;

class UserContentURLPattern {
public:


    bool isValid() const { return !m_invalid; }

    bool matches(const URL&) const;

    const String& scheme() const { return m_scheme; }
    const String& host() const { return m_host; }


    bool matchSubdomains() const { return m_matchSubdomains; }
    
    static bool matchesPatterns(const URL&, const Vector<String>& whitelist, const Vector<String>& blacklist);

private:
    bool parse(const String& pattern);

    bool matchesHost(const URL&) const;
    bool matchesPath(const URL&) const;

    bool m_invalid;




#ifndef UserScript_h
#define UserScript_h

#include "URL.h"
#include "UserContentTypes.h"
#include "UserScriptTypes.h"
#include <wtf/Vector.h>

    {
    }

    UserScript(const String& source, const URL& url, const Vector<String>& whitelist, const Vector<String>& blacklist, UserScriptInjectionTime injectionTime, UserContentInjectedFrames injectedFrames)
        : m_source(source)
        , m_url(url)
        , m_whitelist(whitelist)

    }

    const String& source() const { return m_source; }
    const URL& url() const { return m_url; }
    const Vector<String>& whitelist() const { return m_whitelist; }
    const Vector<String>& blacklist() const { return m_blacklist; }
    UserScriptInjectionTime injectionTime() const { return m_injectionTime; }


private:
    String m_source;
    URL m_url;
    Vector<String> m_whitelist;
    Vector<String> m_blacklist;
    UserScriptInjectionTime m_injectionTime;



#ifndef UserStyleSheet_h
#define UserStyleSheet_h

#include "URL.h"
#include "UserContentTypes.h"
#include "UserStyleSheetTypes.h"
#include <wtf/Vector.h>

    {
    }

    UserStyleSheet(const String& source, const URL& url, const Vector<String>& whitelist, const Vector<String>& blacklist, UserContentInjectedFrames injectedFrames, UserStyleLevel level)
        : m_source(source)
        , m_url(url)
        , m_whitelist(whitelist)

    }

    const String& source() const { return m_source; }
    const URL& url() const { return m_url; }
    const Vector<String>& whitelist() const { return m_whitelist; }
    const Vector<String>& blacklist() const { return m_blacklist; }
    UserContentInjectedFrames injectedFrames() const { return m_injectedFrames; }


private:
    String m_source;
    URL m_url;
    Vector<String> m_whitelist;
    Vector<String> m_blacklist;
    UserContentInjectedFrames m_injectedFrames;

Lines 67-73 void DragController::cleanupAfterSystemDrag() a/Source/WebCore/page/efl/DragControllerEfl.cpp_sec1
- a/Source/WebCore/page/efl/DragControllerEfl.cpp -1 / +1 lines
67	{	67	{
68	}	68	}
69		69
70	void DragController::declareAndWriteDragImage(Clipboard, Element, const KURL&, const String&)	70	void DragController::declareAndWriteDragImage(Clipboard, Element, const URL&, const String&)
71	{	71	{
72	}	72	}
73		73

Lines 69-75 void DragController::cleanupAfterSystemDrag() a/Source/WebCore/page/gtk/DragControllerGtk.cpp_sec1
- a/Source/WebCore/page/gtk/DragControllerGtk.cpp -1 / +1 lines
69	{	69	{
70	}	70	}
71		71
72	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const KURL& url, const String& label)	72	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const URL& url, const String& label)
73	{	73	{
74	clipboard->pasteboard().writeImage(element, url, label);	74	clipboard->pasteboard().writeImage(element, url, label);
75	}	75	}

Lines 84-90 void DragController::cleanupAfterSystemDrag() a/Source/WebCore/page/mac/DragControllerMac.mm_sec1
- a/Source/WebCore/page/mac/DragControllerMac.mm -1 / +1 lines
84	dragEnded();	84	dragEnded();
85	}	85	}
86		86
87	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const KURL& url, const String& label)	87	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const URL& url, const String& label)
88	{	88	{
89	m_client.declareAndWriteDragImage(clipboard->pasteboard().name(), kit(element), url, label, element->document().frame());	89	m_client.declareAndWriteDragImage(clipboard->pasteboard().name(), kit(element), url, label, element->document().frame());
90	}	90	}

Lines 71-77 void DragController::cleanupAfterSystemDrag() a/Source/WebCore/page/qt/DragControllerQt.cpp_sec1
- a/Source/WebCore/page/qt/DragControllerQt.cpp -1 / +1 lines
71	{	71	{
72	}	72	}
73		73
74	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const KURL& url, const String& label)	74	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const URL& url, const String& label)
75	{	75	{
76	clipboard->pasteboard().writeImage(element, url, label);	76	clipboard->pasteboard().writeImage(element, url, label);
77	}	77	}

Lines 70-76 void DragController::cleanupAfterSystemDrag() a/Source/WebCore/page/win/DragControllerWin.cpp_sec1
- a/Source/WebCore/page/win/DragControllerWin.cpp -1 / +1 lines
70	{	70	{
71	}	71	}
72		72
73	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const KURL& url, const String& label)	73	void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const URL& url, const String& label)
74	{	74	{
75	Pasteboard& pasteboard = clipboard->pasteboard();	75	Pasteboard& pasteboard = clipboard->pasteboard();
76		76



#if ENABLE(FILE_SYSTEM)

#include "FileSystemType.h"
#include "URL.h"
#include "Timer.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/text/WTFString.h>

    // Moves a file or directory from srcPath to destPath.
    // AsyncFileSystemCallbacks::didSucceed() is called when the operation is completed successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void move(const URL& srcPath, const URL& destPath, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Copies a file or directory from srcPath to destPath.
    // AsyncFileSystemCallbacks::didSucceed() is called when the operation is completed successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void copy(const URL& srcPath, const URL& destPath, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Deletes a file or directory at a given path.
    // It is an error to try to remove a directory that is not empty.
    // AsyncFileSystemCallbacks::didSucceed() is called when the operation is completed successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void remove(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Recursively deletes a directory at a given path.
    // AsyncFileSystemCallbacks::didSucceed() is called when the operation is completed successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void removeRecursively(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Retrieves the metadata information of the file or directory at a given path.
    // AsyncFileSystemCallbacks::didReadMetadata() is called when the operation is completed successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void readMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Creates a file at a given path.  If exclusive flag is true, it fails if the path already exists.
    // AsyncFileSystemCallbacks::didSucceed() is called when the operation is completed successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void createFile(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Creates a directory at a given path.  If exclusive flag is true, it fails if the path already exists.
    // AsyncFileSystemCallbacks::didSucceed() is called when the operation is completed successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void createDirectory(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Checks if a file exists at a given path.
    // AsyncFileSystemCallbacks::didSucceed() is called if the file exists.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void fileExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Checks if a directory exists at a given path.
    // AsyncFileSystemCallbacks::didSucceed() is called if the directory exists.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void directoryExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Reads directory entries of a given directory at path.
    // AsyncFileSystemCallbacks::didReadDirectoryEntry() is called when each directory entry is called. AsyncFileSystemCallbacks::didReadDirectoryEntries() is called after a chunk of directory entries have been read.
    // AsyncFileSystemCallbacks::didFail() is when there is an error.
    virtual void readDirectory(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Creates an AsyncFileWriter for a given file path.
    // AsyncFileSystemCallbacks::didCreateFileWriter() is called when an AsyncFileWriter is created successfully.
    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    virtual void createWriter(AsyncFileWriterClient*, const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Creates a snapshot file and read its metadata for a new File object.
    // In local filesystem cases the backend may simply return the metadata of the file itself (as well as readMetadata does),

    // AsyncFileSystemCallbacks::didFail() is called otherwise.
    //
    // Note: the returned metadata info is cached in the File object for non-regular filesystem types (neither Temporary nor Persistent). The port could return valid metadata if it wants File object to cache metadata (e.g. if the file body is on a remote server), but otherwise should NOT return valid metadata.
    virtual void createSnapshotFileAndReadMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

protected:
    AsyncFileSystem() { }

Lines 50-56 public: a/Source/WebCore/platform/AsyncFileSystemCallbacks.h_sec1
- a/Source/WebCore/platform/AsyncFileSystemCallbacks.h -1 / +1 lines
50	virtual void didSucceed() { ASSERT_NOT_REACHED(); }	50	virtual void didSucceed() { ASSERT_NOT_REACHED(); }
51		51
52	// Called when a requested file system is opened.	52	// Called when a requested file system is opened.
53	virtual void didOpenFileSystem(const String& /* name /, const KURL& / rootURL */, PassOwnPtr<AsyncFileSystem>) { ASSERT_NOT_REACHED(); }	53	virtual void didOpenFileSystem(const String& /* name /, const URL& / rootURL */, PassOwnPtr<AsyncFileSystem>) { ASSERT_NOT_REACHED(); }
54		54
55	// Called when a file metadata is read successfully.	55	// Called when a file metadata is read successfully.
56	virtual void didReadMetadata(const FileMetadata&) { ASSERT_NOT_REACHED(); }	56	virtual void didReadMetadata(const FileMetadata&) { ASSERT_NOT_REACHED(); }




namespace WebCore {

class URL;
class NetworkStorageSession;
struct Cookie;

class CookiesStrategy {
public:
    virtual String cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&) = 0;
    virtual void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String& cookieString) = 0;
    virtual bool cookiesEnabled(const NetworkStorageSession&, const URL& firstParty, const URL&) = 0;
    virtual String cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&) = 0;
    virtual bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>&) = 0;
    virtual void deleteCookie(const NetworkStorageSession&, const URL&, const String& cookieName) = 0;

protected:
    virtual ~CookiesStrategy() { }




#include "CrossThreadCopier.h"

#include "URL.h"
#include "ResourceError.h"
#include "ResourceRequest.h"
#include "ResourceResponse.h"


namespace WebCore {

CrossThreadCopierBase<false, false, URL>::Type CrossThreadCopierBase<false, false, URL>::copy(const URL& url)
{
    return url.copy();
}




    class IntRect;
    class IntSize;
    class URL;
    class ResourceError;
    class ResourceRequest;
    class ResourceResponse;

        }
    };

    template<> struct CrossThreadCopierBase<false, false, URL> {
        typedef URL Type;
        static Type copy(const URL&);
    };

    template<> struct CrossThreadCopierBase<false, false, String> {

Lines 69-75 namespace WebCore { a/Source/WebCore/platform/DragData.h_sec1
- a/Source/WebCore/platform/DragData.h -1 / +1 lines
69		69
70	class Frame;	70	class Frame;
71	class DocumentFragment;	71	class DocumentFragment;
72	class KURL;	72	class URL;
73	class Range;	73	class Range;
74		74
75	enum DragApplicationFlags {	75	enum DragApplicationFlags {

Lines 63-69 DragImageRef fitDragImageToMaxSize(DragImageRef image, const IntSize& srcSize, c a/Source/WebCore/platform/DragImage.cpp_sec1
- a/Source/WebCore/platform/DragImage.cpp -1 / +1 lines
63	}	63	}
64		64
65	#if !PLATFORM(MAC) && (!PLATFORM(WIN) \|\| OS(WINCE))	65	#if !PLATFORM(MAC) && (!PLATFORM(WIN) \|\| OS(WINCE))
66	DragImageRef createDragImageForLink(KURL&, const String&, FontRenderingMode)	66	DragImageRef createDragImageForLink(URL&, const String&, FontRenderingMode)
67	{	67	{
68	return 0;	68	return 0;
69	}	69	}



namespace WebCore {

    class Image;
    class URL;

#if PLATFORM(MAC)
    typedef RetainPtr<NSImage> DragImageRef;

    
    DragImageRef createDragImageFromImage(Image*, ImageOrientationDescription);
    DragImageRef createDragImageIconForCachedImageFilename(const String&);
    DragImageRef createDragImageForLink(URL&, const String& label, FontRenderingMode);
    void deleteDragImage(DragImageRef);
}


Lines 134-140 int FileStream::read(char* buffer, int bufferSize) a/Source/WebCore/platform/FileStream.cpp_sec1
- a/Source/WebCore/platform/FileStream.cpp -1 / +1 lines
134	return bytesRead;	134	return bytesRead;
135	}	135	}
136		136
137	int FileStream::write(const KURL&, long long, int)	137	int FileStream::write(const URL&, long long, int)
138	{	138	{
139	// FIXME: to be implemented.	139	// FIXME: to be implemented.
140	return -1;	140	return -1;




namespace WebCore {

class URL;

// All methods are synchronous.
class FileStream : public RefCounted<FileStream> {


    // Writes a blob to the file.
    // Returns number of bytes being written on success. -1 otherwise.
    int write(const URL& blobURL, long long position, int length);

    // Truncates the file to the specified position.
    // Returns true on success. False otherwise.



/*
 * Copyright (C) 2004, 2007, 2008, 2011, 2012, 2013 Apple Inc. All rights reserved.
 * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "KURL.h"

#include "DecodeEscapeSequences.h"
#include "MIMETypeRegistry.h"
#include "TextEncoding.h"
#include <stdio.h>
#include <wtf/HashMap.h>
#include <wtf/HexNumber.h>
#include <wtf/StdLibExtras.h>
#include <wtf/text/CString.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringHash.h>

#if USE(ICU_UNICODE)
#include <unicode/uidna.h>
#endif

// FIXME: This file makes too much use of the + operator on String.
// We either have to optimize that operator so it doesn't involve
// so many allocations, or change this to use StringBuffer instead.

using namespace std;
using namespace WTF;

namespace WebCore {

typedef Vector<char, 512> CharBuffer;
typedef Vector<UChar, 512> UCharBuffer;

static const unsigned maximumValidPortNumber = 0xFFFE;
static const unsigned invalidPortNumber = 0xFFFF;

static inline bool isLetterMatchIgnoringCase(UChar character, char lowercaseLetter)
{
    ASSERT(isASCIILower(lowercaseLetter));
    return (character | 0x20) == lowercaseLetter;
}

static const char wsScheme[] = {'w', 's'};
static const char ftpScheme[] = {'f', 't', 'p'};
static const char ftpPort[] = {'2', '1'};
static const char wssScheme[] = {'w', 's', 's'};
static const char fileScheme[] = {'f', 'i', 'l', 'e'};
static const char httpScheme[] = {'h', 't', 't', 'p'};
static const char httpPort[] = {'8', '0'};
static const char httpsScheme[] = {'h', 't', 't', 'p', 's'};
static const char httpsPort[] = {'4', '4', '3'};
static const char gopherScheme[] = {'g', 'o', 'p', 'h', 'e', 'r'};
static const char gopherPort[] = {'7', '0'};

static inline bool isLetterMatchIgnoringCase(char character, char lowercaseLetter)
{
    ASSERT(isASCIILower(lowercaseLetter));
    return (character | 0x20) == lowercaseLetter;
}

enum URLCharacterClasses {
    // alpha 
    SchemeFirstChar = 1 << 0,

    // ( alpha | digit | "+" | "-" | "." )
    SchemeChar = 1 << 1,

    // mark        = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
    // unreserved  = alphanum | mark
    // ( unreserved | escaped | ";" | ":" | "&" | "=" | "+" | "$" | "," )
    UserInfoChar = 1 << 2,

    // alnum | "." | "-" | "%"
    // The above is what the specification says, but we are lenient to
    // match existing practice and also allow:
    // "_"
    HostnameChar = 1 << 3,

    // hexdigit | ":" | "%"
    IPv6Char = 1 << 4,

    // "#" | "?" | "/" | nul
    PathSegmentEndChar = 1 << 5,

    // not allowed in path
    BadChar = 1 << 6
};

static const unsigned char characterClassTable[256] = {
    /* 0 nul */ PathSegmentEndChar,    /* 1 soh */ BadChar,
    /* 2 stx */ BadChar,    /* 3 etx */ BadChar,
    /* 4 eot */ BadChar,    /* 5 enq */ BadChar,    /* 6 ack */ BadChar,    /* 7 bel */ BadChar,
    /* 8 bs */ BadChar,     /* 9 ht */ BadChar,     /* 10 nl */ BadChar,    /* 11 vt */ BadChar,
    /* 12 np */ BadChar,    /* 13 cr */ BadChar,    /* 14 so */ BadChar,    /* 15 si */ BadChar,
    /* 16 dle */ BadChar,   /* 17 dc1 */ BadChar,   /* 18 dc2 */ BadChar,   /* 19 dc3 */ BadChar,
    /* 20 dc4 */ BadChar,   /* 21 nak */ BadChar,   /* 22 syn */ BadChar,   /* 23 etb */ BadChar,
    /* 24 can */ BadChar,   /* 25 em */ BadChar,    /* 26 sub */ BadChar,   /* 27 esc */ BadChar,
    /* 28 fs */ BadChar,    /* 29 gs */ BadChar,    /* 30 rs */ BadChar,    /* 31 us */ BadChar,
    /* 32 sp */ BadChar,    /* 33  ! */ UserInfoChar,
    /* 34  " */ BadChar,    /* 35  # */ PathSegmentEndChar | BadChar,
    /* 36  $ */ UserInfoChar,    /* 37  % */ UserInfoChar | HostnameChar | IPv6Char | BadChar,
    /* 38  & */ UserInfoChar,    /* 39  ' */ UserInfoChar,
    /* 40  ( */ UserInfoChar,    /* 41  ) */ UserInfoChar,
    /* 42  * */ UserInfoChar,    /* 43  + */ SchemeChar | UserInfoChar,
    /* 44  , */ UserInfoChar,
    /* 45  - */ SchemeChar | UserInfoChar | HostnameChar,
    /* 46  . */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 47  / */ PathSegmentEndChar,
    /* 48  0 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 49  1 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,    
    /* 50  2 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 51  3 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 52  4 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 53  5 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 54  6 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 55  7 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 56  8 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 57  9 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 58  : */ UserInfoChar | IPv6Char,    /* 59  ; */ UserInfoChar,
    /* 60  < */ BadChar,    /* 61  = */ UserInfoChar,
    /* 62  > */ BadChar,    /* 63  ? */ PathSegmentEndChar | BadChar,
    /* 64  @ */ 0,
    /* 65  A */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,    
    /* 66  B */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 67  C */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 68  D */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 69  E */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 70  F */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 71  G */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 72  H */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 73  I */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 74  J */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 75  K */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 76  L */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 77  M */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 78  N */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 79  O */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 80  P */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 81  Q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 82  R */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 83  S */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 84  T */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 85  U */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 86  V */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 87  W */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 88  X */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 89  Y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 90  Z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 91  [ */ 0,
    /* 92  \ */ 0,    /* 93  ] */ 0,
    /* 94  ^ */ 0,
    /* 95  _ */ UserInfoChar | HostnameChar,
    /* 96  ` */ 0,
    /* 97  a */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 98  b */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 99  c */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 100  d */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 101  e */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
    /* 102  f */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
    /* 103  g */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 104  h */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 105  i */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 106  j */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 107  k */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 108  l */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 109  m */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 110  n */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 111  o */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 112  p */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 113  q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 114  r */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 115  s */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 116  t */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 117  u */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 118  v */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 119  w */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 120  x */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 121  y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
    /* 122  z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
    /* 123  { */ 0,
    /* 124  | */ 0,   /* 125  } */ 0,   /* 126  ~ */ UserInfoChar,   /* 127 del */ BadChar,
    /* 128 */ BadChar, /* 129 */ BadChar, /* 130 */ BadChar, /* 131 */ BadChar,
    /* 132 */ BadChar, /* 133 */ BadChar, /* 134 */ BadChar, /* 135 */ BadChar,
    /* 136 */ BadChar, /* 137 */ BadChar, /* 138 */ BadChar, /* 139 */ BadChar,
    /* 140 */ BadChar, /* 141 */ BadChar, /* 142 */ BadChar, /* 143 */ BadChar,
    /* 144 */ BadChar, /* 145 */ BadChar, /* 146 */ BadChar, /* 147 */ BadChar,
    /* 148 */ BadChar, /* 149 */ BadChar, /* 150 */ BadChar, /* 151 */ BadChar,
    /* 152 */ BadChar, /* 153 */ BadChar, /* 154 */ BadChar, /* 155 */ BadChar,
    /* 156 */ BadChar, /* 157 */ BadChar, /* 158 */ BadChar, /* 159 */ BadChar,
    /* 160 */ BadChar, /* 161 */ BadChar, /* 162 */ BadChar, /* 163 */ BadChar,
    /* 164 */ BadChar, /* 165 */ BadChar, /* 166 */ BadChar, /* 167 */ BadChar,
    /* 168 */ BadChar, /* 169 */ BadChar, /* 170 */ BadChar, /* 171 */ BadChar,
    /* 172 */ BadChar, /* 173 */ BadChar, /* 174 */ BadChar, /* 175 */ BadChar,
    /* 176 */ BadChar, /* 177 */ BadChar, /* 178 */ BadChar, /* 179 */ BadChar,
    /* 180 */ BadChar, /* 181 */ BadChar, /* 182 */ BadChar, /* 183 */ BadChar,
    /* 184 */ BadChar, /* 185 */ BadChar, /* 186 */ BadChar, /* 187 */ BadChar,
    /* 188 */ BadChar, /* 189 */ BadChar, /* 190 */ BadChar, /* 191 */ BadChar,
    /* 192 */ BadChar, /* 193 */ BadChar, /* 194 */ BadChar, /* 195 */ BadChar,
    /* 196 */ BadChar, /* 197 */ BadChar, /* 198 */ BadChar, /* 199 */ BadChar,
    /* 200 */ BadChar, /* 201 */ BadChar, /* 202 */ BadChar, /* 203 */ BadChar,
    /* 204 */ BadChar, /* 205 */ BadChar, /* 206 */ BadChar, /* 207 */ BadChar,
    /* 208 */ BadChar, /* 209 */ BadChar, /* 210 */ BadChar, /* 211 */ BadChar,
    /* 212 */ BadChar, /* 213 */ BadChar, /* 214 */ BadChar, /* 215 */ BadChar,
    /* 216 */ BadChar, /* 217 */ BadChar, /* 218 */ BadChar, /* 219 */ BadChar,
    /* 220 */ BadChar, /* 221 */ BadChar, /* 222 */ BadChar, /* 223 */ BadChar,
    /* 224 */ BadChar, /* 225 */ BadChar, /* 226 */ BadChar, /* 227 */ BadChar,
    /* 228 */ BadChar, /* 229 */ BadChar, /* 230 */ BadChar, /* 231 */ BadChar,
    /* 232 */ BadChar, /* 233 */ BadChar, /* 234 */ BadChar, /* 235 */ BadChar,
    /* 236 */ BadChar, /* 237 */ BadChar, /* 238 */ BadChar, /* 239 */ BadChar,
    /* 240 */ BadChar, /* 241 */ BadChar, /* 242 */ BadChar, /* 243 */ BadChar,
    /* 244 */ BadChar, /* 245 */ BadChar, /* 246 */ BadChar, /* 247 */ BadChar,
    /* 248 */ BadChar, /* 249 */ BadChar, /* 250 */ BadChar, /* 251 */ BadChar,
    /* 252 */ BadChar, /* 253 */ BadChar, /* 254 */ BadChar, /* 255 */ BadChar
};

static int copyPathRemovingDots(char* dst, const char* src, int srcStart, int srcEnd);
static void encodeRelativeString(const String& rel, const TextEncoding&, CharBuffer& ouput);
static String substituteBackslashes(const String&);

static inline bool isSchemeFirstChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & SchemeFirstChar; }
static inline bool isSchemeFirstChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeFirstChar); }
static inline bool isSchemeChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & SchemeChar; }
static inline bool isSchemeChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeChar); }
static inline bool isUserInfoChar(unsigned char c) { return characterClassTable[c] & UserInfoChar; }
static inline bool isHostnameChar(unsigned char c) { return characterClassTable[c] & HostnameChar; }
static inline bool isIPv6Char(unsigned char c) { return characterClassTable[c] & IPv6Char; }
static inline bool isPathSegmentEndChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & PathSegmentEndChar; }
static inline bool isPathSegmentEndChar(UChar c) { return c <= 0xff && (characterClassTable[c] & PathSegmentEndChar); }
static inline bool isBadChar(unsigned char c) { return characterClassTable[c] & BadChar; }
    
static inline bool isSchemeCharacterMatchIgnoringCase(char character, char schemeCharacter)
{
    ASSERT(isSchemeChar(character));
    ASSERT(schemeCharacter & 0x20);
    ASSERT(isASCIILower(schemeCharacter) || (!isASCIIUpper(schemeCharacter) && isSchemeChar(schemeCharacter)));
    return (character | 0x20) == schemeCharacter;
}

// Copies the source to the destination, assuming all the source characters are
// ASCII. The destination buffer must be large enough. Null characters are allowed
// in the source string, and no attempt is made to null-terminate the result.
static void copyASCII(const String& string, char* dest)
{
    if (string.isEmpty())
        return;

    if (string.is8Bit())
        memcpy(dest, string.characters8(), string.length());
    else {
        const UChar* src = string.characters16();
        size_t length = string.length();
        for (size_t i = 0; i < length; i++)
            dest[i] = static_cast<char>(src[i]);
    }
}

static void appendASCII(const String& base, const char* rel, size_t len, CharBuffer& buffer)
{
    buffer.resize(base.length() + len + 1);
    copyASCII(base, buffer.data());
    memcpy(buffer.data() + base.length(), rel, len);
    buffer[buffer.size() - 1] = '\0';
}

// FIXME: Move to WTFString.h eventually.
// Returns the index of the first index in string |s| of any of the characters
// in |toFind|. |toFind| should be a null-terminated string, all characters up
// to the null will be searched. Returns int if not found.
static int findFirstOf(const UChar* s, int sLen, int startPos, const char* toFind)
{
    for (int i = startPos; i < sLen; i++) {
        const char* cur = toFind;
        while (*cur) {
            if (s[i] == *(cur++))
                return i;
        }
    }
    return -1;
}

static inline void checkEncodedString(const String& url)
{
    ASSERT_UNUSED(url, url.containsOnlyASCII());
    ASSERT_UNUSED(url, url.isEmpty() || isSchemeFirstChar(url[0]));
}

inline bool KURL::protocolIs(const String& string, const char* protocol)
{
    return WebCore::protocolIs(string, protocol);
}

void KURL::invalidate()
{
    m_isValid = false;
    m_protocolIsInHTTPFamily = false;
    m_schemeEnd = 0;
    m_userStart = 0;
    m_userEnd = 0;
    m_passwordEnd = 0;
    m_hostEnd = 0;
    m_portEnd = 0;
    m_pathEnd = 0;
    m_pathAfterLastSlash = 0;
    m_queryEnd = 0;
    m_fragmentEnd = 0;
}

KURL::KURL(ParsedURLStringTag, const String& url)
{
    parse(url);
    ASSERT(url == m_string);
}

KURL::KURL(const KURL& base, const String& relative)
{
    init(base, relative, UTF8Encoding());
}

KURL::KURL(const KURL& base, const String& relative, const TextEncoding& encoding)
{
    // For UTF-{7,16,32}, we want to use UTF-8 for the query part as 
    // we do when submitting a form. A form with GET method
    // has its contents added to a URL as query params and it makes sense
    // to be consistent.
    init(base, relative, encoding.encodingForFormSubmission());
}

static bool shouldTrimFromURL(unsigned char c)
{
    // Browsers ignore leading/trailing whitespace and control
    // characters from URLs.  Note that c is an *unsigned* char here
    // so this comparison should only catch control characters.
    return c <= ' ';
}

void KURL::init(const KURL& base, const String& relative, const TextEncoding& encoding)
{
    // Allow resolutions with a null or empty base URL, but not with any other invalid one.
    // FIXME: Is this a good rule?
    if (!base.m_isValid && !base.isEmpty()) {
        m_string = relative;
        invalidate();
        return;
    }

    // For compatibility with Win IE, treat backslashes as if they were slashes,
    // as long as we're not dealing with javascript: or data: URLs.
    String rel = relative;
    if (rel.contains('\\') && !(protocolIsJavaScript(rel) || protocolIs(rel, "data")))
        rel = substituteBackslashes(rel);

    bool allASCII = rel.containsOnlyASCII();
    CharBuffer strBuffer;
    char* str;
    size_t len;
    if (allASCII) {
        len = rel.length();
        strBuffer.resize(len + 1);
        copyASCII(rel, strBuffer.data());
        strBuffer[len] = 0;
        str = strBuffer.data();
    } else {
        encodeRelativeString(rel, encoding, strBuffer);
        str = strBuffer.data();
        len = strlen(str);
    }

    // Get rid of leading whitespace and control characters.
    while (len && shouldTrimFromURL(*str)) {
        str++;
        --len;
    }

    // Get rid of trailing whitespace and control characters.
    while (len && shouldTrimFromURL(str[len - 1]))
        str[--len] = '\0';

    // According to the RFC, the reference should be interpreted as an
    // absolute URI if possible, using the "leftmost, longest"
    // algorithm. If the URI reference is absolute it will have a
    // scheme, meaning that it will have a colon before the first
    // non-scheme element.
    bool absolute = false;
    char* p = str;
    if (isSchemeFirstChar(*p)) {
        ++p;
        while (isSchemeChar(*p)) {
            ++p;
        }
        if (*p == ':') {
            if (p[1] != '/' && equalIgnoringCase(base.protocol(), String(str, p - str)) && base.isHierarchical())
                str = p + 1;
            else
                absolute = true;
        }
    }

    CharBuffer parseBuffer;

    if (absolute) {
        parse(str, &relative);
    } else {
        // If the base is empty or opaque (e.g. data: or javascript:), then the URL is invalid
        // unless the relative URL is a single fragment.
        if (!base.isHierarchical()) {
            if (str[0] == '#') {
                appendASCII(base.m_string.left(base.m_queryEnd), str, len, parseBuffer);
                parse(parseBuffer.data(), &relative);
            } else {
                m_string = relative;
                invalidate();
            }
            return;
        }

        switch (str[0]) {
        case '\0':
            // The reference is empty, so this is a reference to the same document with any fragment identifier removed.
            *this = base;
            removeFragmentIdentifier();
            break;
        case '#': {
            // must be fragment-only reference
            appendASCII(base.m_string.left(base.m_queryEnd), str, len, parseBuffer);
            parse(parseBuffer.data(), &relative);
            break;
        }
        case '?': {
            // query-only reference, special case needed for non-URL results
            appendASCII(base.m_string.left(base.m_pathEnd), str, len, parseBuffer);
            parse(parseBuffer.data(), &relative);
            break;
        }
        case '/':
            // must be net-path or absolute-path reference
            if (str[1] == '/') {
                // net-path
                appendASCII(base.m_string.left(base.m_schemeEnd + 1), str, len, parseBuffer);
                parse(parseBuffer.data(), &relative);
            } else {
                // abs-path
                appendASCII(base.m_string.left(base.m_portEnd), str, len, parseBuffer);
                parse(parseBuffer.data(), &relative);
            }
            break;
        default:
            {
                // must be relative-path reference

                // Base part plus relative part plus one possible slash added in between plus terminating \0 byte.
                const size_t bufferSize = base.m_pathEnd + 1 + len + 1;
                parseBuffer.resize(bufferSize);

                char* bufferPos = parseBuffer.data();
                char* bufferStart = bufferPos;

                // first copy everything before the path from the base
                CharBuffer baseStringBuffer(base.m_string.length());
                copyASCII(base.m_string, baseStringBuffer.data());
                const char* baseString = baseStringBuffer.data();
                const char* baseStringStart = baseString;
                const char* pathStart = baseStringStart + base.m_portEnd;
                while (baseStringStart < pathStart)
                    *bufferPos++ = *baseStringStart++;
                char* bufferPathStart = bufferPos;

                // now copy the base path
                const char* baseStringEnd = baseString + base.m_pathEnd;

                // go back to the last slash
                while (baseStringEnd > baseStringStart && baseStringEnd[-1] != '/')
                    baseStringEnd--;

                if (baseStringEnd == baseStringStart) {
                    // no path in base, add a path separator if necessary
                    if (base.m_schemeEnd + 1 != base.m_pathEnd && *str && *str != '?' && *str != '#')
                        *bufferPos++ = '/';
                } else {
                    bufferPos += copyPathRemovingDots(bufferPos, baseStringStart, 0, baseStringEnd - baseStringStart);
                }

                const char* relStringStart = str;
                const char* relStringPos = relStringStart;

                while (*relStringPos && *relStringPos != '?' && *relStringPos != '#') {
                    if (relStringPos[0] == '.' && bufferPos[-1] == '/') {
                        if (isPathSegmentEndChar(relStringPos[1])) {
                            // skip over "." segment
                            relStringPos += 1;
                            if (relStringPos[0] == '/')
                                relStringPos++;
                            continue;
                        } else if (relStringPos[1] == '.' && isPathSegmentEndChar(relStringPos[2])) {
                            // skip over ".." segment and rewind the last segment
                            // the RFC leaves it up to the app to decide what to do with excess
                            // ".." segments - we choose to drop them since some web content
                            // relies on this.
                            relStringPos += 2;
                            if (relStringPos[0] == '/')
                                relStringPos++;
                            if (bufferPos > bufferPathStart + 1)
                                bufferPos--;
                            while (bufferPos > bufferPathStart + 1  && bufferPos[-1] != '/')
                                bufferPos--;
                            continue;
                        }
                    }

                    *bufferPos = *relStringPos;
                    relStringPos++;
                    bufferPos++;
                }

                // all done with the path work, now copy any remainder
                // of the relative reference; this will also add a null terminator
                strncpy(bufferPos, relStringPos, bufferSize - (bufferPos - bufferStart));

                parse(parseBuffer.data(), &relative);

                ASSERT(strlen(parseBuffer.data()) + 1 <= parseBuffer.size());
                break;
            }
        }
    }
}

KURL KURL::copy() const
{
    KURL result = *this;
    result.m_string = result.m_string.isolatedCopy();
    return result;
}

String KURL::lastPathComponent() const
{
    if (!hasPath())
        return String();

    unsigned end = m_pathEnd - 1;
    if (m_string[end] == '/')
        --end;

    size_t start = m_string.reverseFind('/', end);
    if (start < static_cast<unsigned>(m_portEnd))
        return String();
    ++start;

    return m_string.substring(start, end - start + 1);
}

String KURL::protocol() const
{
    return m_string.left(m_schemeEnd);
}

String KURL::host() const
{
    int start = hostStart();
    return decodeURLEscapeSequences(m_string.substring(start, m_hostEnd - start));
}

unsigned short KURL::port() const
{
    // We return a port of 0 if there is no port specified. This can happen in two situations:
    // 1) The URL contains no colon after the host name and before the path component of the URL.
    // 2) The URL contains a colon but there's no port number before the path component of the URL begins.
    if (m_hostEnd == m_portEnd || m_hostEnd == m_portEnd - 1)
        return 0;

    const UChar* stringData = m_string.characters();
    bool ok = false;
    unsigned number = charactersToUIntStrict(stringData + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
    if (!ok || number > maximumValidPortNumber)
        return invalidPortNumber;
    return number;
}

String KURL::pass() const
{
    if (m_passwordEnd == m_userEnd)
        return String();

    return decodeURLEscapeSequences(m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1)); 
}

String KURL::user() const
{
    return decodeURLEscapeSequences(m_string.substring(m_userStart, m_userEnd - m_userStart));
}

String KURL::fragmentIdentifier() const
{
    if (m_fragmentEnd == m_queryEnd)
        return String();

    return m_string.substring(m_queryEnd + 1, m_fragmentEnd - (m_queryEnd + 1));
}

bool KURL::hasFragmentIdentifier() const
{
    return m_fragmentEnd != m_queryEnd;
}

String KURL::baseAsString() const
{
    return m_string.left(m_pathAfterLastSlash);
}

#if !PLATFORM(QT) && !USE(CF)
String KURL::fileSystemPath() const
{
    if (!isValid() || !isLocalFile())
        return String();

    return decodeURLEscapeSequences(path());
}
#endif

#ifdef NDEBUG

static inline void assertProtocolIsGood(const char*)
{
}

#else

static void assertProtocolIsGood(const char* protocol)
{
    const char* p = protocol;
    while (*p) {
        ASSERT(*p > ' ' && *p < 0x7F && !(*p >= 'A' && *p <= 'Z'));
        ++p;
    }
}

#endif

bool KURL::protocolIs(const char* protocol) const
{
    assertProtocolIsGood(protocol);

    // JavaScript URLs are "valid" and should be executed even if KURL decides they are invalid.
    // The free function protocolIsJavaScript() should be used instead. 
    ASSERT(!equalIgnoringCase(protocol, String("javascript")));

    if (!m_isValid)
        return false;

    // Do the comparison without making a new string object.
    for (int i = 0; i < m_schemeEnd; ++i) {
        if (!protocol[i] || !isSchemeCharacterMatchIgnoringCase(m_string[i], protocol[i]))
            return false;
    }
    return !protocol[m_schemeEnd]; // We should have consumed all characters in the argument.
}

String KURL::query() const
{
    if (m_queryEnd == m_pathEnd)
        return String();

    return m_string.substring(m_pathEnd + 1, m_queryEnd - (m_pathEnd + 1)); 
}

String KURL::path() const
{
    return m_string.substring(m_portEnd, m_pathEnd - m_portEnd);
}

bool KURL::setProtocol(const String& s)
{
    // Firefox and IE remove everything after the first ':'.
    size_t separatorPosition = s.find(':');
    String newProtocol = s.substring(0, separatorPosition);

    if (!isValidProtocol(newProtocol))
        return false;

    if (!m_isValid) {
        parse(newProtocol + ':' + m_string);
        return true;
    }

    parse(newProtocol + m_string.substring(m_schemeEnd));
    return true;
}

void KURL::setHost(const String& s)
{
    if (!m_isValid)
        return;

    // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
    // and to avoid changing more than just the host.

    bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;

    parse(m_string.left(hostStart()) + (slashSlashNeeded ? "//" : "") + s + m_string.substring(m_hostEnd));
}

void KURL::removePort()
{
    if (m_hostEnd == m_portEnd)
        return;
    parse(m_string.left(m_hostEnd) + m_string.substring(m_portEnd));
}

void KURL::setPort(unsigned short i)
{
    if (!m_isValid)
        return;

    bool colonNeeded = m_portEnd == m_hostEnd;
    int portStart = (colonNeeded ? m_hostEnd : m_hostEnd + 1);

    parse(m_string.left(portStart) + (colonNeeded ? ":" : "") + String::number(i) + m_string.substring(m_portEnd));
}

void KURL::setHostAndPort(const String& hostAndPort)
{
    if (!m_isValid)
        return;

    // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
    // and to avoid changing more than just host and port.

    bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;

    parse(m_string.left(hostStart()) + (slashSlashNeeded ? "//" : "") + hostAndPort + m_string.substring(m_portEnd));
}

void KURL::setUser(const String& user)
{
    if (!m_isValid)
        return;

    // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
    // and to avoid changing more than just the user login.

    int end = m_userEnd;
    if (!user.isEmpty()) {
        String u = user;
        if (m_userStart == m_schemeEnd + 1)
            u = "//" + u;
        // Add '@' if we didn't have one before.
        if (end == m_hostEnd || (end == m_passwordEnd && m_string[end] != '@'))
            u.append('@');
        parse(m_string.left(m_userStart) + u + m_string.substring(end));
    } else {
        // Remove '@' if we now have neither user nor password.
        if (m_userEnd == m_passwordEnd && end != m_hostEnd && m_string[end] == '@')
            end += 1;
        // We don't want to parse in the extremely common case where we are not going to make a change.
        if (m_userStart != end)
            parse(m_string.left(m_userStart) + m_string.substring(end));
    }
}

void KURL::setPass(const String& password)
{
    if (!m_isValid)
        return;

    // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
    // and to avoid changing more than just the user password.

    int end = m_passwordEnd;
    if (!password.isEmpty()) {
        String p = ":" + password + "@";
        if (m_userEnd == m_schemeEnd + 1)
            p = "//" + p;
        // Eat the existing '@' since we are going to add our own.
        if (end != m_hostEnd && m_string[end] == '@')
            end += 1;
        parse(m_string.left(m_userEnd) + p + m_string.substring(end));
    } else {
        // Remove '@' if we now have neither user nor password.
        if (m_userStart == m_userEnd && end != m_hostEnd && m_string[end] == '@')
            end += 1;
        // We don't want to parse in the extremely common case where we are not going to make a change.
        if (m_userEnd != end)
            parse(m_string.left(m_userEnd) + m_string.substring(end));
    }
}

void KURL::setFragmentIdentifier(const String& s)
{
    if (!m_isValid)
        return;

    // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations.
    parse(m_string.left(m_queryEnd) + "#" + s);
}

void KURL::removeFragmentIdentifier()
{
    if (!m_isValid)
        return;
    parse(m_string.left(m_queryEnd));
}
    
void KURL::setQuery(const String& query)
{
    if (!m_isValid)
        return;

    // FIXME: '#' and non-ASCII characters must be encoded and escaped.
    // Usually, the query is encoded using document encoding, not UTF-8, but we don't have
    // access to the document in this function.
    if ((query.isEmpty() || query[0] != '?') && !query.isNull())
        parse(m_string.left(m_pathEnd) + "?" + query + m_string.substring(m_queryEnd));
    else
        parse(m_string.left(m_pathEnd) + query + m_string.substring(m_queryEnd));

}

void KURL::setPath(const String& s)
{
    if (!m_isValid)
        return;

    // FIXME: encodeWithURLEscapeSequences does not correctly escape '#' and '?', so fragment and query parts
    // may be inadvertently affected.
    String path = s;
    if (path.isEmpty() || path[0] != '/')
        path = "/" + path;

    parse(m_string.left(m_portEnd) + encodeWithURLEscapeSequences(path) + m_string.substring(m_pathEnd));
}

String decodeURLEscapeSequences(const String& string)
{
    return decodeEscapeSequences<URLEscapeSequence>(string, UTF8Encoding());
}

String decodeURLEscapeSequences(const String& string, const TextEncoding& encoding)
{
    return decodeEscapeSequences<URLEscapeSequence>(string, encoding);
}

// Caution: This function does not bounds check.
static void appendEscapedChar(char*& buffer, unsigned char c)
{
    *buffer++ = '%';
    placeByteAsHex(c, buffer);
}

static void appendEscapingBadChars(char*& buffer, const char* strStart, size_t length)
{
    char* p = buffer;

    const char* str = strStart;
    const char* strEnd = strStart + length;
    while (str < strEnd) {
        unsigned char c = *str++;
        if (isBadChar(c)) {
            if (c == '%' || c == '?')
                *p++ = c;
            else if (c != 0x09 && c != 0x0a && c != 0x0d)
                appendEscapedChar(p, c);
        } else
            *p++ = c;
    }

    buffer = p;
}

static void escapeAndAppendNonHierarchicalPart(char*& buffer, const char* strStart, size_t length)
{
    char* p = buffer;

    const char* str = strStart;
    const char* strEnd = strStart + length;
    while (str < strEnd) {
        unsigned char c = *str++;
        // Strip CR, LF and Tab from fragments, per:
        // https://bugs.webkit.org/show_bug.cgi?id=8770
        if (c == 0x09 || c == 0x0a || c == 0x0d)
            continue;

        // Chrome and IE allow non-ascii characters in fragments, however doing
        // so would hit an ASSERT in checkEncodedString, so for now we don't.
        if (c < 0x20 || c >= 127) {
            appendEscapedChar(p, c);
            continue;
        }
        *p++ = c;
    }

    buffer = p;
}

// copy a path, accounting for "." and ".." segments
static int copyPathRemovingDots(char* dst, const char* src, int srcStart, int srcEnd)
{
    char* bufferPathStart = dst;

    // empty path is a special case, and need not have a leading slash
    if (srcStart != srcEnd) {
        const char* baseStringStart = src + srcStart;
        const char* baseStringEnd = src + srcEnd;
        const char* baseStringPos = baseStringStart;

        // this code is unprepared for paths that do not begin with a
        // slash and we should always have one in the source string
        ASSERT(baseStringPos[0] == '/');

        // copy the leading slash into the destination
        *dst = *baseStringPos;
        baseStringPos++;
        dst++;

        while (baseStringPos < baseStringEnd) {
            if (baseStringPos[0] == '.' && dst[-1] == '/') {
                if (baseStringPos[1] == '/' || baseStringPos + 1 == baseStringEnd) {
                    // skip over "." segment
                    baseStringPos += 2;
                    continue;
                } else if (baseStringPos[1] == '.' && (baseStringPos[2] == '/' ||
                                       baseStringPos + 2 == baseStringEnd)) {
                    // skip over ".." segment and rewind the last segment
                    // the RFC leaves it up to the app to decide what to do with excess
                    // ".." segments - we choose to drop them since some web content
                    // relies on this.
                    baseStringPos += 3;
                    if (dst > bufferPathStart + 1)
                        dst--;
                    while (dst > bufferPathStart && dst[-1] != '/')
                        dst--;
                    continue;
                }
            }

            *dst = *baseStringPos;
            baseStringPos++;
            dst++;
        }
    }
    *dst = '\0';
    return dst - bufferPathStart;
}

static inline bool hasSlashDotOrDotDot(const char* str)
{
    const unsigned char* p = reinterpret_cast<const unsigned char*>(str);
    if (!*p)
        return false;
    unsigned char pc = *p;
    while (unsigned char c = *++p) {
        if (c == '.' && (pc == '/' || pc == '.'))
            return true;
        pc = c;
    }
    return false;
}

void KURL::parse(const String& string)
{
    checkEncodedString(string);

    CharBuffer buffer(string.length() + 1);
    copyASCII(string, buffer.data());
    buffer[string.length()] = '\0';
    parse(buffer.data(), &string);
}

template<size_t length>
static inline bool equal(const char* a, const char (&b)[length])
{
    for (size_t i = 0; i < length; ++i) {
        if (a[i] != b[i])
            return false;
    }
    return true;
}

template<size_t lengthB>
static inline bool equal(const char* stringA, size_t lengthA, const char (&stringB)[lengthB])
{
    return lengthA == lengthB && equal(stringA, stringB);
}

// List of default schemes is taken from google-url:
// http://code.google.com/p/google-url/source/browse/trunk/src/url_canon_stdurl.cc#120
static inline bool isDefaultPortForScheme(const char* port, size_t portLength, const char* scheme, size_t schemeLength)
{
    // This switch is theoretically a performance optimization.  It came over when
    // the code was moved from google-url, but may be removed later.
    switch (schemeLength) {
    case 2:
        return equal(scheme, wsScheme) && equal(port, portLength, httpPort);
    case 3:
        if (equal(scheme, ftpScheme))
            return equal(port, portLength, ftpPort);
        if (equal(scheme, wssScheme))
            return equal(port, portLength, httpsPort);
        break;
    case 4:
        return equal(scheme, httpScheme) && equal(port, portLength, httpPort);
    case 5:
        return equal(scheme, httpsScheme) && equal(port, portLength, httpsPort);
    case 6:
        return equal(scheme, gopherScheme) && equal(port, portLength, gopherPort);
    }
    return false;
}

static inline bool hostPortIsEmptyButCredentialsArePresent(int hostStart, int portEnd, char userinfoEndChar)
{
    return userinfoEndChar == '@' && hostStart == portEnd;
}

static bool isNonFileHierarchicalScheme(const char* scheme, size_t schemeLength)
{
    switch (schemeLength) {
    case 2:
        return equal(scheme, wsScheme);
    case 3:
        return equal(scheme, ftpScheme) || equal(scheme, wssScheme);
    case 4:
        return equal(scheme, httpScheme);
    case 5:
        return equal(scheme, httpsScheme);
    case 6:
        return equal(scheme, gopherScheme);
    }
    return false;
}

static bool isCanonicalHostnameLowercaseForScheme(const char* scheme, size_t schemeLength)
{
    switch (schemeLength) {
    case 2:
        return equal(scheme, wsScheme);
    case 3:
        return equal(scheme, ftpScheme) || equal(scheme, wssScheme);
    case 4:
        return equal(scheme, httpScheme) || equal(scheme, fileScheme);
    case 5:
        return equal(scheme, httpsScheme);
    case 6:
        return equal(scheme, gopherScheme);
    }
    return false;
}

void KURL::parse(const char* url, const String* originalString)
{
    if (!url || url[0] == '\0') {
        // valid URL must be non-empty
        m_string = originalString ? *originalString : url;
        invalidate();
        return;
    }

    if (!isSchemeFirstChar(url[0])) {
        // scheme must start with an alphabetic character
        m_string = originalString ? *originalString : url;
        invalidate();
        return;
    }

    int schemeEnd = 0;
    while (isSchemeChar(url[schemeEnd]))
        schemeEnd++;

    if (url[schemeEnd] != ':') {
        m_string = originalString ? *originalString : url;
        invalidate();
        return;
    }

    int userStart = schemeEnd + 1;
    int userEnd;
    int passwordStart;
    int passwordEnd;
    int hostStart;
    int hostEnd;
    int portStart;
    int portEnd;

    bool hierarchical = url[schemeEnd + 1] == '/';
    bool hasSecondSlash = hierarchical && url[schemeEnd + 2] == '/';

    bool isFile = schemeEnd == 4
        && isLetterMatchIgnoringCase(url[0], 'f')
        && isLetterMatchIgnoringCase(url[1], 'i')
        && isLetterMatchIgnoringCase(url[2], 'l')
        && isLetterMatchIgnoringCase(url[3], 'e');

#if PLATFORM(BLACKBERRY)
    // Parse local: urls the same as file: urls.
    if (!isFile)
        isFile = schemeEnd == 5
            && isLetterMatchIgnoringCase(url[0], 'l')
            && isLetterMatchIgnoringCase(url[1], 'o')
            && isLetterMatchIgnoringCase(url[2], 'c')
            && isLetterMatchIgnoringCase(url[3], 'a')
            && isLetterMatchIgnoringCase(url[4], 'l');
#endif

    m_protocolIsInHTTPFamily = isLetterMatchIgnoringCase(url[0], 'h')
        && isLetterMatchIgnoringCase(url[1], 't')
        && isLetterMatchIgnoringCase(url[2], 't')
        && isLetterMatchIgnoringCase(url[3], 'p')
        && (url[4] == ':' || (isLetterMatchIgnoringCase(url[4], 's') && url[5] == ':'));

    if ((hierarchical && hasSecondSlash) || isNonFileHierarchicalScheme(url, schemeEnd)) {
        // The part after the scheme is either a net_path or an abs_path whose first path segment is empty.
        // Attempt to find an authority.
        // FIXME: Authority characters may be scanned twice, and it would be nice to be faster.

        if (hierarchical)
            userStart++;
        if (hasSecondSlash)
            userStart++;
        userEnd = userStart;

        int colonPos = 0;
        while (isUserInfoChar(url[userEnd])) {
            if (url[userEnd] == ':' && colonPos == 0)
                colonPos = userEnd;
            userEnd++;
        }

        if (url[userEnd] == '@') {
            // actual end of the userinfo, start on the host
            if (colonPos != 0) {
                passwordEnd = userEnd;
                userEnd = colonPos;
                passwordStart = colonPos + 1;
            } else
                passwordStart = passwordEnd = userEnd;

            hostStart = passwordEnd + 1;
        } else if (url[userEnd] == '[' || isPathSegmentEndChar(url[userEnd])) {
            // hit the end of the authority, must have been no user
            // or looks like an IPv6 hostname
            // either way, try to parse it as a hostname
            userEnd = userStart;
            passwordStart = passwordEnd = userEnd;
            hostStart = userStart;
        } else {
            // invalid character
            m_string = originalString ? *originalString : url;
            invalidate();
            return;
        }

        hostEnd = hostStart;

        // IPV6 IP address
        if (url[hostEnd] == '[') {
            hostEnd++;
            while (isIPv6Char(url[hostEnd]))
                hostEnd++;
            if (url[hostEnd] == ']')
                hostEnd++;
            else {
                // invalid character
                m_string = originalString ? *originalString : url;
                invalidate();
                return;
            }
        } else {
            while (isHostnameChar(url[hostEnd]))
                hostEnd++;
        }
        
        if (url[hostEnd] == ':') {
            portStart = portEnd = hostEnd + 1;
 
            // possible start of port
            portEnd = portStart;
            while (isASCIIDigit(url[portEnd]))
                portEnd++;
        } else
            portStart = portEnd = hostEnd;

        if (!isPathSegmentEndChar(url[portEnd])) {
            // invalid character
            m_string = originalString ? *originalString : url;
            invalidate();
            return;
        }

        if (hostPortIsEmptyButCredentialsArePresent(hostStart, portEnd, url[passwordEnd])) {
            m_string = originalString ? *originalString : url;
            invalidate();
            return;
        }

        if (userStart == portEnd && !m_protocolIsInHTTPFamily && !isFile) {
            // No authority found, which means that this is not a net_path, but rather an abs_path whose first two
            // path segments are empty. For file, http and https only, an empty authority is allowed.
            userStart -= 2;
            userEnd = userStart;
            passwordStart = userEnd;
            passwordEnd = passwordStart;
            hostStart = passwordEnd;
            hostEnd = hostStart;
            portStart = hostEnd;
            portEnd = hostEnd;
        }
    } else {
        // the part after the scheme must be an opaque_part or an abs_path
        userEnd = userStart;
        passwordStart = passwordEnd = userEnd;
        hostStart = hostEnd = passwordEnd;
        portStart = portEnd = hostEnd;
    }

    int pathStart = portEnd;
    int pathEnd = pathStart;
    while (url[pathEnd] && url[pathEnd] != '?' && url[pathEnd] != '#')
        pathEnd++;

    int queryStart = pathEnd;
    int queryEnd = queryStart;
    if (url[queryStart] == '?') {
        while (url[queryEnd] && url[queryEnd] != '#')
            queryEnd++;
    }

    int fragmentStart = queryEnd;
    int fragmentEnd = fragmentStart;
    if (url[fragmentStart] == '#') {
        fragmentStart++;
        fragmentEnd = fragmentStart;
        while (url[fragmentEnd])
            fragmentEnd++;
    }

    // assemble it all, remembering the real ranges

    Vector<char, 4096> buffer(fragmentEnd * 3 + 1);

    char *p = buffer.data();
    const char *strPtr = url;

    // copy in the scheme
    const char *schemeEndPtr = url + schemeEnd;
    while (strPtr < schemeEndPtr)
        *p++ = toASCIILower(*strPtr++);
    m_schemeEnd = p - buffer.data();

    bool hostIsLocalHost = portEnd - userStart == 9
        && isLetterMatchIgnoringCase(url[userStart], 'l')
        && isLetterMatchIgnoringCase(url[userStart+1], 'o')
        && isLetterMatchIgnoringCase(url[userStart+2], 'c')
        && isLetterMatchIgnoringCase(url[userStart+3], 'a')
        && isLetterMatchIgnoringCase(url[userStart+4], 'l')
        && isLetterMatchIgnoringCase(url[userStart+5], 'h')
        && isLetterMatchIgnoringCase(url[userStart+6], 'o')
        && isLetterMatchIgnoringCase(url[userStart+7], 's')
        && isLetterMatchIgnoringCase(url[userStart+8], 't');

    // File URLs need a host part unless it is just file:// or file://localhost
    bool degenerateFilePath = pathStart == pathEnd && (hostStart == hostEnd || hostIsLocalHost);

    // We drop empty credentials, but keep a colon in an empty host/port pair.
    // Removing hostname completely would change the structure of the URL on re-parsing.
    bool haveNonHostAuthorityPart = userStart != userEnd || passwordStart != passwordEnd || hostEnd != portEnd;

    // add ":" after scheme
    *p++ = ':';

    // if we have at least one authority part or a file URL - add "//" and authority
    if (isFile ? !degenerateFilePath : (haveNonHostAuthorityPart || hostStart != hostEnd)) {
        *p++ = '/';
        *p++ = '/';

        m_userStart = p - buffer.data();

        // copy in the user
        strPtr = url + userStart;
        const char* userEndPtr = url + userEnd;
        while (strPtr < userEndPtr) {
            char c = *strPtr++;
            ASSERT(isUserInfoChar(c));
            *p++ = c;
        }
        m_userEnd = p - buffer.data();

        // copy in the password
        if (passwordEnd != passwordStart) {
            *p++ = ':';
            strPtr = url + passwordStart;
            const char* passwordEndPtr = url + passwordEnd;
            while (strPtr < passwordEndPtr) {
                char c = *strPtr++;
                ASSERT(isUserInfoChar(c));
                *p++ = c;
            }
        }
        m_passwordEnd = p - buffer.data();

        // If we had any user info, add "@"
        if (p - buffer.data() != m_userStart)
            *p++ = '@';

        // copy in the host, except in the case of a file URL with authority="localhost"
        if (!(isFile && hostIsLocalHost && !haveNonHostAuthorityPart)) {
            strPtr = url + hostStart;
            const char* hostEndPtr = url + hostEnd;
            if (isCanonicalHostnameLowercaseForScheme(buffer.data(), m_schemeEnd)) {
                while (strPtr < hostEndPtr) {
                    char c = toASCIILower(*strPtr++);
                    ASSERT(isHostnameChar(c) || c == '[' || c == ']' || c == ':');
                    *p++ = c;
                }
            } else {
                while (strPtr < hostEndPtr) {
                    char c = *strPtr++;
                    ASSERT(isHostnameChar(c) || c == '[' || c == ']' || c == ':');
                    *p++ = c;
                }
            }
        }
        m_hostEnd = p - buffer.data();

        // Copy in the port if the URL has one (and it's not default). Also, copy it if there was no hostname, so that there is still something in authority component.
        if (hostEnd != portStart) {
            const char* portStr = url + portStart;
            size_t portLength = portEnd - portStart;
            if ((portLength && !isDefaultPortForScheme(portStr, portLength, buffer.data(), m_schemeEnd))
                || (hostStart == hostEnd && hostEnd != portStart)) {
                *p++ = ':';
                const char* portEndPtr = url + portEnd;
                while (portStr < portEndPtr)
                    *p++ = *portStr++;
            }
        }
        m_portEnd = p - buffer.data();
    } else {
        if (isFile) {
            ASSERT(degenerateFilePath);
            *p++ = '/';
            *p++ = '/';
        }
        m_userStart = m_userEnd = m_passwordEnd = m_hostEnd = m_portEnd = p - buffer.data();
    }

    // For canonicalization, ensure we have a '/' for no path.
    // Do this only for URL with protocol file, http or https.
    if ((m_protocolIsInHTTPFamily || isFile) && pathEnd == pathStart)
        *p++ = '/';

    // add path, escaping bad characters
    if (!hierarchical)
        escapeAndAppendNonHierarchicalPart(p, url + pathStart, pathEnd - pathStart);
    else if (!hasSlashDotOrDotDot(url))
        appendEscapingBadChars(p, url + pathStart, pathEnd - pathStart);
    else {
        CharBuffer pathBuffer(pathEnd - pathStart + 1);
        size_t length = copyPathRemovingDots(pathBuffer.data(), url, pathStart, pathEnd);
        appendEscapingBadChars(p, pathBuffer.data(), length);
    }

    m_pathEnd = p - buffer.data();

    // Find the position after the last slash in the path, or
    // the position before the path if there are no slashes in it.
    int i;
    for (i = m_pathEnd; i > m_portEnd; --i) {
        if (buffer[i - 1] == '/')
            break;
    }
    m_pathAfterLastSlash = i;

    // add query, escaping bad characters
    appendEscapingBadChars(p, url + queryStart, queryEnd - queryStart);
    m_queryEnd = p - buffer.data();

    // add fragment, escaping bad characters
    if (fragmentEnd != queryEnd) {
        *p++ = '#';
        escapeAndAppendNonHierarchicalPart(p, url + fragmentStart, fragmentEnd - fragmentStart);
    }
    m_fragmentEnd = p - buffer.data();

    ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
    ASSERT(buffer.size() > 0);

    // If we didn't end up actually changing the original string and
    // it was already in a String, reuse it to avoid extra allocation.
    if (originalString && equal(originalString->impl(), buffer.data(), m_fragmentEnd))
        m_string = *originalString;
    else
        m_string = String(buffer.data(), m_fragmentEnd);

    m_isValid = true;
}

bool equalIgnoringFragmentIdentifier(const KURL& a, const KURL& b)
{
    if (a.m_queryEnd != b.m_queryEnd)
        return false;
    unsigned queryLength = a.m_queryEnd;
    for (unsigned i = 0; i < queryLength; ++i)
        if (a.string()[i] != b.string()[i])
            return false;
    return true;
}

bool protocolHostAndPortAreEqual(const KURL& a, const KURL& b)
{
    if (a.m_schemeEnd != b.m_schemeEnd)
        return false;

    int hostStartA = a.hostStart();
    int hostLengthA = a.hostEnd() - hostStartA;
    int hostStartB = b.hostStart();
    int hostLengthB = b.hostEnd() - b.hostStart();
    if (hostLengthA != hostLengthB)
        return false;

    // Check the scheme
    for (int i = 0; i < a.m_schemeEnd; ++i)
        if (a.string()[i] != b.string()[i])
            return false;

    // And the host
    for (int i = 0; i < hostLengthA; ++i)
        if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
            return false;

    if (a.port() != b.port())
        return false;

    return true;
}

String encodeWithURLEscapeSequences(const String& notEncodedString)
{
    CString asUTF8 = notEncodedString.utf8();

    CharBuffer buffer(asUTF8.length() * 3 + 1);
    char* p = buffer.data();

    const char* str = asUTF8.data();
    const char* strEnd = str + asUTF8.length();
    while (str < strEnd) {
        unsigned char c = *str++;
        if (isBadChar(c))
            appendEscapedChar(p, c);
        else
            *p++ = c;
    }

    ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));

    return String(buffer.data(), p - buffer.data());
}

// Appends the punycoded hostname identified by the given string and length to
// the output buffer. The result will not be null terminated.
static void appendEncodedHostname(UCharBuffer& buffer, const UChar* str, unsigned strLen)
{
    // Needs to be big enough to hold an IDN-encoded name.
    // For host names bigger than this, we won't do IDN encoding, which is almost certainly OK.
    const unsigned hostnameBufferLength = 2048;

    if (strLen > hostnameBufferLength || charactersAreAllASCII(str, strLen)) {
        buffer.append(str, strLen);
        return;
    }

#if USE(ICU_UNICODE)
    UChar hostnameBuffer[hostnameBufferLength];
    UErrorCode error = U_ZERO_ERROR;
    int32_t numCharactersConverted = uidna_IDNToASCII(str, strLen, hostnameBuffer,
        hostnameBufferLength, UIDNA_ALLOW_UNASSIGNED, 0, &error);
    if (error == U_ZERO_ERROR)
        buffer.append(hostnameBuffer, numCharactersConverted);
#endif
}

static void findHostnamesInMailToURL(const UChar* str, int strLen, Vector<pair<int, int> >& nameRanges)
{
    // In a mailto: URL, host names come after a '@' character and end with a '>' or ',' or '?' or end of string character.
    // Skip quoted strings so that characters in them don't confuse us.
    // When we find a '?' character, we are past the part of the URL that contains host names.

    nameRanges.clear();

    int p = 0;
    while (1) {
        // Find start of host name or of quoted string.
        int hostnameOrStringStart = findFirstOf(str, strLen, p, "\"@?");
        if (hostnameOrStringStart == -1)
            return;
        UChar c = str[hostnameOrStringStart];
        p = hostnameOrStringStart + 1;

        if (c == '?')
            return;

        if (c == '@') {
            // Find end of host name.
            int hostnameStart = p;
            int hostnameEnd = findFirstOf(str, strLen, p, ">,?");
            bool done;
            if (hostnameEnd == -1) {
                hostnameEnd = strLen;
                done = true;
            } else {
                p = hostnameEnd;
                done = false;
            }

            nameRanges.append(make_pair(hostnameStart, hostnameEnd));

            if (done)
                return;
        } else {
            // Skip quoted string.
            ASSERT(c == '"');
            while (1) {
                int escapedCharacterOrStringEnd = findFirstOf(str, strLen, p, "\"\\");
                if (escapedCharacterOrStringEnd == -1)
                    return;

                c = str[escapedCharacterOrStringEnd];
                p = escapedCharacterOrStringEnd + 1;

                // If we are the end of the string, then break from the string loop back to the host name loop.
                if (c == '"')
                    break;

                // Skip escaped character.
                ASSERT(c == '\\');
                if (p == strLen)
                    return;

                ++p;
            }
        }
    }
}

static bool findHostnameInHierarchicalURL(const UChar* str, int strLen, int& startOffset, int& endOffset)
{
    // Find the host name in a hierarchical URL.
    // It comes after a "://" sequence, with scheme characters preceding, and
    // this should be the first colon in the string.
    // It ends with the end of the string or a ":" or a path segment ending character.
    // If there is a "@" character, the host part is just the part after the "@".
    int separator = findFirstOf(str, strLen, 0, ":");
    if (separator == -1 || separator + 2 >= strLen ||
        str[separator + 1] != '/' || str[separator + 2] != '/')
        return false;

    // Check that all characters before the :// are valid scheme characters.
    if (!isSchemeFirstChar(str[0]))
        return false;
    for (int i = 1; i < separator; ++i) {
        if (!isSchemeChar(str[i]))
            return false;
    }

    // Start after the separator.
    int authorityStart = separator + 3;

    // Find terminating character.
    int hostnameEnd = strLen;
    for (int i = authorityStart; i < strLen; ++i) {
        UChar c = str[i];
        if (c == ':' || (isPathSegmentEndChar(c) && c != 0)) {
            hostnameEnd = i;
            break;
        }
    }

    // Find "@" for the start of the host name.
    int userInfoTerminator = findFirstOf(str, strLen, authorityStart, "@");
    int hostnameStart;
    if (userInfoTerminator == -1 || userInfoTerminator > hostnameEnd)
        hostnameStart = authorityStart;
    else
        hostnameStart = userInfoTerminator + 1;

    startOffset = hostnameStart;
    endOffset = hostnameEnd;
    return true;
}

// Converts all hostnames found in the given input to punycode, preserving the
// rest of the URL unchanged. The output will NOT be null-terminated.
static void encodeHostnames(const String& str, UCharBuffer& output)
{
    output.clear();

    if (protocolIs(str, "mailto")) {
        Vector<pair<int, int> > hostnameRanges;
        findHostnamesInMailToURL(str.characters(), str.length(), hostnameRanges);
        int n = hostnameRanges.size();
        int p = 0;
        for (int i = 0; i < n; ++i) {
            const pair<int, int>& r = hostnameRanges[i];
            output.append(&str.characters()[p], r.first - p);
            appendEncodedHostname(output, &str.characters()[r.first], r.second - r.first);
            p = r.second;
        }
        // This will copy either everything after the last hostname, or the
        // whole thing if there is no hostname.
        output.append(&str.characters()[p], str.length() - p);
    } else {
        int hostStart, hostEnd;
        if (findHostnameInHierarchicalURL(str.characters(), str.length(), hostStart, hostEnd)) {
            output.append(str.characters(), hostStart); // Before hostname.
            appendEncodedHostname(output, &str.characters()[hostStart], hostEnd - hostStart);
            output.append(&str.characters()[hostEnd], str.length() - hostEnd); // After hostname.
        } else {
            // No hostname to encode, return the input.
            output.append(str.characters(), str.length());
        }
    }
}

static void encodeRelativeString(const String& rel, const TextEncoding& encoding, CharBuffer& output)
{
    UCharBuffer s;
    encodeHostnames(rel, s);

    TextEncoding pathEncoding(UTF8Encoding()); // Path is always encoded as UTF-8; other parts may depend on the scheme.

    int pathEnd = -1;
    if (encoding != pathEncoding && encoding.isValid() && !protocolIs(rel, "mailto") && !protocolIs(rel, "data") && !protocolIsJavaScript(rel)) {
        // Find the first instance of either # or ?, keep pathEnd at -1 otherwise.
        pathEnd = findFirstOf(s.data(), s.size(), 0, "#?");
    }

    if (pathEnd == -1) {
        CString decoded = pathEncoding.encode(s.data(), s.size(), URLEncodedEntitiesForUnencodables);
        output.resize(decoded.length());
        memcpy(output.data(), decoded.data(), decoded.length());
    } else {
        CString pathDecoded = pathEncoding.encode(s.data(), pathEnd, URLEncodedEntitiesForUnencodables);
        // Unencodable characters in URLs are represented by converting
        // them to XML entities and escaping non-alphanumeric characters.
        CString otherDecoded = encoding.encode(s.data() + pathEnd, s.size() - pathEnd, URLEncodedEntitiesForUnencodables);

        output.resize(pathDecoded.length() + otherDecoded.length());
        memcpy(output.data(), pathDecoded.data(), pathDecoded.length());
        memcpy(output.data() + pathDecoded.length(), otherDecoded.data(), otherDecoded.length());
    }
    output.append('\0'); // null-terminate the output.
}

static String substituteBackslashes(const String& string)
{
    size_t questionPos = string.find('?');
    size_t hashPos = string.find('#');
    unsigned pathEnd;

    if (hashPos != notFound && (questionPos == notFound || questionPos > hashPos))
        pathEnd = hashPos;
    else if (questionPos != notFound)
        pathEnd = questionPos;
    else
        pathEnd = string.length();

    return string.left(pathEnd).replace('\\','/') + string.substring(pathEnd);
}

bool KURL::isHierarchical() const
{
    if (!m_isValid)
        return false;
    ASSERT(m_string[m_schemeEnd] == ':');
    return m_string[m_schemeEnd + 1] == '/';
}

void KURL::copyToBuffer(Vector<char, 512>& buffer) const
{
    // FIXME: This throws away the high bytes of all the characters in the string!
    // That's fine for a valid URL, which is all ASCII, but not for invalid URLs.
    buffer.resize(m_string.length());
    copyASCII(m_string, buffer.data());
}

bool protocolIs(const String& url, const char* protocol)
{
    // Do the comparison without making a new string object.
    assertProtocolIsGood(protocol);
    for (int i = 0; ; ++i) {
        if (!protocol[i])
            return url[i] == ':';
        if (!isLetterMatchIgnoringCase(url[i], protocol[i]))
            return false;
    }
}

bool isValidProtocol(const String& protocol)
{
    // RFC3986: ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
    if (protocol.isEmpty())
        return false;
    if (!isSchemeFirstChar(protocol[0]))
        return false;
    unsigned protocolLength = protocol.length();
    for (unsigned i = 1; i < protocolLength; i++) {
        if (!isSchemeChar(protocol[i]))
            return false;
    }
    return true;
}

#ifndef NDEBUG
void KURL::print() const
{
    printf("%s\n", m_string.utf8().data());
}
#endif

String KURL::strippedForUseAsReferrer() const
{
    KURL referrer(*this);
    referrer.setUser(String());
    referrer.setPass(String());
    referrer.removeFragmentIdentifier();
    return referrer.string();
}

bool KURL::isLocalFile() const
{
    // Including feed here might be a bad idea since drag and drop uses this check
    // and including feed would allow feeds to potentially let someone's blog
    // read the contents of the clipboard on a drag, even without a drop.
    // Likewise with using the FrameLoader::shouldTreatURLAsLocal() function.
    return protocolIs("file");
}

bool protocolIsJavaScript(const String& url)
{
    return protocolIs(url, "javascript");
}

const KURL& blankURL()
{
    DEFINE_STATIC_LOCAL(KURL, staticBlankURL, (ParsedURLString, "about:blank"));
    return staticBlankURL;
}

bool KURL::isBlankURL() const
{
    return protocolIs("about");
}

bool isDefaultPortForProtocol(unsigned short port, const String& protocol)
{
    if (protocol.isEmpty())
        return false;

    typedef HashMap<String, unsigned, CaseFoldingHash> DefaultPortsMap;
    DEFINE_STATIC_LOCAL(DefaultPortsMap, defaultPorts, ());
    if (defaultPorts.isEmpty()) {
        defaultPorts.set("http", 80);
        defaultPorts.set("https", 443);
        defaultPorts.set("ftp", 21);
        defaultPorts.set("ftps", 990);
    }
    return defaultPorts.get(protocol) == port;
}

bool portAllowed(const KURL& url)
{
    unsigned short port = url.port();

    // Since most URLs don't have a port, return early for the "no port" case.
    if (!port)
        return true;

    // This blocked port list matches the port blocking that Mozilla implements.
    // See http://www.mozilla.org/projects/netlib/PortBanning.html for more information.
    static const unsigned short blockedPortList[] = {
        1,    // tcpmux
        7,    // echo
        9,    // discard
        11,   // systat
        13,   // daytime
        15,   // netstat
        17,   // qotd
        19,   // chargen
        20,   // FTP-data
        21,   // FTP-control
        22,   // SSH
        23,   // telnet
        25,   // SMTP
        37,   // time
        42,   // name
        43,   // nicname
        53,   // domain
        77,   // priv-rjs
        79,   // finger
        87,   // ttylink
        95,   // supdup
        101,  // hostriame
        102,  // iso-tsap
        103,  // gppitnp
        104,  // acr-nema
        109,  // POP2
        110,  // POP3
        111,  // sunrpc
        113,  // auth
        115,  // SFTP
        117,  // uucp-path
        119,  // nntp
        123,  // NTP
        135,  // loc-srv / epmap
        139,  // netbios
        143,  // IMAP2
        179,  // BGP
        389,  // LDAP
        465,  // SMTP+SSL
        512,  // print / exec
        513,  // login
        514,  // shell
        515,  // printer
        526,  // tempo
        530,  // courier
        531,  // Chat
        532,  // netnews
        540,  // UUCP
        556,  // remotefs
        563,  // NNTP+SSL
        587,  // ESMTP
        601,  // syslog-conn
        636,  // LDAP+SSL
        993,  // IMAP+SSL
        995,  // POP3+SSL
        2049, // NFS
        3659, // apple-sasl / PasswordServer [Apple addition]
        4045, // lockd
        6000, // X11
        6665, // Alternate IRC [Apple addition]
        6666, // Alternate IRC [Apple addition]
        6667, // Standard IRC [Apple addition]
        6668, // Alternate IRC [Apple addition]
        6669, // Alternate IRC [Apple addition]
        invalidPortNumber, // Used to block all invalid port numbers
    };
    const unsigned short* const blockedPortListEnd = blockedPortList + WTF_ARRAY_LENGTH(blockedPortList);

#ifndef NDEBUG
    // The port list must be sorted for binary_search to work.
    static bool checkedPortList = false;
    if (!checkedPortList) {
        for (const unsigned short* p = blockedPortList; p != blockedPortListEnd - 1; ++p)
            ASSERT(*p < *(p + 1));
        checkedPortList = true;
    }
#endif

    // If the port is not in the blocked port list, allow it.
    if (!binary_search(blockedPortList, blockedPortListEnd, port))
        return true;

    // Allow ports 21 and 22 for FTP URLs, as Mozilla does.
    if ((port == 21 || port == 22) && url.protocolIs("ftp"))
        return true;

    // Allow any port number in a file URL, since the port number is ignored.
    if (url.protocolIs("file"))
        return true;

#if PLATFORM(BLACKBERRY)
    if (url.protocolIs("local"))
        return true;
#endif

    return false;
}

String mimeTypeFromDataURL(const String& url)
{
    ASSERT(protocolIs(url, "data"));
    size_t index = url.find(';');
    if (index == notFound)
        index = url.find(',');
    if (index != notFound) {
        if (index > 5)
            return url.substring(5, index - 5).lower();
        return "text/plain"; // Data URLs with no MIME type are considered text/plain.
    }
    return "";
}

String mimeTypeFromURL(const KURL& url)
{
    String decodedPath = decodeURLEscapeSequences(url.path());
    String extension = decodedPath.substring(decodedPath.reverseFind('.') + 1);

    // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
    return MIMETypeRegistry::getMIMETypeForExtension(extension);
}

bool KURL::isSafeToSendToAnotherThread() const
{
    return m_string.isSafeToSendToAnotherThread();
}

String KURL::stringCenterEllipsizedToLength(unsigned length) const
{
    if (string().length() <= length)
        return string();

    return string().left(length / 2 - 1) + "..." + string().right(length / 2 - 2);
}

}



/*
 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2011, 2012, 2013 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef KURL_h
#define KURL_h

#include <wtf/Forward.h>
#include <wtf/HashMap.h>
#include <wtf/RetainPtr.h>
#include <wtf/text/WTFString.h>

#if USE(CF)
typedef const struct __CFURL* CFURLRef;
#endif

#if PLATFORM(MAC)
OBJC_CLASS NSURL;
#endif

#if PLATFORM(QT)
QT_BEGIN_NAMESPACE
class QUrl;
QT_END_NAMESPACE
#endif

namespace WebCore {

class TextEncoding;
struct KURLHash;

enum ParsedURLStringTag { ParsedURLString };

class KURL {
public:
    // Generates a URL which contains a null string.
    KURL() { invalidate(); }

    // The argument is an absolute URL string. The string is assumed to be output of KURL::string() called on a valid
    // KURL object, or indiscernible from such.
    // It is usually best to avoid repeatedly parsing a string, unless memory saving outweigh the possible slow-downs.
    KURL(ParsedURLStringTag, const String&);
    explicit KURL(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { }
    bool isHashTableDeletedValue() const { return string().isHashTableDeletedValue(); }

    // Resolves the relative URL with the given base URL. If provided, the
    // TextEncoding is used to encode non-ASCII characers. The base URL can be
    // null or empty, in which case the relative URL will be interpreted as
    // absolute.
    // FIXME: If the base URL is invalid, this always creates an invalid
    // URL. Instead I think it would be better to treat all invalid base URLs
    // the same way we treate null and empty base URLs.
    KURL(const KURL& base, const String& relative);
    KURL(const KURL& base, const String& relative, const TextEncoding&);

    String strippedForUseAsReferrer() const;

    // FIXME: The above functions should be harmonized so that passing a
    // base of null or the empty string gives the same result as the
    // standard String constructor.

    // Makes a deep copy. Helpful only if you need to use a KURL on another
    // thread.  Since the underlying StringImpl objects are immutable, there's
    // no other reason to ever prefer copy() over plain old assignment.
    KURL copy() const;

    bool isNull() const;
    bool isEmpty() const;
    bool isValid() const;

    // Returns true if you can set the host and port for the URL.
    // Non-hierarchical URLs don't have a host and port.
    bool canSetHostOrPort() const { return isHierarchical(); }

    bool canSetPathname() const { return isHierarchical(); }
    bool isHierarchical() const;

    const String& string() const { return m_string; }

    String stringCenterEllipsizedToLength(unsigned length = 1024) const;

    String protocol() const;
    String host() const;
    unsigned short port() const;
    bool hasPort() const;
    String user() const;
    String pass() const;
    String path() const;
    String lastPathComponent() const;
    String query() const;
    String fragmentIdentifier() const;
    bool hasFragmentIdentifier() const;

    String baseAsString() const;

    String fileSystemPath() const;

    // Returns true if the current URL's protocol is the same as the null-
    // terminated ASCII argument. The argument must be lower-case.
    bool protocolIs(const char*) const;
    bool protocolIsData() const { return protocolIs("data"); }
    bool protocolIsInHTTPFamily() const;
    bool isLocalFile() const;
    bool isBlankURL() const;

    bool setProtocol(const String&);
    void setHost(const String&);

    void removePort();
    void setPort(unsigned short);

    // Input is like "foo.com" or "foo.com:8000".
    void setHostAndPort(const String&);

    void setUser(const String&);
    void setPass(const String&);

    // If you pass an empty path for HTTP or HTTPS URLs, the resulting path
    // will be "/".
    void setPath(const String&);

    // The query may begin with a question mark, or, if not, one will be added
    // for you. Setting the query to the empty string will leave a "?" in the
    // URL (with nothing after it). To clear the query, pass a null string.
    void setQuery(const String&);

    void setFragmentIdentifier(const String&);
    void removeFragmentIdentifier();

    friend bool equalIgnoringFragmentIdentifier(const KURL&, const KURL&);

    friend bool protocolHostAndPortAreEqual(const KURL&, const KURL&);

    unsigned hostStart() const;
    unsigned hostEnd() const;

    unsigned pathStart() const;
    unsigned pathEnd() const;
    unsigned pathAfterLastSlash() const;

    operator const String&() const { return string(); }

#if USE(CF)
    KURL(CFURLRef);
    RetainPtr<CFURLRef> createCFURL() const;
#endif

#if PLATFORM(MAC)
    KURL(NSURL*);
    operator NSURL*() const;
#endif
#ifdef __OBJC__
    operator NSString*() const { return string(); }
#endif

#if PLATFORM(QT)
    KURL(const QUrl&);
    operator QUrl() const;
#endif

    const KURL* innerURL() const { return 0; }

#ifndef NDEBUG
    void print() const;
#endif

    bool isSafeToSendToAnotherThread() const;

private:
    void invalidate();
    static bool protocolIs(const String&, const char*);
    void init(const KURL&, const String&, const TextEncoding&);
    void copyToBuffer(Vector<char, 512>& buffer) const;

    // Parses the given URL. The originalString parameter allows for an
    // optimization: When the source is the same as the fixed-up string,
    // it will use the passed-in string instead of allocating a new one.
    void parse(const String&);
    void parse(const char* url, const String* originalString = 0);

    bool hasPath() const;

    String m_string;
    bool m_isValid : 1;
    bool m_protocolIsInHTTPFamily : 1;

    int m_schemeEnd;
    int m_userStart;
    int m_userEnd;
    int m_passwordEnd;
    int m_hostEnd;
    int m_portEnd;
    int m_pathAfterLastSlash;
    int m_pathEnd;
    int m_queryEnd;
    int m_fragmentEnd;
};

bool operator==(const KURL&, const KURL&);
bool operator==(const KURL&, const String&);
bool operator==(const String&, const KURL&);
bool operator!=(const KURL&, const KURL&);
bool operator!=(const KURL&, const String&);
bool operator!=(const String&, const KURL&);

bool equalIgnoringFragmentIdentifier(const KURL&, const KURL&);
bool protocolHostAndPortAreEqual(const KURL&, const KURL&);

const KURL& blankURL();

// Functions to do URL operations on strings.
// These are operations that aren't faster on a parsed URL.
// These are also different from the KURL functions in that they don't require the string to be a valid and parsable URL.
// This is especially important because valid javascript URLs are not necessarily considered valid by KURL.

bool protocolIs(const String& url, const char* protocol);
bool protocolIsJavaScript(const String& url);

bool isDefaultPortForProtocol(unsigned short port, const String& protocol);
bool portAllowed(const KURL&); // Blacklist ports that should never be used for Web resources.

bool isValidProtocol(const String&);

String mimeTypeFromDataURL(const String& url);
String mimeTypeFromURL(const KURL&);

// Unescapes the given string using URL escaping rules, given an optional
// encoding (defaulting to UTF-8 otherwise). DANGER: If the URL has "%00"
// in it, the resulting string will have embedded null characters!
String decodeURLEscapeSequences(const String&);
String decodeURLEscapeSequences(const String&, const TextEncoding&);

String encodeWithURLEscapeSequences(const String&);

// Inlines.

inline bool operator==(const KURL& a, const KURL& b)
{
    return a.string() == b.string();
}

inline bool operator==(const KURL& a, const String& b)
{
    return a.string() == b;
}

inline bool operator==(const String& a, const KURL& b)
{
    return a == b.string();
}

inline bool operator!=(const KURL& a, const KURL& b)
{
    return a.string() != b.string();
}

inline bool operator!=(const KURL& a, const String& b)
{
    return a.string() != b;
}

inline bool operator!=(const String& a, const KURL& b)
{
    return a != b.string();
}

// Inline versions of some non-GoogleURL functions so we can get inlining
// without having to have a lot of ugly ifdefs in the class definition.

inline bool KURL::isNull() const
{
    return m_string.isNull();
}

inline bool KURL::isEmpty() const
{
    return m_string.isEmpty();
}

inline bool KURL::isValid() const
{
    return m_isValid;
}

inline bool KURL::hasPath() const
{
    return m_pathEnd != m_portEnd;
}

inline bool KURL::hasPort() const
{
    return m_hostEnd < m_portEnd;
}

inline bool KURL::protocolIsInHTTPFamily() const
{
    return m_protocolIsInHTTPFamily;
}

inline unsigned KURL::hostStart() const
{
    return (m_passwordEnd == m_userStart) ? m_passwordEnd : m_passwordEnd + 1;
}

inline unsigned KURL::hostEnd() const
{
    return m_hostEnd;
}

inline unsigned KURL::pathStart() const
{
    return m_portEnd;
}

inline unsigned KURL::pathEnd() const
{
    return m_pathEnd;
}

inline unsigned KURL::pathAfterLastSlash() const
{
    return m_pathAfterLastSlash;
}

} // namespace WebCore

namespace WTF {

    // KURLHash is the default hash for String
    template<typename T> struct DefaultHash;
    template<> struct DefaultHash<WebCore::KURL> {
        typedef WebCore::KURLHash Hash;
    };

} // namespace WTF

#endif // KURL_h



/*
 * Copyright (C) 2008 Apple Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef KURLHash_h
#define KURLHash_h

#include "KURL.h"
#include <wtf/text/StringHash.h>
#include <wtf/text/WTFString.h>

namespace WebCore {

    struct KURLHash {
        static unsigned hash(const KURL& key)
        {
            return key.string().impl()->hash();
        }

        static bool equal(const KURL& a, const KURL& b)
        {
            return StringHash::equal(a.string(), b.string());
        }

        static const bool safeToCompareToEmptyOrDeleted = false;
    };

} // namespace WebCore

namespace WTF {

    template<> struct HashTraits<WebCore::KURL> : SimpleClassHashTraits<WebCore::KURL> { };

} // namespace WTF

#endif // KURLHash_h



 */

#include "config.h"
#include "URL.h"
#include "LinkHash.h"
#include <wtf/text/AtomicString.h>
#include <wtf/text/StringHash.h>

}

template <typename CharacterType>
static ALWAYS_INLINE void visitedURLInline(const URL& base, const CharacterType* characters, unsigned length, Vector<CharacterType, 512>& buffer)
{
    if (!length)
        return;

    // This is a poor man's completeURL. Faster with less memory allocation.
    // FIXME: It's missing a lot of what completeURL does and a lot of what URL does.
    // For example, it does not handle international domain names properly.

    // FIXME: It is wrong that we do not do further processing on strings that have "://" in them:

    return;
}

void visitedURL(const URL& base, const AtomicString& attributeURL, Vector<UChar, 512>& buffer)
{
    return visitedURLInline(base, attributeURL.characters(), attributeURL.length(), buffer);
}

LinkHash visitedLinkHash(const URL& base, const AtomicString& attributeURL)
{
    if (attributeURL.isEmpty())
        return 0;




namespace WebCore {

class URL;

typedef uint64_t LinkHash;


// base URL, and returns the hash of the string that will be used for visited
// link coloring. It will return the special value of 0 if attributeURL does not
// look like a relative URL.
LinkHash visitedLinkHash(const URL& base, const AtomicString& attributeURL);

// Resolves the potentially relative URL "attributeURL" relative to the given
// base URL, and returns the hash of the string that will be used for visited.
// It will return an empty Vector in case of errors.
void visitedURL(const URL& base, const AtomicString& attributeURL, Vector<UChar, 512>&);


}  // namespace WebCore




#include "DragImage.h"
#include "Image.h"
#include "URL.h"
#include "SharedBuffer.h"
#include <wtf/Noncopyable.h>
#include <wtf/Vector.h>

};

struct PasteboardURL {
    URL url;
    String title;
#if PLATFORM(MAC) && !PLATFORM(IOS)
    String userVisibleForm;

    virtual bool readRTFD(PassRefPtr<SharedBuffer>) = 0;
    virtual bool readRTF(PassRefPtr<SharedBuffer>) = 0;
    virtual bool readImage(PassRefPtr<SharedBuffer>, const String& type) = 0;
    virtual bool readURL(const URL&, const String& title) = 0;
#endif
    virtual bool readPlainText(const String&) = 0;
};

#endif

#if PLATFORM(GTK) || PLATFORM(QT) || PLATFORM(WIN)
    void writeImage(Node*, const URL&, const String& title); // FIXME: Layering violation.
    void writeSelection(Range*, bool canSmartCopyOrDelete, Frame*, ShouldSerializeSelectedTextForClipboard = DefaultSelectedTextType); // FIXME: Layering violation.
#endif


#if PLATFORM(WIN)
    COMPtr<IDataObject> dataObject() const { return m_dataObject; }
    void setExternalDataObject(IDataObject*);
    void writeURLToWritableDataObject(const URL&, const String&);
    COMPtr<WCDataObject> writableDataObject() const { return m_writableDataObject; }
    void writeImageToDataObject(Element*, const URL&); // FIXME: Layering violation.
#endif

private:


    void finishCreatingPasteboard();
    void writeRangeToDataObject(Range*, Frame*); // FIXME: Layering violation.
    void writeURLToDataObject(const URL&, const String&);
    void writePlainTextToDataObject(const String&, SmartReplaceOption);
#endif




namespace WebCore {

class Color;
class URL;
    
class PasteboardStrategy {
public:

    virtual long changeCount(const String& pasteboardName) = 0;
    virtual String uniqueName() = 0;
    virtual Color color(const String& pasteboardName) = 0;
    virtual URL url(const String& pasteboardName) = 0;
    
    virtual long addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) = 0;
    virtual long setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) = 0;



namespace WebCore {

class Color;
class URL;

class PlatformPasteboard {
public:

    String stringForType(const String& pasteboardType);
    long changeCount() const;
    Color color();
    URL url();

    // Take ownership of the pasteboard, and return new change count.
    long addTypes(const Vector<String>& pasteboardTypes);




namespace WebCore {

    class URL;

    // Returns strings representing key sizes that may be used
    // for the <keygen> tag. The first string is displayed as the default

    // This function handles the <keygen> tag in form elements.
    // Returns a signed copy of the combined challenge string and public
    // key (from a newly generated key pair).
    String signedPublicKeyAndChallengeString(unsigned keySizeIndex, const String& challengeString, const URL&);

} // namespace WebCore





typedef uint64_t LinkHash;
class Page;
class URL;

class VisitedLinkStrategy {
public:
    virtual bool isLinkVisited(Page*, LinkHash, const URL& baseURL, const AtomicString& attributeURL) = 0;
    virtual void addVisitedLink(Page*, LinkHash) = 0;

protected:



#include "AsyncFileWriterClient.h"
#include "DOMFileSystemBase.h"
#include "ExceptionCode.h"
#include "KURL.h"
#include "NotImplemented.h"
#include "PlatformAsyncFileSystemCallbacks.h"
#include "ScriptExecutionContext.h"
#include "SecurityOrigin.h"
#include "URL.h"

#include <wtf/text/CString.h>
#include <wtf/text/StringBuilder.h>

    ASSERT_NOT_REACHED();
}

void AsyncFileSystemBlackBerry::openFileSystem(const URL& rootURL, const String& basePath, const String& storageIdentifier, FileSystemType type, long long size, bool create, int playerId, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    BlackBerry::Platform::WebFileSystem::openFileSystem(BlackBerry::Platform::webKitThreadMessageClient(), basePath, storageIdentifier, static_cast<BlackBerry::Platform::WebFileSystem::Type>(type), size, create, new PlatformAsyncFileSystemCallbacks(callbacks, rootURL), playerId);
}

{
}

void AsyncFileSystemBlackBerry::move(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->move(fileSystemURLToPath(sourcePath), fileSystemURLToPath(destinationPath), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::copy(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->copy(fileSystemURLToPath(sourcePath), fileSystemURLToPath(destinationPath), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::remove(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->remove(fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::removeRecursively(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->removeRecursively(fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::readMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->readMetadata(fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::createFile(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->createFile(fileSystemURLToPath(path), exclusive, new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::createDirectory(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->createDirectory(fileSystemURLToPath(path), exclusive, new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::fileExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->fileExists(fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::directoryExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->directoryExists(fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::readDirectory(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->readDirectory(fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks));
}

void AsyncFileSystemBlackBerry::createWriter(AsyncFileWriterClient* client, const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    BlackBerry::Platform::WebFileWriter::createWriter(m_platformFileSystem.get(), fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks, client));
}

void AsyncFileSystemBlackBerry::createSnapshotFileAndReadMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    m_platformFileSystem->createSnapshotFileAndReadMetadata(fileSystemURLToPath(path), new PlatformAsyncFileSystemCallbacks(callbacks));
}

String AsyncFileSystemBlackBerry::fileSystemURLToPath(const URL& url)
{
    FileSystemType type;
    String fullPath;



#if ENABLE(FILE_SYSTEM)
#include "AsyncFileSystem.h"
#include "FileSystemType.h"
#include "URL.h"

#include <BlackBerryPlatformWebFileSystem.h>
#include <wtf/OwnPtr.h>

        return adoptPtr(new AsyncFileSystemBlackBerry(platformFileSystem));
    }

    static void openFileSystem(const URL& rootURL, const String& basePath, const String& storageIdentifier, FileSystemType, long long size, bool create, int playerId, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual ~AsyncFileSystemBlackBerry();
    virtual void move(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void copy(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void remove(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void removeRecursively(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createFile(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createDirectory(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void fileExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void directoryExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readDirectory(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createWriter(AsyncFileWriterClient*, const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createSnapshotFileAndReadMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);

protected:
    AsyncFileSystemBlackBerry(PassOwnPtr<BlackBerry::Platform::WebFileSystem> platformFileSystem);
    static String fileSystemURLToPath(const URL&);

    OwnPtr<BlackBerry::Platform::WebFileSystem> m_platformFileSystem;
};



#include "AuthenticationChallengeManager.h"

#include "Credential.h"
#include "URL.h"
#include "PageClientBlackBerry.h"
#include "ProtectionSpace.h"


typedef HashMap<PageClientBlackBerry*, bool> PageVisibilityMap;

struct ChallengeInfo {
    ChallengeInfo(const URL&, const ProtectionSpace&, const Credential&, AuthenticationChallengeClient*, PageClientBlackBerry*);

    URL url;
    ProtectionSpace space;
    Credential credential;
    AuthenticationChallengeClient* authClient;

    bool blocked;
};

ChallengeInfo::ChallengeInfo(const URL& aUrl, const ProtectionSpace& aSpace, const Credential& aCredential,
    AuthenticationChallengeClient* anAuthClient, PageClientBlackBerry* aPageClient)
    : url(aUrl)
    , space(aSpace)

    d->resumeAuthenticationChallenge(client);
}

void AuthenticationChallengeManager::authenticationChallenge(const URL& url, const ProtectionSpace& space,
    const Credential& credential, AuthenticationChallengeClient* authClient, PageClientBlackBerry* pageClient)
{
    BLACKBERRY_ASSERT(authClient);

        d->startAuthenticationChallenge(next);
}

void AuthenticationChallengeManager::notifyChallengeResult(const URL&, const ProtectionSpace& space,
    AuthenticationChallengeResult result, const Credential& credential)
{
    d->m_activeChallenge = 0;




class AuthenticationChallengeManagerPrivate;
class Credential;
class URL;
class ProtectionSpace;

enum AuthenticationChallengeResult {


class AuthenticationChallengeClient {
public:
    virtual void notifyChallengeResult(const URL&, const ProtectionSpace&, AuthenticationChallengeResult, const Credential&) = 0;
};

class AuthenticationChallengeManager : public BlackBerry::Platform::ThreadUnsafeSingleton<AuthenticationChallengeManager> {

    void pageDeleted(PageClientBlackBerry*);
    void pageVisibilityChanged(PageClientBlackBerry*, bool visible);

    void authenticationChallenge(const URL&, const ProtectionSpace&, const Credential&, AuthenticationChallengeClient*, PageClientBlackBerry*);
    void cancelAuthenticationChallenge(AuthenticationChallengeClient*);
    void notifyChallengeResult(const URL&, const ProtectionSpace&, AuthenticationChallengeResult, const Credential&);

private:
    AuthenticationChallengeManager();



    return protocol == "file" || protocol == "local";
}

void CookieManager::setCookies(const URL& url, const String& value, CookieFilter filter)
{
    // If the database hasn't been sync-ed at this point, force a sync load
    if (!m_syncedWithDatabase && !m_privateMode)

    }
}

void CookieManager::setCookies(const URL& url, const Vector<String>& cookies, CookieFilter filter)
{
    // If the database hasn't been sync-ed at this point, force a sync load
    if (!m_syncedWithDatabase && !m_privateMode)

    }
}

String CookieManager::getCookie(const URL& url, CookieFilter filter) const
{
    // If the database hasn't been sync-ed at this point, force a sync load
    if (!m_syncedWithDatabase && !m_privateMode)

    return result;
}

void CookieManager::getRawCookies(Vector<RefPtr<ParsedCookie> > &stackOfCookies, const URL& requestURL, CookieFilter filter) const
{
    // Force a sync load of the database
    if (!m_syncedWithDatabase && !m_privateMode)

    return curMap;
}

void CookieManager::removeCookieWithName(const URL& url, const String& cookieName)
{
    // Dispatch the message because the database cookies are not loaded in memory yet.
    if (!m_syncedWithDatabase && !m_privateMode) {
        typedef void (WebCore::CookieManager::*FunctionType)(const URL&, const String&);
        BlackBerry::Platform::webKitThreadMessageClient()->dispatchMessage(
            BlackBerry::Platform::createMethodCallMessage<FunctionType, CookieManager, const URL, const String>(
                &CookieManager::removeCookieWithName, this, url, cookieName));
        return;
    }



namespace WebCore {

class CookieDatabaseBackingStore;
class URL;

enum BackingStoreRemovalPolicy {
    RemoveFromBackingStore,

    bool canLocalAccessAllCookies() const { return m_shouldDumpAllCookies; }
    void setCanLocalAccessAllCookies(bool enabled) { m_shouldDumpAllCookies = enabled; }

    void setCookies(const URL&, const String& value, CookieFilter = WithHttpOnlyCookies);
    void setCookies(const URL&, const Vector<String>& cookies, CookieFilter);

    void removeAllCookies(BackingStoreRemovalPolicy);
    void removeCookieWithName(const URL&, const String& cookieName);

    unsigned short cookiesCount() const { return m_count; }


    void setPrivateMode(bool);

    String generateHtmlFragmentForCookies();
    String getCookie(const URL& requestURL, CookieFilter) const;

    // Returns all cookies that are associated with the specified URL as raw cookies.
    void getRawCookies(Vector<RefPtr<ParsedCookie> >& stackOfCookies, const URL& requestURL, CookieFilter = WithHttpOnlyCookies) const;

private:
    friend CookieManager& cookieManager();



    return (c == ' ' || c == '\t');
}

CookieParser::CookieParser(const URL& defaultCookieURL)
    : m_defaultCookieURL(defaultCookieURL)
{
    m_defaultCookieHost = defaultCookieURL.host();

        case 'P':
        case 'p' : {
            if (length >= 4 && ((cookie.find("ath", tokenStartSvg + 1, false) - tokenStartSvg) == 1)) {
                // We need the path to be decoded to match those returned from URL::path().
                // The path attribute may or may not include percent-encoded characters. Fortunately
                // if there are no percent-encoded characters, decoding the url is a no-op.
                res->setPath(decodeURLEscapeSequences(parsedValue));



#ifndef CookieParser_h
#define CookieParser_h

#include "URL.h"
#include <wtf/Vector.h>

namespace WTF {


class CookieParser {
public:
    CookieParser(const URL& defaultCookieURL);
    ~CookieParser();

    // Parses a sequence of "Cookie:" header and return the parsed cookies.

    // FIXME: curTime, start, end parameters should be removed. And this method can be public.
    PassRefPtr<ParsedCookie> parseOneCookie(const String& cookie, unsigned start, unsigned end, double curTime);

    URL m_defaultCookieURL;
    String m_defaultCookieHost;
    bool m_defaultDomainIsIPAddress;
};




namespace WebCore {

URL DOMFileSystemBase::createFileSystemURL(const String& fullPath) const
{
    ASSERT(DOMFilePath::isAbsolute(fullPath));


    return m_context->completeURL(m_filesystemRootURL.string() + encodeWithURLEscapeSequences(fullPath));
}

bool DOMFileSystemBase::crackFileSystemURL(const URL& url, FileSystemType& type, String& filePath)
{
    if (!url.protocolIs("filesystem"))
        return false;


        filePath = decodeURLEscapeSequences(url.path());
    } else {
        URL originURL(ParsedURLString, url.path());
        String path = decodeURLEscapeSequences(originURL.path());
        if (path.isEmpty() || path[0] != '/')
            return false;



#include "FileSystemCallback.h"
#include "FileSystemCallbacks.h"
#include "FileSystemType.h"
#include "URL.h"
#include "Page.h"
#include "PageClientBlackBerry.h"
#include "SecurityOrigin.h"

    if (type == FileSystemTypeIsolated)
        return;

    URL url = context->url();
    if (url.hasFragmentIdentifier())
        url.removeFragmentIdentifier();
    url.setQuery(String());

    builder.append("filesystem:");
    builder.append(url.string());
    builder.append(fileSystemTypeString(type));
    URL rootURL = context->completeURL(builder.toString());
    ASSERT(rootURL.isValid());

    // TODO: Ask user for file system permission.



class Credential;
class IntRect;
class IntSize;
class URL;
class PluginView;
class ProtectionSpace;
}

    virtual int showAlertDialog(BlackBerry::WebKit::WebPageClient::AlertType) = 0;
    virtual bool isActive() const = 0;
    virtual bool isVisible() const = 0;
    virtual void authenticationChallenge(const WebCore::URL&, const WebCore::ProtectionSpace&, const WebCore::Credential&) = 0;
    virtual SaveCredentialType notifyShouldSaveCredential(bool) = 0;
    virtual void syncProxyCredential(const WebCore::Credential&) = 0;
};

Lines 28-34 a/Source/WebCore/platform/blackberry/ParsedCookie.cpp_sec1
- a/Source/WebCore/platform/blackberry/ParsedCookie.cpp -1 / +1 lines
28	#include "ParsedCookie.h"	28	#include "ParsedCookie.h"
29		29
30	#include "CookieManager.h"	30	#include "CookieManager.h"
31	#include "KURL.h"	31	#include "URL.h"
32	#include "Logging.h"	32	#include "Logging.h"
33	#include <curl/curl.h>	33	#include <curl/curl.h>
34	#include <wtf/CurrentTime.h>	34	#include <wtf/CurrentTime.h>

Lines 37-43 class String; a/Source/WebCore/platform/blackberry/ParsedCookie.h_sec1
- a/Source/WebCore/platform/blackberry/ParsedCookie.h -1 / +1 lines
37	}	37	}
38	namespace WebCore {	38	namespace WebCore {
39		39
40	class KURL;	40	class URL;
41		41
42	// This class represents a cookie internally	42	// This class represents a cookie internally
43	// It can either be created by the CookieParser which will then fill it	43	// It can either be created by the CookieParser which will then fill it




#include "DocumentFragment.h"
#include "Frame.h"
#include "URL.h"
#include "NotImplemented.h"
#include "Range.h"
#include "markup.h"

    BlackBerry::Platform::Clipboard::clearClipboard();
}

void Pasteboard::writeImage(Node*, URL const&, String const&)
{
    notImplemented();
}




#if ENABLE(FILE_SYSTEM)
#include "AsyncFileSystemCallbacks.h"
#include "URL.h"

#include <BlackBerryPlatformWebFileSystem.h>
#include <wtf/OwnPtr.h>


class PlatformAsyncFileSystemCallbacks: public BlackBerry::Platform::WebFileSystemCallbacks {
public:
    PlatformAsyncFileSystemCallbacks(PassOwnPtr<AsyncFileSystemCallbacks> callbacks, const URL& rootURL = URL())
        : m_callbacks(callbacks)
        , m_writerClient(0)
        , m_rootURL(rootURL)

    AsyncFileWriterClient* m_writerClient;

private:
    URL m_rootURL;
};

} // namespace WebCore



#include "config.h"
#include "SSLKeyGenerator.h"

#include "URL.h"
#include "NotImplemented.h"
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>

    notImplemented();
}

String signedPublicKeyAndChallengeString(unsigned, String const&, URL const&)
{
    notImplemented();
    return String();



    WebFileSystem::deleteFileSystem(webKitThreadMessageClient(), basePath, storageIdentifier, static_cast<WebFileSystem::Type>(type), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::moveOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& sourcePath, const URL& destinationPath, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->move(fileSystemURLToPath(sourcePath), fileSystemURLToPath(destinationPath), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::copyOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& sourcePath, const URL& destinationPath, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->copy(fileSystemURLToPath(sourcePath), fileSystemURLToPath(destinationPath), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::removeOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->remove(fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::removeRecursivelyOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->removeRecursively(fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::readMetadataOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->readMetadata(fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::createFileOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, bool exclusive, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->createFile(fileSystemURLToPath(path), exclusive, callbacks);
}

void WorkerAsyncFileSystemBlackBerry::createDirectoryOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, bool exclusive, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->createDirectory(fileSystemURLToPath(path), exclusive, callbacks);
}

void WorkerAsyncFileSystemBlackBerry::fileExistsOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->fileExists(fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::directoryExistsOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->directoryExists(fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::readDirectoryOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->readDirectory(fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::createWriterOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, AsyncFileWriterClient*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    WebFileWriter::createWriter(platformFileSystem, fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::createSnapshotFileAndReadMetadataOnMainThread(ScriptExecutionContext*, WebFileSystem* platformFileSystem, const URL& path, WorkerPlatformAsyncFileSystemCallbacks* callbacks)
{
    platformFileSystem->createSnapshotFileAndReadMetadata(fileSystemURLToPath(path), callbacks);
}

void WorkerAsyncFileSystemBlackBerry::openFileSystem(WorkerGlobalScope* context, const URL& rootURL, const String& mode, const String& basePath, const String& storageIdentifier, FileSystemType type, long long size, bool create, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    ASSERT(context);
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::openFileSystemOnMainThread, basePath, storageIdentifier, type, size, create, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, context, mode, rootURL)));

    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::deleteFileSystemOnMainThread, basePath, storageIdentifier, type, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, context, mode)));
}

void WorkerAsyncFileSystemBlackBerry::move(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::moveOnMainThread, m_platformFileSystem.get(), sourcePath, destinationPath, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::copy(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::copyOnMainThread, m_platformFileSystem.get(), sourcePath, destinationPath, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::remove(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::removeOnMainThread, m_platformFileSystem.get(), path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::removeRecursively(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::removeRecursivelyOnMainThread, m_platformFileSystem.get(), path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::readMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::readMetadataOnMainThread, m_platformFileSystem.get(), path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::createFile(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::createFileOnMainThread, m_platformFileSystem.get(), path, exclusive, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::createDirectory(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::createDirectoryOnMainThread, m_platformFileSystem.get(), path, exclusive, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::fileExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::fileExistsOnMainThread, m_platformFileSystem.get(), path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::directoryExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::directoryExistsOnMainThread, m_platformFileSystem.get(), path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::readDirectory(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::readDirectoryOnMainThread, m_platformFileSystem.get(), path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::createWriter(AsyncFileWriterClient* client, const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::createWriterOnMainThread, m_platformFileSystem.get(), client, path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, client, m_context, m_mode)));
}

void WorkerAsyncFileSystemBlackBerry::createSnapshotFileAndReadMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    postTaskToMainThread(createCallbackTask(&WorkerAsyncFileSystemBlackBerry::createSnapshotFileAndReadMetadataOnMainThread, m_platformFileSystem.get(), path, new WorkerPlatformAsyncFileSystemCallbacks(callbacks, m_context, m_mode)));
}



        return adoptPtr(new WorkerAsyncFileSystemBlackBerry(context, mode, platformFileSystem));
    }

    static void openFileSystem(WorkerGlobalScope*, const URL& rootURL, const String& mode, const String& basePath, const String& storageIdentifier, FileSystemType, long long size, bool create, PassOwnPtr<AsyncFileSystemCallbacks>);
    static void deleteFileSystem(WorkerGlobalScope*, const String& mode, const String& basePath, const String& storageIdentifier, FileSystemType, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual ~WorkerAsyncFileSystemBlackBerry();
    virtual bool waitForOperationToComplete();
    virtual void move(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void copy(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void remove(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void removeRecursively(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createFile(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createDirectory(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void fileExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void directoryExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readDirectory(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createWriter(AsyncFileWriterClient*, const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createSnapshotFileAndReadMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);

private:
    WorkerAsyncFileSystemBlackBerry(WorkerGlobalScope*, const String& mode, PassOwnPtr<BlackBerry::Platform::WebFileSystem> platformFileSystem);
    static void openFileSystemOnMainThread(ScriptExecutionContext*, const String& basePath, const String& storageIdentifier, FileSystemType, long long size, bool create, WorkerPlatformAsyncFileSystemCallbacks*);
    static void deleteFileSystemOnMainThread(ScriptExecutionContext*, const String& basePath, const String& storageIdentifier, FileSystemType, WorkerPlatformAsyncFileSystemCallbacks*);
    static void moveOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& sourcePath, const URL& destinationPath, WorkerPlatformAsyncFileSystemCallbacks*);
    static void copyOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& sourcePath, const URL& destinationPath, WorkerPlatformAsyncFileSystemCallbacks*);
    static void removeOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);
    static void removeRecursivelyOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);
    static void readMetadataOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);
    static void createFileOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, bool exclusive, WorkerPlatformAsyncFileSystemCallbacks*);
    static void createDirectoryOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, bool exclusive, WorkerPlatformAsyncFileSystemCallbacks*);
    static void fileExistsOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);
    static void directoryExistsOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);
    static void readDirectoryOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);
    static void createWriterOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, AsyncFileWriterClient*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);
    static void createSnapshotFileAndReadMetadataOnMainThread(ScriptExecutionContext*, BlackBerry::Platform::WebFileSystem*, const URL& path, WorkerPlatformAsyncFileSystemCallbacks*);

    WorkerGlobalScope* m_context;
    String m_mode;




void postTaskToMainThread(PassOwnPtr<ScriptExecutionContext::Task>);

class URL;

class WorkerPlatformAsyncFileSystemCallbacks: public PlatformAsyncFileSystemCallbacks, public WorkerGlobalScope::Observer {
public:
    WorkerPlatformAsyncFileSystemCallbacks(PassOwnPtr<AsyncFileSystemCallbacks> callbacks, WorkerGlobalScope* context, const String& mode, const URL& rootURL = URL())
        : PlatformAsyncFileSystemCallbacks(callbacks, rootURL)
        , WorkerGlobalScope::Observer(context)
        , m_context(context)



/*
 * Copyright (C) 2004, 2008, 2013 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "KURL.h"

#include "CFURLExtras.h"
#include <CoreFoundation/CFURL.h>
#include <wtf/text/CString.h>

using namespace std;

namespace WebCore {

KURL::KURL(CFURLRef url)
{
    if (!url) {
        invalidate();
        return;
    }

    // FIXME: Why is it OK to ignore base URL here?
    CString urlBytes;
    getURLBytes(url, urlBytes);
    parse(urlBytes.data());
}

#if !PLATFORM(MAC)
RetainPtr<CFURLRef> KURL::createCFURL() const
{
    // FIXME: What should this return for invalid URLs?
    // Currently it throws away the high bytes of the characters in the string in that case,
    // which is clearly wrong.
    URLCharBuffer buffer;
    copyToBuffer(buffer);
    return createCFURLFromBuffer(buffer.data(), buffer.size());
}
#endif

String KURL::fileSystemPath() const
{
    RetainPtr<CFURLRef> cfURL = createCFURL();
    if (!cfURL)
        return String();

#if PLATFORM(WIN)
    CFURLPathStyle pathStyle = kCFURLWindowsPathStyle;
#else
    CFURLPathStyle pathStyle = kCFURLPOSIXPathStyle;
#endif
    return adoptCF(CFURLCopyFileSystemPath(cfURL.get(), pathStyle)).get();
}

}



{
}

void AsyncFileSystemEfl::move(const URL&, const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::copy(const URL&, const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::remove(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::removeRecursively(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::readMetadata(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::createFile(const URL&, bool, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::createDirectory(const URL&, bool, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::fileExists(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::directoryExists(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::readDirectory(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::createWriter(AsyncFileWriterClient*, const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}

void AsyncFileSystemEfl::createSnapshotFileAndReadMetadata(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}



    AsyncFileSystemEfl();
    virtual ~AsyncFileSystemEfl();

    virtual void move(const URL&, const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void copy(const URL&, const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void remove(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void removeRecursively(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readMetadata(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createFile(const URL&, bool, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createDirectory(const URL&, bool, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void fileExists(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void directoryExists(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readDirectory(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createWriter(AsyncFileWriterClient*, const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createSnapshotFileAndReadMetadata(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>);
};

} // namespace WebCore



{
    DocumentLoader* documentLoader = printContext->frame()->loader().documentLoader();

    return ResourceError(errorDomainPrint, PrintErrorGeneral, documentLoader ? documentLoader->url() : URL(), errorMessage);
}

ResourceError printerNotFoundError(const PrintContext* printContext)
{
    DocumentLoader* documentLoader = printContext->frame()->loader().documentLoader();

    return ResourceError(errorDomainPrint, PrintErrorPrinterNotFound, documentLoader ? documentLoader->url() : URL(), ASCIILiteral("Printer not found"));
}

ResourceError invalidPageRangeToPrint(const PrintContext* printContext)
{
    DocumentLoader* documentLoader = printContext->frame()->loader().documentLoader();

    return ResourceError(errorDomainPrint, PrintErrorInvalidPageRange, documentLoader ? documentLoader->url() : URL(), ASCIILiteral("Invalid page range"));
}

} // namespace WebCore



#include "Editor.h"
#include "FTPDirectoryDocument.h"
#include "FrameView.h"
#include "URL.h"
#include "NotImplemented.h"
#include "PluginView.h"
#include "ScrollbarTheme.h"

    notImplemented();
}

String signedPublicKeyAndChallengeString(unsigned, const String&, const URL&)
{
    return String();
}



    class ImageBuffer;
    class IntRect;
    class RoundedRect;
    class URL;
    class GraphicsContext3D;
    class TextRun;
    class TransformationMatrix;

        void translate(const FloatSize& size) { translate(size.width(), size.height()); }
        void translate(float x, float y);

        void setURLForRect(const URL&, const IntRect&);

        void concatCTM(const AffineTransform&);
        void setCTM(const AffineTransform&);




static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);

static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, const URL&, MediaPlayerFactory* current = 0);
static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);

enum RequeryEngineOptions { DoNotResetEngines, ResetEngines };

    return codecs;
}

static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, const URL& url, MediaPlayerFactory* current)
{
    if (type.isEmpty())
        return 0;

    m_mediaPlayerClient = 0;
}

bool MediaPlayer::load(const URL& url, const ContentType& contentType, const String& keySystem)
{
    m_contentMIMEType = contentType.type().lower();
    m_contentTypeCodecs = contentType.parameter(codecs());

}

#if ENABLE(MEDIA_SOURCE)
bool MediaPlayer::load(const URL& url, PassRefPtr<HTMLMediaSource> mediaSource)
{
    m_mediaSource = mediaSource;
    m_contentMIMEType = "";

    return m_private->copyVideoTextureToPlatformTexture(context, texture, level, type, internalFormat, premultiplyAlpha, flipY);
}

MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType, const String& keySystem, const URL& url, const MediaPlayerSupportsTypeClient* client)
{
    String type = contentType.type().lower();
    // The codecs string is not lower-cased because MP4 values are case sensitive

        m_mediaPlayerClient->mediaPlayerKeyError(this, keySystem, sessionId, errorCode, systemCode);
}

void MediaPlayer::keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL)
{
    if (m_mediaPlayerClient)
        m_mediaPlayerClient->mediaPlayerKeyMessage(this, keySystem, sessionId, message, messageLength, defaultURL);



#include "AudioTrackPrivate.h"
#include "InbandTextTrackPrivate.h"
#include "IntRect.h"
#include "URL.h"
#include "LayoutRect.h"
#include "Timer.h"
#include "VideoTrackPrivate.h"

    enum MediaKeyErrorCode { UnknownError = 1, ClientError, ServiceError, OutputError, HardwareChangeError, DomainError };
    virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */) { }
    virtual void mediaPlayerKeyError(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, MediaKeyErrorCode, unsigned short /* systemCode */) { }
    virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* message */, unsigned /* messageLength */, const URL& /* defaultURL */) { }
    virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* initData */, unsigned /* initDataLength */) { return false; }
#endif



    // Media engine support.
    enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
    static MediaPlayer::SupportsType supportsType(const ContentType&, const String& keySystem, const URL&, const MediaPlayerSupportsTypeClient*);
    static void getSupportedTypes(HashSet<String>&);
    static bool isAvailable();
    static void getSitesInMediaCache(Vector<String>&);

    IntSize size() const { return m_size; }
    void setSize(const IntSize& size);

    bool load(const URL&, const ContentType&, const String& keySystem);
#if ENABLE(MEDIA_SOURCE)
    bool load(const URL&, PassRefPtr<HTMLMediaSource>);
#endif
    void cancelLoad();


#if ENABLE(ENCRYPTED_MEDIA)
    void keyAdded(const String& keySystem, const String& sessionId);
    void keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode);
    void keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL);
    bool keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength);
#endif


    Timer<MediaPlayer> m_reloadTimer;
    OwnPtr<MediaPlayerPrivateInterface> m_private;
    MediaPlayerFactory* m_currentMediaEngine;
    URL m_url;
    String m_contentMIMEType;
    String m_contentTypeCodecs;
    String m_keySystem;

typedef PassOwnPtr<MediaPlayerPrivateInterface> (*CreateMediaEnginePlayer)(MediaPlayer*);
typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs, const String& keySystem, const URL& url);
#else
typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs, const URL& url);
#endif
typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
typedef void (*MediaEngineClearMediaCache)();

Lines 35-41 a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp_sec1
- a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp -1 / +1 lines
35	#include "GraphicsContext.h"	35	#include "GraphicsContext.h"
36	#include "InbandTextTrackPrivateAVF.h"	36	#include "InbandTextTrackPrivateAVF.h"
37	#include "InbandTextTrackPrivateClient.h"	37	#include "InbandTextTrackPrivateClient.h"
38	#include "KURL.h"	38	#include "URL.h"
39	#include "Logging.h"	39	#include "Logging.h"
40	#include "PlatformLayer.h"	40	#include "PlatformLayer.h"
41	#include "SoftLinking.h"	41	#include "SoftLinking.h"



#else
#include "InbandTextTrackPrivateLegacyAVCF.h"
#endif
#include "URL.h"
#include "Logging.h"
#include "PlatformCALayer.h"
#include "SoftLinking.h"

    supportedTypes = mimeTypeCache();
} 

MediaPlayer::SupportsType MediaPlayerPrivateAVFoundationCF::supportsType(const String& type, const String& codecs, const URL&)
{
    // Only return "IsSupported" if there is no codecs parameter for now as there is no way to ask if it supports an
    // extended MIME type until rdar://8721715 is fixed.

{
    ASSERT(!avAsset());

    RetainPtr<CFURLRef> urlRef = URL(ParsedURLString, url).createCFURL();

    AVCFURLAssetRef assetRef = AVCFURLAssetCreateWithURLAndOptions(kCFAllocatorDefault, urlRef.get(), 0, m_notificationQueue);
    m_avAsset = adoptCF(assetRef);

Lines 48-54 private: a/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h_sec1
- a/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h -1 / +1 lines
48	// Engine support	48	// Engine support
49	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);	49	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
50	static void getSupportedTypes(HashSet<String>& types);	50	static void getSupportedTypes(HashSet<String>& types);
51	static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const KURL&);	51	static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const URL&);
52	static bool isAvailable();	52	static bool isAvailable();
53		53
54	virtual void cancelLoad();	54	virtual void cancelLoad();



    // engine support
    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static void getSupportedTypes(HashSet<String>& types);
    static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const URL&);
#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
    static MediaPlayer::SupportsType extendedSupportsType(const String& type, const String& codecs, const String& keySystem, const URL&);
#endif

    static bool isAvailable();



#import "GraphicsContext.h"
#import "InbandTextTrackPrivateAVFObjC.h"
#import "InbandTextTrackPrivateLegacyAVFObjC.h"
#import "URL.h"
#import "Logging.h"
#import "SecurityOrigin.h"
#import "SoftLinking.h"

        [options.get() setObject:headerFields.get() forKey:@"AVURLAssetHTTPHeaderFieldsKey"];
#endif

    NSURL *cocoaURL = URL(ParsedURLString, url);
    m_avAsset = adoptNS([[AVURLAsset alloc] initWithURL:cocoaURL options:options.get()]);

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090

    supportedTypes = mimeTypeCache();
} 

MediaPlayer::SupportsType MediaPlayerPrivateAVFoundationObjC::supportsType(const String& type, const String& codecs, const URL&)
{
    if (!mimeTypeCache().contains(type))
        return MediaPlayer::IsNotSupported;

    return false;
}

MediaPlayer::SupportsType MediaPlayerPrivateAVFoundationObjC::extendedSupportsType(const String& type, const String& codecs, const String& keySystem, const URL& url)
{
    // From: <http://dvcs.w3.org/hg/html-media/raw-file/eme-v0.1b/encrypted-media/encrypted-media.html#dom-canplaytype>
    // In addition to the steps in the current specification, this method must run the following steps:

    if (!m_avAsset)
        return false;
    
    RefPtr<SecurityOrigin> resolvedOrigin = SecurityOrigin::create(URL(wkAVAssetResolvedURL(m_avAsset.get())));
    RefPtr<SecurityOrigin> requestedOrigin = SecurityOrigin::createFromString(assetURL());
    return resolvedOrigin->isSameSchemeHostPort(requestedOrigin.get());
}


    RefPtr<ArrayBuffer> keyRequestBuffer = ArrayBuffer::create([keyRequest.get() bytes], [keyRequest.get() length]);
    RefPtr<Uint8Array> keyRequestArray = Uint8Array::create(keyRequestBuffer, 0, keyRequestBuffer->byteLength());
    player()->keyMessage(keySystem, sessionID, keyRequestArray->data(), keyRequestArray->byteLength(), URL());

    // Move ownership of the AVAssetResourceLoadingRequestfrom the keyIDToRequestMap to the sessionIDToRequestMap:
    m_sessionIDToRequestMap.set(sessionID, avRequest);

Lines 66-72 void WebCoreAVFResourceLoader::startLoading() a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm_sec1
- a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm -1 / +1 lines
66	if (m_resource)	66	if (m_resource)
67	return;	67	return;
68		68
69	KURL requestURL = [[m_avRequest.get() request] URL];	69	URL requestURL = [[m_avRequest.get() request] URL];
70		70
71	CachedResourceRequest request(ResourceRequest(requestURL), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck, UseDefaultOriginRestrictionsForType));	71	CachedResourceRequest request(ResourceRequest(requestURL), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck, UseDefaultOriginRestrictionsForType));
72		72

Lines 21-27 a/Source/WebCore/platform/graphics/blackberry/GradientBlackBerry.cpp_sec1
- a/Source/WebCore/platform/graphics/blackberry/GradientBlackBerry.cpp -1 / +1 lines
21	#include "AffineTransform.h"	21	#include "AffineTransform.h"
22	#include "GraphicsContext.h"	22	#include "GraphicsContext.h"
23	#include "GraphicsContext3D.h"	23	#include "GraphicsContext3D.h"
24	#include "KURL.h"	24	#include "URL.h"
25	#include "NotImplemented.h"	25	#include "NotImplemented.h"
26	#include "TransformationMatrix.h"	26	#include "TransformationMatrix.h"
27		27



#include "AffineTransform.h"
#include "Gradient.h"
#include "GraphicsContext3D.h"
#include "KURL.h"
#include "NotImplemented.h"
#include "RoundedRect.h"
#include "TransformationMatrix.h"
#include "URL.h"

#include <BlackBerryPlatformGraphicsContext.h>
#include <stdio.h>

    return IntRect(IntPoint(INT_MIN / 2, INT_MIN / 2), IntSize(INT_MAX, INT_MAX));
}

void GraphicsContext::setURLForRect(const URL&, const IntRect&)
{
}




        types.add(*i);
}

MediaPlayer::SupportsType MediaPlayerPrivate::supportsType(const WTF::String& type, const WTF::String& codecs, const URL& url)
{
    bool isRTSP = url.protocolIs("rtsp");


    WTF::String modifiedUrl(url);

    if (modifiedUrl.startsWith("local://")) {
        URL kurl = URL(URL(), modifiedUrl);
        kurl.setProtocol("file");
        WTF::String tempPath(BlackBerry::Platform::Settings::instance()->applicationLocalDirectory().c_str());
        tempPath.append(kurl.path());

    // already done a security check on the filesystem: URL as part of the
    // media resource selection algorithm, we should be OK here.
    if (modifiedUrl.startsWith("filesystem:")) {
        URL kurl = URL(URL(), modifiedUrl);
        URL mediaURL;
        WTF::String fsPath;
        FileSystemType fsType;
        WebFileSystem::Type type;


    WTF::String cookiePairs;
    if (!url.isEmpty())
        cookiePairs = cookieManager().getCookie(URL(ParsedURLString, url), WithHttpOnlyCookies);
    m_platformPlayer->load(playerID, modifiedUrl, m_webCorePlayer->userAgent(), cookiePairs);
}



static ProtectionSpace generateProtectionSpaceFromMMRAuthChallenge(const MMRAuthChallenge& authChallenge)
{
    URL url(ParsedURLString, WTF::String(authChallenge.url().c_str()));
    ASSERT(url.isValid());

    return ProtectionSpace(url.host(), url.port(),


void MediaPlayerPrivate::onAuthenticationNeeded(MMRAuthChallenge& authChallenge)
{
    URL url(ParsedURLString, WTF::String(authChallenge.url().c_str()));
    if (!url.isValid())
        return;


        this, m_webCorePlayer->mediaPlayerClient()->mediaPlayerHostWindow()->platformPageClient());
}

void MediaPlayerPrivate::notifyChallengeResult(const URL& url, const ProtectionSpace&, AuthenticationChallengeResult result, const Credential& credential)
{
    m_isAuthenticationChallenging = false;



void MediaPlayerPrivate::onAuthenticationAccepted(const MMRAuthChallenge& authChallenge) const
{
    URL url(ParsedURLString, WTF::String(authChallenge.url().c_str()));
    if (!url.isValid())
        return;




    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static void registerMediaEngine(MediaEngineRegistrar);
    static void getSupportedTypes(HashSet<WTF::String>&);
    static MediaPlayer::SupportsType supportsType(const WTF::String&, const WTF::String&, const URL&);
    static void notifyAppActivatedEvent(bool);
    static void setCertificatePath(const WTF::String&);


    virtual void onCreateHolePunchRect();
    virtual void onDestroyHolePunchRect();

    virtual void notifyChallengeResult(const URL&, const ProtectionSpace&, AuthenticationChallengeResult, const Credential&);

    virtual bool isProcessingUserGesture() const;
    virtual bool isFullscreen() const;

Lines 757-763 void GraphicsContext::setPlatformStrokeStyle(StrokeStyle strokeStyle) a/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp_sec1
- a/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp -1 / +1 lines
757	}	757	}
758	}	758	}
759		759
760	void GraphicsContext::setURLForRect(const KURL&, const IntRect&)	760	void GraphicsContext::setURLForRect(const URL&, const IntRect&)
761	{	761	{
762	notImplemented();	762	notImplemented();
763	}	763	}



#include "GraphicsContextPlatformPrivateCG.h"
#include "ImageBuffer.h"
#include "ImageOrientation.h"
#include "URL.h"
#include "Path.h"
#include "Pattern.h"
#include "ShadowBlur.h"

        CGContextSetShouldAntialias(platformContext(), true);
}

void GraphicsContext::setURLForRect(const URL& link, const IntRect& destRect)
{
    if (paintingDisabled())
        return;




#include "GStreamerUtilities.h"
#include "GStreamerVersioning.h"
#include "URL.h"
#include "Logging.h"
#include "MIMETypeRegistry.h"
#include "MediaPlayer.h"

    if (!initializeGStreamerAndRegisterWebKitElements())
        return;

    URL kurl(URL(), url);
    String cleanUrl(url);

    // Clean out everything after file:// url path.


    ASSERT(m_playBin);

    m_url = URL(URL(), cleanUrl);
    g_object_set(m_playBin.get(), "uri", cleanUrl.utf8().data(), NULL);

    INFO_MEDIA_MESSAGE("Load %s", cleanUrl.utf8().data());

        // Found a candidate. new-location is not always an absolute url
        // though. We need to take the base of the current url and
        // append the value of new-location to it.
        URL baseUrl = gst_uri_is_valid(newLocation) ? URL() : m_url;
        URL newUrl = URL(baseUrl, newLocation);

        RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::create(m_url);
        if (securityOrigin->canRequest(newUrl)) {

    types = mimeTypeCache();
}

MediaPlayer::SupportsType MediaPlayerPrivateGStreamer::supportsType(const String& type, const String& codecs, const URL&)
{
    if (type.isNull() || type.isEmpty())
        return MediaPlayer::IsNotSupported;



    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);

    static void getSupportedTypes(HashSet<String>&);
    static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const URL&);

    static bool isAvailable();


    guint m_readyTimerHandler;
    GRefPtr<GstElement> m_webkitAudioSink;
    mutable long m_totalBytes;
    URL m_url;
    bool m_preservesPitch;
    GstState m_requestedState;
    GRefPtr<GstElement> m_autoAudioSink;




    ASSERT(!priv->client);

    URL url = URL(URL(), priv->uri);

    ResourceRequest request(url);
    request.setAllowCookies(true);

    if (!uri)
        return TRUE;

    URL url(URL(), uri);

    if (!url.isValid() || !url.protocolIsInHTTPFamily()) {
        g_set_error(error, GST_URI_ERROR, GST_URI_ERROR_BAD_URI, "Invalid URI '%s'", uri);

    if (!uri)
        return TRUE;

    URL url(URL(), uri);

    if (!url.isValid() || !url.protocolIsInHTTPFamily()) {
        GST_ERROR_OBJECT(src, "Invalid URI '%s'", uri);



    // engine support
    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static void getSupportedTypes(HashSet<String>& types);
    static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const URL&);
#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
    static MediaPlayer::SupportsType extendedSupportsType(const String& type, const String& codecs, const String& keySystem, const URL&);
#endif

    static void getSitesInMediaCache(Vector<String>&);



#import "FrameView.h"
#import "HostWindow.h"
#import "GraphicsContext.h"
#import "URL.h"
#import "Logging.h"
#import "MIMETypeRegistry.h"
#import "SecurityOrigin.h"


void MediaPlayerPrivateQTKit::createQTMovie(const String& url)
{
    URL kURL(ParsedURLString, url);
    NSURL *cocoaURL = kURL;
    NSMutableDictionary *movieAttributes = commonMovieAttributes();    
    [movieAttributes setValue:cocoaURL forKey:QTMovieURLAttribute];

    concatenateHashSets(supportedTypes, mimeCommonTypesCache());
}

MediaPlayer::SupportsType MediaPlayerPrivateQTKit::supportsType(const String& type, const String& codecs, const URL&)
{
    // Only return "IsSupported" if there is no codecs parameter for now as there is no way to ask QT if it supports an
    // extended MIME type yet.

}

#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
MediaPlayer::SupportsType MediaPlayerPrivateQTKit::extendedSupportsType(const String& type, const String& codecs, const String& keySystem, const URL& url)
{
    // QTKit does not support any encrytped media, so return IsNotSupported if the keySystem is non-NULL:
    if (!keySystem.isNull() || !keySystem.isEmpty())

    if (!m_qtMovie)
        return false;

    RefPtr<SecurityOrigin> resolvedOrigin = SecurityOrigin::create(URL(wkQTMovieResolvedURL(m_qtMovie.get())));
    RefPtr<SecurityOrigin> requestedOrigin = SecurityOrigin::createFromString(m_movieURL);
    return resolvedOrigin->isSameSchemeHostPort(requestedOrigin.get());
}

Lines 1521-1527 void GraphicsContext::set3DTransform(const TransformationMatrix& transform) a/Source/WebCore/platform/graphics/qt/GraphicsContextQt.cpp_sec1
- a/Source/WebCore/platform/graphics/qt/GraphicsContextQt.cpp -1 / +1 lines
1521	}	1521	}
1522	#endif	1522	#endif
1523		1523
1524	void GraphicsContext::setURLForRect(const KURL&, const IntRect&)	1524	void GraphicsContext::setURLForRect(const URL&, const IntRect&)
1525	{	1525	{
1526	notImplemented();	1526	notImplemented();
1527	}	1527	}



    }
}

MediaPlayer::SupportsType MediaPlayerPrivateQt::supportsType(const String& mime, const String& codec, const URL&)
{
    if (!mime.startsWith("audio/") && !mime.startsWith("video/"))
        return MediaPlayer::IsNotSupported;

        m_webCorePlayer->readyStateChanged();
    }

    URL kUrl(ParsedURLString, url);
    const QUrl rUrl = kUrl;
    const QString scheme = rUrl.scheme().toLower();


Lines 53-59 public: a/Source/WebCore/platform/graphics/qt/MediaPlayerPrivateQt.h_sec1
- a/Source/WebCore/platform/graphics/qt/MediaPlayerPrivateQt.h -1 / +1 lines
53		53
54	static void registerMediaEngine(MediaEngineRegistrar);	54	static void registerMediaEngine(MediaEngineRegistrar);
55	static void getSupportedTypes(HashSet<String>&);	55	static void getSupportedTypes(HashSet<String>&);
56	static MediaPlayer::SupportsType supportsType(const String&, const String&, const KURL&);	56	static MediaPlayer::SupportsType supportsType(const String&, const String&, const URL&);
57	static bool isAvailable() { return true; }	57	static bool isAvailable() { return true; }
58		58
59	bool hasVideo() const;	59	bool hasVideo() const;



#include "Frame.h"
#include "FrameView.h"
#include "GraphicsContext.h"
#include "KURL.h"
#include "MediaPlayerPrivateTaskTimer.h"
#include "Page.h"
#include "QTCFDictionary.h"

#include "SoftLinking.h"
#include "TimeRanges.h"
#include "Timer.h"
#include "URL.h"
#include <AssertMacros.h>
#include <CoreGraphics/CGAffineTransform.h>
#include <CoreGraphics/CGContext.h>

    if (!frame || !frame->page() || !frame->page()->settings().cookieEnabled())
        return;

    URL movieURL = URL(URL(), url);
    Vector<Cookie> documentCookies;
    if (!getRawCookies(frame->document(), movieURL, documentCookies))
        return;

#endif
}

MediaPlayer::SupportsType MediaPlayerPrivateQuickTimeVisualContext::supportsType(const String& type, const String& codecs, const URL&)
{
    // only return "IsSupported" if there is no codecs parameter for now as there is no way to ask QT if it supports an
    //  extended MIME type

Lines 128-134 private: a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h_sec1
- a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.h -1 / +1 lines
128	// engine support	128	// engine support
129	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);	129	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
130	static void getSupportedTypes(HashSet<String>& types);	130	static void getSupportedTypes(HashSet<String>& types);
131	static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const KURL&);	131	static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const URL&);
132	static bool isAvailable();	132	static bool isAvailable();
133		133
134	#if USE(ACCELERATED_COMPOSITING)	134	#if USE(ACCELERATED_COMPOSITING)

Lines 981-987 void GraphicsContext::setPlatformStrokeThickness(float strokeThickness) a/Source/WebCore/platform/graphics/wince/GraphicsContextWinCE.cpp_sec1
- a/Source/WebCore/platform/graphics/wince/GraphicsContextWinCE.cpp -1 / +1 lines
981	notImplemented();	981	notImplemented();
982	}	982	}
983		983
984	void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)	984	void GraphicsContext::setURLForRect(const URL& link, const IntRect& destRect)
985	{	985	{
986	notImplemented();	986	notImplemented();
987	}	987	}

Lines 100-106 namespace WebCore { a/Source/WebCore/platform/graphics/wince/MediaPlayerPrivateWinCE.h_sec1
- a/Source/WebCore/platform/graphics/wince/MediaPlayerPrivateWinCE.h -1 / +1 lines
100	// engine support	100	// engine support
101	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);	101	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
102	static void getSupportedTypes(HashSet<String>& types);	102	static void getSupportedTypes(HashSet<String>& types);
103	static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const KURL&);	103	static MediaPlayer::SupportsType supportsType(const String& type, const String& codecs, const URL&);
104	static bool isAvailable();	104	static bool isAvailable();
105		105
106	virtual String engineDescription() const { return "WinCE"; }	106	virtual String engineDescription() const { return "WinCE"; }



    notImplemented();
}

void AsyncFileSystemGtk::move(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::copy(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::remove(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::removeRecursively(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::readMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::createFile(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::createDirectory(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::fileExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::directoryExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::readDirectory(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}


void AsyncFileSystemGtk::createWriter(AsyncFileWriterClient* client, const URL& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
{
    notImplemented();
}

void AsyncFileSystemGtk::createSnapshotFileAndReadMetadata(const URL&, PassOwnPtr<AsyncFileSystemCallbacks>)
{
    notImplemented();
}



    AsyncFileSystemGtk();
    virtual ~AsyncFileSystemGtk();

    virtual void move(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void copy(const URL& sourcePath, const URL& destinationPath, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void remove(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void removeRecursively(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readMetadata(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createFile(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createDirectory(const URL& path, bool exclusive, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void fileExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void directoryExists(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void readDirectory(const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    virtual void createWriter(AsyncFileWriterClient*, const URL& path, PassOwnPtr<AsyncFileSystemCallbacks>);
};

} // namespace WebCore



        if (line[0] == '#')
            continue;

        URL url = URL(URL(), line);
        if (url.isValid()) {
            if (!setURL) {
                m_url = url;

    }
}

void DataObjectGtk::setURL(const URL& url, const String& label)
{
    m_url = url;
    m_uriList = url;

    m_text = "";
    m_markup = "";
    m_uriList = "";
    m_url = URL();
    m_image = 0;
    m_range = 0;
}



#define DataObjectGtk_h

#include "FileList.h"
#include "URL.h"
#include "Range.h"
#include <wtf/RefCounted.h>
#include <wtf/gobject/GRefPtr.h>

        return adoptRef(new DataObjectGtk());
    }

    const URL& url() const { return m_url; }
    const String& uriList() const { return m_uriList; }
    const Vector<String>& filenames() const { return m_filenames; }
    GdkPixbuf* image() const { return m_image.get(); }
    void setRange(PassRefPtr<Range> newRange) { m_range = newRange; }
    void setImage(GdkPixbuf* newImage) { m_image = newImage; }
    void setURL(const URL&, const String&);
    bool hasText() const { return m_range || !m_text.isEmpty(); }
    bool hasMarkup() const { return m_range || !m_markup.isEmpty(); }
    bool hasURIList() const { return !m_uriList.isEmpty(); }

    bool hasFilenames() const { return !m_filenames.isEmpty(); }
    bool hasImage() const { return m_image; }
    void clearURIList() { m_uriList = ""; }
    void clearURL() { m_url = URL(); }
    void clearImage() { m_image = 0; }

    String text() const;

private:
    String m_text;
    String m_markup;
    URL m_url;
    String m_uriList;
    Vector<String> m_filenames;
    GRefPtr<GdkPixbuf> m_image;

Lines 80-86 String DragData::asURL(Frame, FilenameConversionPolicy filenamePolicy, String a/Source/WebCore/platform/gtk/DragDataGtk.cpp_sec1
- a/Source/WebCore/platform/gtk/DragDataGtk.cpp -1 / +1 lines
80	if (!m_platformDragData->hasURL())	80	if (!m_platformDragData->hasURL())
81	return String();	81	return String();
82	if (filenamePolicy != ConvertFilenames) {	82	if (filenamePolicy != ConvertFilenames) {
83	KURL url(KURL(), m_platformDragData->url());	83	URL url(URL(), m_platformDragData->url());
84	if (url.isLocalFile())	84	if (url.isLocalFile())
85	return String();	85	return String();
86	}	86	}



{
    DocumentLoader* documentLoader = printContext->frame()->loader().documentLoader();
    return ResourceError(errorDomainPrint, PrintErrorGeneral,
                         documentLoader ? documentLoader->url() : URL(), errorMessage);
}

ResourceError printerNotFoundError(const PrintContext* printContext)
{
    DocumentLoader* documentLoader = printContext->frame()->loader().documentLoader();
    return ResourceError(errorDomainPrint, PrintErrorPrinterNotFound,
                         documentLoader ? documentLoader->url() : URL(), _("Printer not found"));
}

ResourceError invalidPageRangeToPrint(const PrintContext* printContext)
{
    DocumentLoader* documentLoader = printContext->frame()->loader().documentLoader();
    return ResourceError(errorDomainPrint, PrintErrorInvalidPageRange,
                         documentLoader ? documentLoader->url() : URL(), _("Invalid page range"));
}

} // namespace WebCore



#include "HTMLNames.h"
#include "HTMLParserIdioms.h"
#include "Image.h"
#include "KURL.h"
#include "PasteboardHelper.h"
#include "RenderImage.h"
#include "URL.h"
#include "markup.h"
#include <gtk/gtk.h>


        PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(m_gtkClipboard);
}

static URL getURLForImageNode(Node* node)
{
    // FIXME: Later this code should be shared with Chromium somehow. Chances are all platforms want it.
    AtomicString urlString;

        Element* element = toElement(node);
        urlString = element->imageSourceURL();
    }
    return urlString.isEmpty() ? URL() : node->document().completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
}

void Pasteboard::writeImage(Node* node, const URL&, const String& title)
{
    ASSERT(node);



    m_dataObject->clearAll();

    URL url = getURLForImageNode(node);
    if (!url.isEmpty()) {
        m_dataObject->setURL(url, title);





#include "config.h"

#include "URL.h"
#include "NotImplemented.h"
#include <float.h>
#include <wtf/text/WTFString.h>

    notImplemented();
}

String signedPublicKeyAndChallengeString(unsigned, const String&, const URL&)
{
    return String();
}

Lines 38-44 a/Source/WebCore/platform/ios/PasteboardIOS.mm_sec1
- a/Source/WebCore/platform/ios/PasteboardIOS.mm -1 / +1 lines
38	#import "HTMLElement.h"	38	#import "HTMLElement.h"
39	#import "HTMLNames.h"	39	#import "HTMLNames.h"
40	#import "HTMLParserIdioms.h"	40	#import "HTMLParserIdioms.h"
41	#import "KURL.h"	41	#import "URL.h"
42	#import "LegacyWebArchive.h"	42	#import "LegacyWebArchive.h"
43	#import "Page.h"	43	#import "Page.h"
44	#import "PasteboardStrategy.h"	44	#import "PasteboardStrategy.h"




#import "config.h"
#import "Color.h"
#import "URL.h"
#import "Image.h"
#import "PlatformPasteboard.h"
#import "SoftLinking.h"

    return Color();
}

URL PlatformPasteboard::url()
{
    return URL();
}

long PlatformPasteboard::copy(const String&)



#import "FontSelector.h"
#import "GraphicsContext.h"
#import "Image.h"
#import "URL.h"
#import "ResourceResponse.h"
#import "StringTruncator.h"
#import "TextRun.h"

        drawAtPoint(string, textPoint, font, topColor);
}

DragImageRef createDragImageForLink(URL& url, const String& title, FontRenderingMode)
{
    NSString *label = nsStringNilIfEmpty(title);
    NSURL *cocoaURL = url;



/*
 * Copyright (C) 2004, 2008 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#import "config.h"
#import "KURL.h"

#import "CFURLExtras.h"
#import <wtf/ObjcRuntimeExtras.h>
#import <wtf/text/CString.h>

namespace WebCore {

KURL::KURL(NSURL *url)
{
    if (!url) {
        invalidate();
        return;
    }

    // FIXME: Why is it OK to ignore base URL here?
    CString urlBytes;
    getURLBytes(reinterpret_cast<CFURLRef>(url), urlBytes);
    parse(urlBytes.data());
}

KURL::operator NSURL *() const
{
    // Creating a toll-free bridged CFURL, because a real NSURL would not preserve the original string.
    // We'll need fidelity when round-tripping via CFURLGetBytes().
    return CFBridgingRelease(createCFURL().leakRef());
}

RetainPtr<CFURLRef> KURL::createCFURL() const
{
    if (isNull())
        return 0;

    if (isEmpty()) {
        // We use the toll-free bridge between NSURL and CFURL to create a CFURLRef supporting both empty and null values.
        return reinterpret_cast<CFURLRef>(adoptNS([[NSURL alloc] initWithString:@""]).get());
    }

    URLCharBuffer buffer;
    copyToBuffer(buffer);
    return createCFURLFromBuffer(buffer.data(), buffer.size());
}



}



#import "htmlediting.h"
#import "HTMLNames.h"
#import "Image.h"
#import "URL.h"
#import "LegacyWebArchive.h"
#import "LoaderNSURLExtras.h"
#import "MIMETypeRegistry.h"

    }

    if (types.contains(String(NSURLPboardType))) {
        URL url = strategy.url(m_pasteboardName);
        String title = strategy.stringForType(WebURLNamePboardType, m_pasteboardName);
        if (!url.isNull() && reader.readURL(url, title))
            return;




#import "config.h"
#import "Color.h"
#import "URL.h"
#import "PlatformPasteboard.h"

namespace WebCore {

                    (int)([color blueComponent] * 255.0 + 0.5), (int)([color alphaComponent] * 255.0 + 0.5));    
}

URL PlatformPasteboard::url()
{
    return [NSURL URLFromPasteboard:m_pasteboard.get()];
}



#include "config.h"
#include "SSLKeyGenerator.h"

#include "URL.h"
#include "LocalizedStrings.h"
#include "WebCoreSystemInterface.h"
#include <wtf/RetainPtr.h>

    supportedKeySizes.append(keygenMenuItem512());
}

String signedPublicKeyAndChallengeString(unsigned keySizeIndex, const String& challengeString, const URL& url)
{   
    // This switch statement must always be synced with the UI strings returned by getSupportedKeySizes.
    UInt32 keySize;




#if ENABLE(MEDIA_STREAM)

#include "URL.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/Vector.h>


class RTCIceServer : public RefCounted<RTCIceServer> {
public:
    static PassRefPtr<RTCIceServer> create(const URL& uri, const String& credential, const String& username)
    {
        return adoptRef(new RTCIceServer(uri, credential, username));
    }
    virtual ~RTCIceServer() { }

    const URL& uri() { return m_uri; }
    const String& credential() { return m_credential; }
    const String& username() { return m_username; }

private:
    RTCIceServer(const URL& uri, const String& credential, const String& username)
        : m_uri(uri)
        , m_credential(credential)
        , m_username(username)
    {
    }

    URL m_uri;
    String m_credential;
    String m_username;
};



    m_items.append(BlobDataItem(path, offset, length, expectedModificationTime));
}

void BlobData::appendBlob(const URL& url, long long offset, long long length)
{
    m_items.append(BlobDataItem(url, offset, length));
}

#if ENABLE(FILE_SYSTEM)
void BlobData::appendURL(const URL& url, long long offset, long long length, double expectedModificationTime)
{
    m_items.append(BlobDataItem(url, offset, length, expectedModificationTime));
}



#define BlobData_h

#include "FileSystem.h"
#include "URL.h"
#include <wtf/Forward.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/ThreadSafeRefCounted.h>

    }

    // Constructor for Blob type.
    BlobDataItem(const URL& url, long long offset, long long length)
        : type(Blob)
        , url(url)
        , offset(offset)


#if ENABLE(FILE_SYSTEM)
    // Constructor for URL type (e.g. FileSystem files).
    BlobDataItem(const URL& url, long long offset, long long length, double expectedModificationTime)
        : type(URL)
        , url(url)
        , offset(offset)

    String path;

    // For Blob or URL type.
    URL url;

    long long offset;
    long long length;

    void appendData(PassRefPtr<RawData>, long long offset, long long length);
    void appendFile(const String& path);
    void appendFile(const String& path, long long offset, long long length, double expectedModificationTime);
    void appendBlob(const URL&, long long offset, long long length);
#if ENABLE(FILE_SYSTEM)
    void appendURL(const URL&, long long offset, long long length, double expectedModificationTime);
#endif

private:


private:
    BlobDataHandle(PassOwnPtr<BlobData>, long long size);
    URL m_internalURL;
};

} // namespace WebCore



class BlobData;
class BlobStorageData;
class BlobRegistry;
class URL;

BlobRegistry& blobRegistry();


class BlobRegistry {
public:
    // Registers a blob URL referring to the specified blob data.
    virtual void registerBlobURL(const URL&, PassOwnPtr<BlobData>) = 0;
    
    // Registers a new blob URL referring to the blob data identified by the specified srcURL.
    virtual void registerBlobURL(const URL&, const URL& srcURL) = 0;

    virtual void unregisterBlobURL(const URL&) = 0;

    virtual bool isBlobRegistryImpl() const { return false; }




    }
}

void BlobRegistryImpl::registerBlobURL(const URL& url, PassOwnPtr<BlobData> blobData)
{
    ASSERT(isMainThread());
    registerBlobResourceHandleConstructor();

    m_blobs.set(url.string(), blobStorageData);
}

void BlobRegistryImpl::registerBlobURL(const URL& url, const URL& srcURL)
{
    ASSERT(isMainThread());
    registerBlobResourceHandleConstructor();

    m_blobs.set(url.string(), src);
}

void BlobRegistryImpl::unregisterBlobURL(const URL& url)
{
    ASSERT(isMainThread());
    m_blobs.remove(url.string());
}

BlobStorageData* BlobRegistryImpl::getBlobDataFromURL(const URL& url) const
{
    ASSERT(isMainThread());
    return m_blobs.get(url.string());




namespace WebCore {

class URL;
class ResourceHandle;
class ResourceHandleClient;
class ResourceRequest;

public:
    virtual ~BlobRegistryImpl();

    BlobStorageData* getBlobDataFromURL(const URL&) const;

    PassRefPtr<ResourceHandle> createResourceHandle(const ResourceRequest&, ResourceHandleClient*);


    void appendStorageItems(BlobStorageData*, const BlobDataItemList&);
    void appendStorageItems(BlobStorageData*, const BlobDataItemList&, long long offset, long long length);

    virtual void registerBlobURL(const URL&, PassOwnPtr<BlobData>) OVERRIDE;
    virtual void registerBlobURL(const URL&, const URL& srcURL) OVERRIDE;
    virtual void unregisterBlobURL(const URL&) OVERRIDE;
    virtual bool isBlobRegistryImpl() const OVERRIDE { return true; }

    HashMap<String, RefPtr<BlobStorageData> > m_blobs;

Lines 39-45 a/Source/WebCore/platform/network/BlobResourceHandle.cpp_sec1
- a/Source/WebCore/platform/network/BlobResourceHandle.cpp -1 / +1 lines
39	#include "FileStream.h"	39	#include "FileStream.h"
40	#include "FileSystem.h"	40	#include "FileSystem.h"
41	#include "HTTPParsers.h"	41	#include "HTTPParsers.h"
42	#include "KURL.h"	42	#include "URL.h"
43	#include "ResourceError.h"	43	#include "ResourceError.h"
44	#include "ResourceHandleClient.h"	44	#include "ResourceHandleClient.h"
45	#include "ResourceRequest.h"	45	#include "ResourceRequest.h"



#include "CredentialStorage.h"

#include "Credential.h"
#include "URL.h"
#include "ProtectionSpaceHash.h"
#include <wtf/text/WTFString.h>
#include <wtf/text/StringHash.h>

    return map;
}

static String originStringFromURL(const URL& url)
{
    if (url.port())
        return url.protocol() + "://" + url.host() + ':' + String::number(url.port()) + '/';

    return url.protocol() + "://" + url.host() + '/';
}

static String protectionSpaceMapKeyFromURL(const URL& url)
{
    ASSERT(url.isValid());


    return directoryURL;
}

void CredentialStorage::set(const Credential& credential, const ProtectionSpace& protectionSpace, const URL& url)
{
    ASSERT(protectionSpace.isProxy() || url.protocolIsInHTTPFamily());
    ASSERT(protectionSpace.isProxy() || url.isValid());

    protectionSpaceToCredentialMap().remove(protectionSpace);
}

static PathToDefaultProtectionSpaceMap::iterator findDefaultProtectionSpaceForURL(const URL& url)
{
    ASSERT(url.protocolIsInHTTPFamily());
    ASSERT(url.isValid());

    }
}

bool CredentialStorage::set(const Credential& credential, const URL& url)
{
    ASSERT(url.protocolIsInHTTPFamily());
    ASSERT(url.isValid());

    return true;
}

Credential CredentialStorage::get(const URL& url)
{
    PathToDefaultProtectionSpaceMap::iterator iter = findDefaultProtectionSpaceForURL(url);
    if (iter == pathToDefaultProtectionSpaceMap().end())



namespace WebCore {

class Credential;
class URL;
class ProtectionSpace;

class CredentialStorage {
public:
    // WebCore session credential storage.
    static void set(const Credential&, const ProtectionSpace&, const URL&);
    static Credential get(const ProtectionSpace&);
    static void remove(const ProtectionSpace&);



    // These methods work for authentication schemes that support sending credentials without waiting for a request. E.g., for HTTP Basic authentication scheme
    // a client should assume that all paths at or deeper than the depth of a known protected resource share are within the same protection space.
    static bool set(const Credential&, const URL&); // Returns true if the URL corresponds to a known protection space, so credentials could be updated.
    static Credential get(const URL&);

    static void setPrivateMode(bool);
};



    m_elements.append(FormDataElement(filename, start, length, expectedModificationTime, shouldGenerateFile));
}

void FormData::appendBlob(const URL& blobURL)
{
    m_elements.append(FormDataElement(blobURL));
}
#endif
#if ENABLE(FILE_SYSTEM)
void FormData::appendURL(const URL& url)
{
    m_elements.append(FormDataElement(url, 0, BlobDataItem::toEndOfFile, invalidFileTime()));
}

void FormData::appendURLRange(const URL& url, long long start, long long length, double expectedModificationTime)
{
    m_elements.append(FormDataElement(url, start, length, expectedModificationTime));
}

}

#if ENABLE(BLOB)
static void appendBlobResolved(FormData* formData, const URL& url)
{
    if (!blobRegistry().isBlobRegistryImpl()) {
        LOG_ERROR("Tried to resolve a blob without a usable registry");
        return;
    }
    BlobStorageData* blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromURL(URL(ParsedURLString, url));
    if (!blobData) {
        LOG_ERROR("Could not get blob data from a registry");
        return;


#if ENABLE(FILE_SYSTEM)
        if (type == FormDataElement::encodedURL)
            element.m_url = URL(URL(), filenameOrURL);
        else
#endif
        element.m_filename = filenameOrURL;

        String blobURLString;
        if (!decoder.decodeString(blobURLString))
            return false;
        element.m_url = URL(URL(), blobURLString);
        return true;
#endif




#ifndef FormData_h
#define FormData_h

#include "URL.h"
#include <wtf/Forward.h>
#include <wtf/RefCounted.h>
#include <wtf/Vector.h>


#if ENABLE(BLOB)
    FormDataElement(const String& filename, long long fileStart, long long fileLength, double expectedFileModificationTime, bool shouldGenerateFile) : m_type(encodedFile), m_filename(filename), m_fileStart(fileStart), m_fileLength(fileLength), m_expectedFileModificationTime(expectedFileModificationTime), m_shouldGenerateFile(shouldGenerateFile) { }
    explicit FormDataElement(const URL& blobURL) : m_type(encodedBlob), m_url(blobURL) { }
#else
    FormDataElement(const String& filename, bool shouldGenerateFile) : m_type(encodedFile), m_filename(filename), m_shouldGenerateFile(shouldGenerateFile) { }
#endif
#if ENABLE(FILE_SYSTEM)
    FormDataElement(const URL& url, long long start, long long length, double expectedFileModificationTime) : m_type(encodedURL), m_url(url), m_fileStart(start), m_fileLength(length), m_expectedFileModificationTime(expectedFileModificationTime), m_shouldGenerateFile(false) { }
#endif

    enum Type {

    Vector<char> m_data;
    String m_filename;
#if ENABLE(BLOB)
    URL m_url; // For Blob or URL.
    long long m_fileStart;
    long long m_fileLength;
    double m_expectedFileModificationTime;

    void appendFile(const String& filePath, bool shouldGenerateFile = false);
#if ENABLE(BLOB)
    void appendFileRange(const String& filename, long long start, long long length, double expectedModificationTime, bool shouldGenerateFile = false);
    void appendBlob(const URL& blobURL);
#endif
#if ENABLE(FILE_SYSTEM)
    void appendURL(const URL&);
    void appendURLRange(const URL&, long long start, long long length, double expectedModificationTime);
#endif
    char* expandDataStore(size_t);





namespace WebCore {

class URL;
class NetworkStorageSession;
struct Cookie;

// FIXME: These should probably be NetworkStorageSession member functions.

String cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&);
void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String&);
bool cookiesEnabled(const NetworkStorageSession&, const URL& firstParty, const URL&);
String cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&);
bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>&);
void deleteCookie(const NetworkStorageSession&, const URL&, const String&);
void getHostnamesWithCookies(const NetworkStorageSession&, HashSet<String>& hostnames);
void deleteCookiesForHostname(const NetworkStorageSession&, const String& hostname);
void deleteAllCookies(const NetworkStorageSession&);




namespace WebCore {

class URL;
class NetworkingContext;

// Represents a single proxy server.

};

// Return a vector of proxy servers for the given URL.
Vector<ProxyServer> proxyServersForURL(const URL&, const NetworkingContext*);

// Converts the given vector of proxy servers to a PAC string, as described in
// http://web.archive.org/web/20060424005037/wp.netscape.com/eng/mozilla/2.0/relnotes/demo/proxy-live.html

Lines 205-211 bool ResourceHandle::shouldContentSniff() const a/Source/WebCore/platform/network/ResourceHandle.cpp_sec1
- a/Source/WebCore/platform/network/ResourceHandle.cpp -1 / +1 lines
205	return d->m_shouldContentSniff;	205	return d->m_shouldContentSniff;
206	}	206	}
207		207
208	bool ResourceHandle::shouldContentSniffURL(const KURL& url)	208	bool ResourceHandle::shouldContentSniffURL(const URL& url)
209	{	209	{
210	#if PLATFORM(MAC)	210	#if PLATFORM(MAC)
211	if (shouldForceContentSniffing)	211	if (shouldForceContentSniffing)



class AuthenticationChallenge;
class Credential;
class Frame;
class URL;
class NetworkingContext;
class ProtectionSpace;
class ResourceError;

#endif

    bool shouldContentSniff() const;
    static bool shouldContentSniffURL(const URL&);

    static void forceContentSniffing();


Lines 41-47 OBJC_CLASS NSCachedURLResponse; a/Source/WebCore/platform/network/ResourceHandleClient.h_sec1
- a/Source/WebCore/platform/network/ResourceHandleClient.h -1 / +1 lines
41	namespace WebCore {	41	namespace WebCore {
42	class AuthenticationChallenge;	42	class AuthenticationChallenge;
43	class Credential;	43	class Credential;
44	class KURL;	44	class URL;
45	class ProtectionSpace;	45	class ProtectionSpace;
46	class ResourceHandle;	46	class ResourceHandle;
47	class ResourceError;	47	class ResourceError;

Lines 130-136 namespace WebCore { a/Source/WebCore/platform/network/ResourceHandleInternal.h_sec1
- a/Source/WebCore/platform/network/ResourceHandleInternal.h -1 / +1 lines
130	, m_scheduledFailureType(ResourceHandle::NoFailure)	130	, m_scheduledFailureType(ResourceHandle::NoFailure)
131	, m_failureTimer(loader, &ResourceHandle::fireFailure)	131	, m_failureTimer(loader, &ResourceHandle::fireFailure)
132	{	132	{
133	const KURL& url = m_firstRequest.url();	133	const URL& url = m_firstRequest.url();
134	m_user = url.user();	134	m_user = url.user();
135	m_pass = url.pass();	135	m_pass = url.pass();
136	m_firstRequest.removeCredentials();	136	m_firstRequest.removeCredentials();



    return m_url.isNull();
}

const URL& ResourceRequestBase::url() const 
{
    updateResourceRequest(); 
    
    return m_url;
}

void ResourceRequestBase::setURL(const URL& url)
{ 
    updateResourceRequest(); 


        m_platformRequestUpdated = false;
}

const URL& ResourceRequestBase::firstPartyForCookies() const
{
    updateResourceRequest(); 
    
    return m_firstPartyForCookies;
}

void ResourceRequestBase::setFirstPartyForCookies(const URL& firstPartyForCookies)
{ 
    updateResourceRequest(); 





#include "FormData.h"
#include "HTTPHeaderMap.h"
#include "URL.h"
#include "ResourceLoadPriority.h"

#include <wtf/OwnPtr.h>

        bool isNull() const;
        bool isEmpty() const;

        const URL& url() const;
        void setURL(const URL& url);

        void removeCredentials();


        double timeoutInterval() const; // May return 0 when using platform default.
        void setTimeoutInterval(double timeoutInterval);
        
        const URL& firstPartyForCookies() const;
        void setFirstPartyForCookies(const URL& firstPartyForCookies);
        
        const String& httpMethod() const;
        void setHTTPMethod(const String& httpMethod);

        {
        }

        ResourceRequestBase(const URL& url, ResourceRequestCachePolicy policy)
            : m_url(url)
            , m_cachePolicy(policy)
            , m_timeoutInterval(s_defaultTimeoutInterval)

        // The ResourceRequest subclass may "shadow" this method to compare platform specific fields
        static bool platformCompare(const ResourceRequest&, const ResourceRequest&) { return true; }

        URL m_url;

        ResourceRequestCachePolicy m_cachePolicy;
        double m_timeoutInterval; // 0 is a magic value for platform default on platforms that have one.
        URL m_firstPartyForCookies;
        String m_httpMethod;
        HTTPHeaderMap m_httpHeaderFields;
        Vector<String> m_responseContentDispositionEncodingFallbackArray;

        WTF_MAKE_NONCOPYABLE(CrossThreadResourceRequestDataBase); WTF_MAKE_FAST_ALLOCATED;
    public:
        CrossThreadResourceRequestDataBase() { }
        URL m_url;

        ResourceRequestCachePolicy m_cachePolicy;
        double m_timeoutInterval;
        URL m_firstPartyForCookies;

        String m_httpMethod;
        OwnPtr<CrossThreadHTTPHeaderMapData> m_httpHeaders;



{
}

ResourceResponseBase::ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
    : m_url(url)
    , m_mimeType(mimeType)
    , m_expectedContentLength(expectedLength)

    return equalIgnoringCase(protocol, "http")  || equalIgnoringCase(protocol, "https");
}

const URL& ResourceResponseBase::url() const
{
    lazyInit(CommonFieldsOnly);

    return m_url; 
}

void ResourceResponseBase::setURL(const URL& url)
{
    lazyInit(CommonFieldsOnly);
    m_isNull = false;



#define ResourceResponseBase_h

#include "HTTPHeaderMap.h"
#include "URL.h"
#include "ResourceLoadTiming.h"

#include <wtf/PassOwnPtr.h>

    bool isNull() const { return m_isNull; }
    bool isHTTP() const;

    const URL& url() const;
    void setURL(const URL& url);

    const String& mimeType() const;
    void setMimeType(const String& mimeType);

    };

    ResourceResponseBase();
    ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename);

    void lazyInit(InitLevel) const;


    // The ResourceResponse subclass may "shadow" this method to compare platform specific fields
    static bool platformCompare(const ResourceResponse&, const ResourceResponse&) { return true; }

    URL m_url;
    String m_mimeType;
    long long m_expectedContentLength;
    String m_textEncodingName;

    WTF_MAKE_NONCOPYABLE(CrossThreadResourceResponseDataBase); WTF_MAKE_FAST_ALLOCATED;
public:
    CrossThreadResourceResponseDataBase() { }
    URL m_url;
    String m_mimeType;
    long long m_expectedContentLength;
    String m_textEncodingName;

Lines 38-44 namespace WebCore { a/Source/WebCore/platform/network/SocketStreamHandleBase.cpp_sec1
- a/Source/WebCore/platform/network/SocketStreamHandleBase.cpp -1 / +1 lines
38		38
39	const unsigned int bufferSize = 100 * 1024 * 1024;	39	const unsigned int bufferSize = 100 * 1024 * 1024;
40		40
41	SocketStreamHandleBase::SocketStreamHandleBase(const KURL& url, SocketStreamHandleClient* client)	41	SocketStreamHandleBase::SocketStreamHandleBase(const URL& url, SocketStreamHandleClient* client)
42	: m_url(url)	42	: m_url(url)
43	, m_client(client)	43	, m_client(client)
44	, m_state(Connecting)	44	, m_state(Connecting)



#ifndef SocketStreamHandleBase_h
#define SocketStreamHandleBase_h

#include "URL.h"

#include <wtf/StreamBuffer.h>


        void setClient(SocketStreamHandleClient*);

    protected:
        SocketStreamHandleBase(const URL&, SocketStreamHandleClient*);

        bool sendPendingData();
        virtual int platformSend(const char* data, int length) = 0;
        virtual void platformClose() = 0;

        URL m_url;
        SocketStreamHandleClient* m_client;
        StreamBuffer<char, 1024 * 1024> m_buffer;
        SocketStreamState m_state;

Lines 35-41 a/Source/WebCore/platform/network/SocketStreamHandleClient.h_sec1
- a/Source/WebCore/platform/network/SocketStreamHandleClient.h -1 / +1 lines
35	namespace WebCore {	35	namespace WebCore {
36		36
37	class AuthenticationChallenge;	37	class AuthenticationChallenge;
38	class KURL;	38	class URL;
39	class SocketStreamError;	39	class SocketStreamError;
40	class SocketStreamHandle;	40	class SocketStreamHandle;
41		41




namespace WebCore {

void setCookiesFromDOM(const NetworkStorageSession&, const URL& /*firstParty*/, const URL& url, const String& value)
{
    cookieManager().setCookies(url, value, NoHttpOnlyCookie);
}

String cookiesForDOM(const NetworkStorageSession&, const URL& /*firstParty*/, const URL& url)
{
    // 'HttpOnly' cookies should no be accessible from scripts, so we filter them out here.
    return cookieManager().getCookie(url, NoHttpOnlyCookie);
}

String cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& /*firstParty*/, const URL& url)
{
    return cookieManager().getCookie(url, WithHttpOnlyCookies);
}

bool cookiesEnabled(const NetworkStorageSession&, const URL& /*firstParty*/, const URL& /*url*/)
{
    return !cookieManager().cookieJar().isEmpty();
}

bool getRawCookies(const NetworkStorageSession&, const URL& /*firstParty*/, const URL& url, Vector<Cookie>& rawCookies)
{
    Vector<RefPtr<ParsedCookie> > result;
    cookieManager().getRawCookies(result, url, WithHttpOnlyCookies);

    return true;
}

void deleteCookie(const NetworkStorageSession&, const URL& url, const String& name)
{
    cookieManager().removeCookieWithName(url, name);
}

Lines 22-28 a/Source/WebCore/platform/network/blackberry/CredentialBackingStore.cpp_sec1
- a/Source/WebCore/platform/network/blackberry/CredentialBackingStore.cpp -1 / +1 lines
22	#if ENABLE(BLACKBERRY_CREDENTIAL_PERSIST)	22	#if ENABLE(BLACKBERRY_CREDENTIAL_PERSIST)
23	#include "CredentialStorage.h"	23	#include "CredentialStorage.h"
24	#include "FileSystem.h"	24	#include "FileSystem.h"
25	#include "KURL.h"	25	#include "URL.h"
26	#include "ProtectionSpaceHash.h"	26	#include "ProtectionSpaceHash.h"
27	#include "SQLiteStatement.h"	27	#include "SQLiteStatement.h"
28	#include <BlackBerryPlatformEncryptor.h>	28	#include <BlackBerryPlatformEncryptor.h>



#include "Frame.h"
#include "FrameLoaderClientBlackBerry.h"
#include "HTTPParsers.h"
#include "URL.h"
#include "MIMESniffing.h"
#include "MIMETypeRegistry.h"
#include "NetworkManager.h"


void NetworkJob::initialize(int playerId,
    const String& pageGroupName,
    const URL& url,
    const BlackBerry::Platform::NetworkRequest& request,
    PassRefPtr<ResourceHandle> handle,
    BlackBerry::Platform::NetworkStreamFactory* streamFactory,


void NetworkJob::handleSetCookieHeader(const String& value)
{
    URL url = m_response.url();
    CookieManager& manager = cookieManager();
    if ((manager.cookiePolicy() == CookieStorageAcceptPolicyOnlyFromMainDocumentDomain)
        && (m_handle->firstRequest().firstPartyForCookies() != url)


    ASSERT(m_handle);
    ResourceRequest newRequest = m_handle->firstRequest();
    URL url = newRequest.url();
    url.setPath(url.path() + "/");
    newRequest.setURL(url);
    newRequest.setMustHandleInternally(true);

    if (location.isNull())
        return false;

    URL newURL(m_response.url(), location);
    if (!newURL.isValid())
        return false;


    if (!m_handle)
        return SendRequestCancelled;

    URL newURL = m_response.url();
    if (!newURL.isValid())
        return SendRequestCancelled;


            host = m_response.url().host();
            port = m_response.url().port();
        } else {
            // proxyInfo returns host:port, without a protocol. URL can't parse this, so stick http
            // on the front.
            // (We could split into host and port by hand, but that gets hard to parse with IPv6 urls,
            // so better to reuse URL's parsing.)
            StringBuilder proxyAddress;
            if (type == ProtectionSpaceProxyHTTP)
                proxyAddress.append("http://");

                proxyAddress.append("https://");
            proxyAddress.append(proxyInfo.address);

            URL proxyURL(URL(), proxyAddress.toString());
            host = proxyURL.host();
            port = proxyURL.port();
        }

    NetworkManager::instance()->deleteJob(this);
}

void NetworkJob::notifyChallengeResult(const URL& url, const ProtectionSpace& protectionSpace, AuthenticationChallengeResult result, const Credential& credential)
{
    ASSERT(url.isValid());
    ASSERT(url == m_response.url());




class Credential;
class Frame;
class URL;
class ProtectionSpace;
class ResourceRequest;



    void initialize(int playerId,
        const String& pageGroupName,
        const URL&,
        const BlackBerry::Platform::NetworkRequest&,
        PassRefPtr<ResourceHandle>,
        BlackBerry::Platform::NetworkStreamFactory*,

    virtual int status() const { return m_extendedStatusCode; }
    virtual const BlackBerry::Platform::String mimeType() const;

    virtual void notifyChallengeResult(const URL&, const ProtectionSpace&, AuthenticationChallengeResult, const Credential&);

    // Implementation of FrameDestructionObserver pure virtuals.
    virtual void frameDestroyed();



    // Make sure the ResourceHandle doesn't go out of scope while calling callbacks.
    RefPtr<ResourceHandle> guardJob(job);

    URL url = request.url();

    // Only load the initial url once.
    bool isInitial = (url == m_initialURL);
    if (isInitial)
        m_initialURL = URL();

    // Always reread cookies on a redirect
    if (redirectCount)

    BlackBerry::Platform::NetworkRequest platformRequest;
    request.initializePlatformRequest(platformRequest, frame->loader() && frame->loader()->client() && static_cast<FrameLoaderClientBlackBerry*>(frame->loader()->client())->cookiesEnabled(), isInitial, rereadCookies);

    // GURL and URL consider valid URLs differently, for example http:// is parsed as
    // http:/ by URL and considered valid, while GURL considers it invalid.
    if (!platformRequest.url().is_valid())
        return BlackBerry::Platform::FilterStream::StatusErrorInvalidUrl;




#ifndef NetworkManager_h
#define NetworkManager_h

#include "URL.h"
#include "ResourceHandle.h"

#include <BlackBerryPlatformSingleton.h>

class NetworkManager : public BlackBerry::Platform::ThreadUnsafeSingleton<NetworkManager> {
    SINGLETON_DEFINITION_THREADUNSAFE(NetworkManager)
public:
    void setInitialURL(const URL& url) { m_initialURL = url; }
    URL initialURL() { return m_initialURL; }
    int startJob(int playerId, PassRefPtr<ResourceHandle> job, Frame*, bool defersLoading);
    int startJob(int playerId, PassRefPtr<ResourceHandle> job, const ResourceRequest&, Frame*, bool defersLoading);
    bool stopJob(PassRefPtr<ResourceHandle>);

    int startJob(int playerId, const String& pageGroupName, PassRefPtr<ResourceHandle>, const ResourceRequest&, BlackBerry::Platform::NetworkStreamFactory*, Frame*, int deferLoadingCount = 0, int redirectCount = 0, bool rereadCookies = false);

    Vector<NetworkJob*> m_jobs;
    URL m_initialURL;
};

} // namespace WebCore



#include "config.h"
#include "ProxyServer.h"

#include "URL.h"
#include "NotImplemented.h"

namespace WebCore {

Vector<ProxyServer> proxyServersForURL(const URL&, const NetworkingContext*)
{
    notImplemented();
    return Vector<ProxyServer>();



        TargetIsUnspecified,
    };
    ResourceRequest(const String& url)
        : ResourceRequestBase(URL(ParsedURLString, url), UseProtocolCachePolicy)
        , m_isXMLHTTPRequest(false)
        , m_mustHandleInternally(false)
        , m_forceDownload(false)

    {
    }

    ResourceRequest(const URL& url)
        : ResourceRequestBase(url, UseProtocolCachePolicy)
        , m_isXMLHTTPRequest(false)
        , m_mustHandleInternally(false)

    {
    }

    ResourceRequest(const URL& url, const String& referrer, ResourceRequestCachePolicy policy = UseProtocolCachePolicy)
        : ResourceRequestBase(url, policy)
        , m_isXMLHTTPRequest(false)
        , m_mustHandleInternally(false)

    }

    ResourceRequest()
        : ResourceRequestBase(URL(), UseProtocolCachePolicy)
        , m_isXMLHTTPRequest(false)
        , m_mustHandleInternally(false)
        , m_forceDownload(false)

Lines 30-36 public: a/Source/WebCore/platform/network/blackberry/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/blackberry/ResourceResponse.h -1 / +1 lines
30	{	30	{
31	}	31	}
32		32
33	ResourceResponse(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)	33	ResourceResponse(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
34	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)	34	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)
35	, m_isMultipartPayload(false)	35	, m_isMultipartPayload(false)
36	{	36	{




class SocketStreamHandle : public RefCounted<SocketStreamHandle>, public BlackBerry::Platform::FilterStream, public SocketStreamHandleBase {
public:
    static PassRefPtr<SocketStreamHandle> create(const String& groupName, const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(groupName, url, client)); }

    virtual ~SocketStreamHandle();


    virtual void platformClose();

private:
    SocketStreamHandle(const String& groupName, const URL&, SocketStreamHandleClient*);

    OwnPtr<BlackBerry::Platform::FilterStream> m_socketStream;
    int m_status;




#include "Chrome.h"
#include "FrameLoaderClientBlackBerry.h"
#include "URL.h"
#include "Logging.h"
#include "Page.h"
#include "PageClientBlackBerry.h"


namespace WebCore {

SocketStreamHandle::SocketStreamHandle(const String& groupName, const URL& url, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(url, client)
{
    LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);

Lines 63-69 RSSAtomParser::RSSAtomParser() a/Source/WebCore/platform/network/blackberry/rss/RSSAtomParser.cpp_sec1
- a/Source/WebCore/platform/network/blackberry/rss/RSSAtomParser.cpp -1 / +1 lines
63		63
64	bool RSSAtomParser::parseBuffer(const char* buffer, int length, const char* url, const char* encoding)	64	bool RSSAtomParser::parseBuffer(const char* buffer, int length, const char* url, const char* encoding)
65	{	65	{
66	m_url = KURL(blankURL(), url);	66	m_url = URL(blankURL(), url);
67	return parseXmlDoc(xmlReadMemory(buffer, length, url, encoding, XML_PARSE_NOBLANKS \| XML_PARSE_NONET));	67	return parseXmlDoc(xmlReadMemory(buffer, length, url, encoding, XML_PARSE_NOBLANKS \| XML_PARSE_NONET));
68	}	68	}
69		69



#ifndef RSSAtomParser_h
#define RSSAtomParser_h

#include "URL.h"
#include "RSSParserBase.h"

namespace WebCore {

    String parseContent(const String& base, xmlNode*);
    String parseAuthor(xmlNode*);
    String parseCategory(xmlNode*);
    URL m_url;
};

} // namespace WebCore



#if USE(CFNETWORK)

#include "Cookie.h"
#include "URL.h"
#include "NetworkStorageSession.h"
#include "SoftLinking.h"
#include <CFNetwork/CFHTTPCookiesPriv.h>

    return filteredCookies;
}

void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
{
    // <rdar://problem/5632883> CFHTTPCookieStorage stores an empty cookie, which would be sent as "Cookie: =".
    if (value.isEmpty())

    CFHTTPCookieStorageSetCookies(session.cookieStorage().get(), filterCookies(cookiesCF.get()).get(), urlCF.get(), firstPartyForCookiesCF.get());
}

String cookiesForDOM(const NetworkStorageSession& session, const URL&, const URL& url)
{
    RetainPtr<CFURLRef> urlCF = url.createCFURL();


    return (CFStringRef)CFDictionaryGetValue(headerCF.get(), s_cookieCF);
}

String cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url)
{
    RetainPtr<CFURLRef> urlCF = url.createCFURL();


    return (CFStringRef)CFDictionaryGetValue(headerCF.get(), s_cookieCF);
}

bool cookiesEnabled(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/)
{
    CFHTTPCookieStorageAcceptPolicy policy = CFHTTPCookieStorageGetCookieAcceptPolicy(session.cookieStorage().get());
    return policy == CFHTTPCookieStorageAcceptPolicyOnlyFromMainDocumentDomain || policy == CFHTTPCookieStorageAcceptPolicyAlways;
}

bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, Vector<Cookie>& rawCookies)
{
    rawCookies.clear();


    return true;
}

void deleteCookie(const NetworkStorageSession& session, const URL& url, const String& name)
{
    RetainPtr<CFHTTPCookieStorageRef> cookieStorage = session.cookieStorage();




#include "DNS.h"
#include "DNSResolveQueue.h"

#include "URL.h"
#include "Timer.h"
#include <wtf/HashSet.h>
#include <wtf/MainThread.h>

    if (!proxySettings)
        return false;

    RetainPtr<CFURLRef> httpCFURL = URL(ParsedURLString, "http://example.com/").createCFURL();
    RetainPtr<CFURLRef> httpsCFURL = URL(ParsedURLString, "https://example.com/").createCFURL();

    RetainPtr<CFArrayRef> httpProxyArray = adoptCF(CFNetworkCopyProxiesForURL(httpCFURL.get(), proxySettings.get()));
    RetainPtr<CFArrayRef> httpsProxyArray = adoptCF(CFNetworkCopyProxiesForURL(httpsCFURL.get(), proxySettings.get()));



#include "config.h"
#include "ProxyServer.h"

#include "URL.h"
#include "Logging.h"
#include <wtf/RetainPtr.h>
#include <wtf/text/CString.h>

    }
}

static void addProxyServersForURL(Vector<ProxyServer>& proxyServers, const URL& url)
{
    RetainPtr<CFDictionaryRef> proxySettings = adoptCF(CFNetworkCopySystemProxySettings());
    if (!proxySettings)

    processProxyServers(proxyServers, proxiesForURL.get(), cfURL.get());
}

Vector<ProxyServer> proxyServersForURL(const URL& url, const NetworkingContext*)
{
    Vector<ProxyServer> proxyServers;
    

Lines 28-34 a/Source/WebCore/platform/network/cf/ResourceErrorCF.cpp_sec1
- a/Source/WebCore/platform/network/cf/ResourceErrorCF.cpp -1 / +1 lines
28		28
29	#if USE(CFNETWORK)	29	#if USE(CFNETWORK)
30		30
31	#include "KURL.h"	31	#include "URL.h"
32	#include <CoreFoundation/CFError.h>	32	#include <CoreFoundation/CFError.h>
33	#include <CFNetwork/CFNetworkErrors.h>	33	#include <CFNetwork/CFNetworkErrors.h>
34	#include <wtf/RetainPtr.h>	34	#include <wtf/RetainPtr.h>



{
    if ((!d->m_user.isEmpty() || !d->m_pass.isEmpty()) && !firstRequest().url().protocolIsInHTTPFamily()) {
        // Credentials for ftp can only be passed in URL, the didReceiveAuthenticationChallenge delegate call won't be made.
        URL urlWithCredentials(firstRequest().url());
        urlWithCredentials.setUser(d->m_user);
        urlWithCredentials.setPass(d->m_pass);
        firstRequest().setURL(urlWithCredentials);


void ResourceHandle::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
{
    const URL& url = request.url();
    d->m_user = url.user();
    d->m_pass = url.pass();
    d->m_lastHTTPMethod = request.httpMethod();

    if (!d->m_user.isNull() && !d->m_pass.isNull()) {
        RetainPtr<CFURLCredentialRef> credential = adoptCF(CFURLCredentialCreate(kCFAllocatorDefault, d->m_user.createCFString().get(), d->m_pass.createCFString().get(), 0, kCFURLCredentialPersistenceNone));
        
        URL urlToStore;
        if (challenge.failureResponse().httpStatusCode() == 401)
            urlToStore = challenge.failureResponse().url();
        CredentialStorage::set(core(credential.get()), challenge.protectionSpace(), urlToStore);

        Credential webCredential(credential.user(), credential.password(), CredentialPersistenceNone);
        RetainPtr<CFURLCredentialRef> cfCredential = adoptCF(createCF(webCredential));
        
        URL urlToStore;
        if (challenge.failureResponse().httpStatusCode() == 401)
            urlToStore = challenge.failureResponse().url();      
        CredentialStorage::set(webCredential, challenge.protectionSpace(), urlToStore);



    class ResourceRequest : public ResourceRequestBase {
    public:
        ResourceRequest(const String& url) 
            : ResourceRequestBase(URL(ParsedURLString, url), UseProtocolCachePolicy)
        {
        }

        ResourceRequest(const URL& url) 
            : ResourceRequestBase(url, UseProtocolCachePolicy)
        {
        }

        ResourceRequest(const URL& url, const String& referrer, ResourceRequestCachePolicy policy = UseProtocolCachePolicy) 
            : ResourceRequestBase(url, policy)
        {
            setHTTPReferrer(referrer);
        }
        
        ResourceRequest()
            : ResourceRequestBase(URL(), UseProtocolCachePolicy)
        {
        }
        

Lines 66-72 public: a/Source/WebCore/platform/network/cf/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/cf/ResourceResponse.h -1 / +1 lines
66	}	66	}
67	#endif	67	#endif
68		68
69	ResourceResponse(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)	69	ResourceResponse(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
70	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)	70	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)
71	, m_initLevel(CommonAndUncommonFields)	71	, m_initLevel(CommonAndUncommonFields)
72	, m_platformResponseIsUpToDate(false)	72	, m_platformResponseIsUpToDate(false)




class SocketStreamHandle : public ThreadSafeRefCounted<SocketStreamHandle>, public SocketStreamHandleBase, public AuthenticationClient {
public:
    static PassRefPtr<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(url, client)); }

    virtual ~SocketStreamHandle();


    virtual int platformSend(const char* data, int length);
    virtual void platformClose();

    SocketStreamHandle(const URL&, SocketStreamHandleClient*);
    void createStreams();
    void scheduleStreams();
    void chooseProxy();




namespace WebCore {

SocketStreamHandle::SocketStreamHandle(const URL& url, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(url, client)
    , m_connectingSubstate(New)
    , m_connectionType(Unknown)


    ASSERT(url.protocolIs("ws") || url.protocolIs("wss"));

    URL httpsURL(URL(), "https://" + m_url.host());
    m_httpsURL = httpsURL.createCFURL();

    createStreams();



#include "PlatformCookieJar.h"

#include "Cookie.h"
#include "URL.h"
#include "ResourceHandleManager.h"

#include <wtf/DateMath.h>


}

static String getNetscapeCookieFormat(const URL& url, const String& value)
{
    // Constructs a cookie string in Netscape Cookie file format.


    return cookieStr.toString();
}

void setCookiesFromDOM(const NetworkStorageSession&, const URL&, const URL& url, const String& value)
{
    CURL* curl = curl_easy_init();


    curl_easy_cleanup(curl);
}

static String cookiesForSession(const NetworkStorageSession&, const URL&, const URL& url, bool httponly)
{
    String cookies;
    CURL* curl = curl_easy_init();

    return cookies;
}

String cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return cookiesForSession(session, firstParty, url, false);
}

String cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return cookiesForSession(session, firstParty, url, true);
}

bool cookiesEnabled(const NetworkStorageSession&, const URL& /*firstParty*/, const URL& /*url*/)
{
    return true;
}

bool getRawCookies(const NetworkStorageSession&, const URL& /*firstParty*/, const URL& /*url*/, Vector<Cookie>& rawCookies)
{
    // FIXME: Not yet implemented
    rawCookies.clear();
    return false; // return true when implemented
}

void deleteCookie(const NetworkStorageSession&, const URL&, const String&)
{
    // FIXME: Not yet implemented
}



    moveFileToDestination();
}

void CurlDownload::init(CurlDownloadListener* listener, const URL& url)
{
    if (!listener)
        return;


    MutexLocker locker(m_mutex);

    URL url(ParsedURLString, request.url());

    init(listener, url);


        if (httpCode >= 200 && httpCode < 300) {
            const char* url = 0;
            err = curl_easy_getinfo(m_curlHandle, CURLINFO_EFFECTIVE_URL, &url);
            m_response.setURL(URL(ParsedURLString, url));

            m_response.setMimeType(extractMIMETypeFromMediaType(m_response.httpHeaderField("Content-Type")));
            m_response.setTextEncodingName(extractCharsetFromMediaType(m_response.httpHeaderField("Content-Type")));

Lines 89-95 public: a/Source/WebCore/platform/network/curl/CurlDownload.h_sec1
- a/Source/WebCore/platform/network/curl/CurlDownload.h -1 / +1 lines
89	CurlDownload();	89	CurlDownload();
90	~CurlDownload();	90	~CurlDownload();
91		91
92	void init(CurlDownloadListener*, const WebCore::KURL&);	92	void init(CurlDownloadListener*, const WebCore::URL&);
93	void init(CurlDownloadListener, ResourceHandle, const ResourceRequest&, const ResourceResponse&);	93	void init(CurlDownloadListener, ResourceHandle, const ResourceRequest&, const ResourceResponse&);
94		94
95	bool start();	95	bool start();



#include "config.h"
#include "ProxyServer.h"

#include "URL.h"
#include <wtf/RetainPtr.h>

namespace WebCore {

Vector<ProxyServer> proxyServersForURL(const URL&, const NetworkingContext*)
{
    // FIXME: Implement.
    return Vector<ProxyServer>();

Lines 231-237 void ResourceHandle::receivedCredential(const AuthenticationChallenge& challenge a/Source/WebCore/platform/network/curl/ResourceHandleCurl.cpp_sec1
- a/Source/WebCore/platform/network/curl/ResourceHandleCurl.cpp -1 / +1 lines
231		231
232	if (shouldUseCredentialStorage()) {	232	if (shouldUseCredentialStorage()) {
233	if (challenge.failureResponse().httpStatusCode() == 401) {	233	if (challenge.failureResponse().httpStatusCode() == 401) {
234	KURL urlToStore = challenge.failureResponse().url();	234	URL urlToStore = challenge.failureResponse().url();
235	CredentialStorage::set(credential, challenge.protectionSpace(), urlToStore);	235	CredentialStorage::set(credential, challenge.protectionSpace(), urlToStore);
236	}	236	}
237	}	237	}



     const char* hdr;
     CURLcode err = curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &hdr);
     ASSERT_UNUSED(err, CURLE_OK == err);
     d->m_response.setURL(URL(ParsedURLString, hdr));
     if (d->client())
         d->client()->didReceiveResponse(job, d->m_response);
     d->m_response.setResponseFired(true);

    if (err != CURLE_OK)
        return false;

    URL kurl(ParsedURLString, url);

    String host = kurl.host();
    String protocol = kurl.protocol();


        const char* hdr;
        curl_easy_getinfo(h, CURLINFO_EFFECTIVE_URL, &hdr);
        d->m_response.setURL(URL(ParsedURLString, hdr));

        d->m_response.setHTTPStatusCode(httpCode);
        d->m_response.setMimeType(extractMIMETypeFromMediaType(d->m_response.httpHeaderField("Content-Type")).lower());

        if (isHttpRedirect(httpCode)) {
            String location = d->m_response.httpHeaderField("location");
            if (!location.isEmpty()) {
                URL newURL = URL(job->firstRequest().url(), location);

                ResourceRequest redirectedRequest = job->firstRequest();
                redirectedRequest.setURL(newURL);


void ResourceHandleManager::dispatchSynchronousJob(ResourceHandle* job)
{
    URL kurl = job->firstRequest().url();

    if (kurl.protocolIsData()) {
        handleDataURL(job);


void ResourceHandleManager::startJob(ResourceHandle* job)
{
    URL kurl = job->firstRequest().url();

    if (kurl.protocolIsData()) {
        handleDataURL(job);

void ResourceHandleManager::initializeHandle(ResourceHandle* job)
{
    static const int allowedProtocols = CURLPROTO_FILE | CURLPROTO_FTP | CURLPROTO_FTPS | CURLPROTO_HTTP | CURLPROTO_HTTPS;
    URL kurl = job->firstRequest().url();

    // Remove any fragment part, otherwise curl will send it as part of the request.
    kurl.removeFragmentIdentifier();



    class ResourceRequest : public ResourceRequestBase {
    public:
        ResourceRequest(const String& url)
            : ResourceRequestBase(URL(ParsedURLString, url), UseProtocolCachePolicy)
        {
        }

        ResourceRequest(const URL& url)
            : ResourceRequestBase(url, UseProtocolCachePolicy)
        {
        }

        ResourceRequest(const URL& url, const String& referrer, ResourceRequestCachePolicy policy = UseProtocolCachePolicy)
            : ResourceRequestBase(url, policy)
        {
            setHTTPReferrer(referrer);
        }

        ResourceRequest()
            : ResourceRequestBase(URL(), UseProtocolCachePolicy)
        {
        }


Lines 39-45 public: a/Source/WebCore/platform/network/curl/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/curl/ResourceResponse.h -1 / +1 lines
39	{	39	{
40	}	40	}
41		41
42	ResourceResponse(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)	42	ResourceResponse(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
43	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename),	43	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename),
44	m_responseFired(false)	44	m_responseFired(false)
45	{	45	{




    class SocketStreamHandle : public RefCounted<SocketStreamHandle>, public SocketStreamHandleBase {
    public:
        static PassRefPtr<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(url, client)); }

        virtual ~SocketStreamHandle();


        virtual void platformClose();

    private:
        SocketStreamHandle(const URL&, SocketStreamHandleClient*);

        // No authentication for streams per se, but proxy may ask for credentials.
        void didReceiveAuthenticationChallenge(const AuthenticationChallenge&);



#include "config.h"
#include "SocketStreamHandle.h"

#include "URL.h"
#include "Logging.h"
#include "NotImplemented.h"
#include "SocketStreamHandleClient.h"

namespace WebCore {

SocketStreamHandle::SocketStreamHandle(const URL& url, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(url, client)
{
    LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);



#import "BlockExceptions.h"
#import "Cookie.h"
#import "CookieStorage.h"
#import "URL.h"
#import "NetworkStorageSession.h"
#import "WebCoreSystemInterface.h"


    return filteredCookies;
}

String cookiesForDOM(const NetworkStorageSession& session, const URL&, const URL& url)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;


    return String();
}

String cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;


    return String();
}

void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieStr)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;


    END_BLOCK_OBJC_EXCEPTIONS;
}

bool cookiesEnabled(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;


    return false;
}

bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, Vector<Cookie>& rawCookies)
{
    rawCookies.clear();
    BEGIN_BLOCK_OBJC_EXCEPTIONS;

    return true;
}

void deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;


Lines 27-33 a/Source/WebCore/platform/network/mac/ResourceErrorMac.mm_sec1
- a/Source/WebCore/platform/network/mac/ResourceErrorMac.mm -1 / +1 lines
27	#import "ResourceError.h"	27	#import "ResourceError.h"
28		28
29	#import "BlockExceptions.h"	29	#import "BlockExceptions.h"
30	#import "KURL.h"	30	#import "URL.h"
31	#import <CoreFoundation/CFError.h>	31	#import <CoreFoundation/CFError.h>
32	#import <Foundation/Foundation.h>	32	#import <Foundation/Foundation.h>
33		33



{
    // Credentials for ftp can only be passed in URL, the connection:didReceiveAuthenticationChallenge: delegate call won't be made.
    if ((!d->m_user.isEmpty() || !d->m_pass.isEmpty()) && !firstRequest().url().protocolIsInHTTPFamily()) {
        URL urlWithCredentials(firstRequest().url());
        urlWithCredentials.setUser(d->m_user);
        urlWithCredentials.setPass(d->m_pass);
        firstRequest().setURL(urlWithCredentials);

    if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https") && d->m_context->shouldClearReferrerOnHTTPSToHTTPRedirect())
        request.clearHTTPReferrer();

    const URL& url = request.url();
    d->m_user = url.user();
    d->m_pass = url.pass();
    d->m_lastHTTPMethod = request.httpMethod();

        // to ignore it for a particular request (short of removing it altogether).
        // <rdar://problem/6867598> gallery.me.com is temporarily whitelisted, so that QuickTime plug-in could see the credentials.
        Credential webCredential(credential, CredentialPersistenceNone);
        URL urlToStore;
        if (challenge.failureResponse().httpStatusCode() == 401)
            urlToStore = challenge.failureResponse().url();
        CredentialStorage::set(webCredential, core([d->m_currentMacChallenge protectionSpace]), urlToStore);



#include "CookieJarQt.h"

#include "Cookie.h"
#include "URL.h"
#include "NetworkingContext.h"
#include "PlatformCookieJar.h"
#include "ThirdPartyCookiesQt.h"


static SharedCookieJarQt* s_sharedCookieJarQt = 0;

void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
{
    QNetworkCookieJar* jar = session.context() ? session.context()->networkAccessManager()->cookieJar() : SharedCookieJarQt::shared();
    if (!jar)

    jar->setCookiesFromUrl(cookies, urlForCookies);
}

String cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    QNetworkCookieJar* jar = session.context() ? session.context()->networkAccessManager()->cookieJar() : SharedCookieJarQt::shared();
    if (!jar)

    return resultCookies.join(QLatin1String("; "));
}

String cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url)
{
    QNetworkCookieJar* jar = session.context() ? session.context()->networkAccessManager()->cookieJar() : SharedCookieJarQt::shared();
    if (!jar)

    return resultCookies.join(QLatin1String("; "));
}

bool cookiesEnabled(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/)
{
    QNetworkCookieJar* jar = session.context() ? session.context()->networkAccessManager()->cookieJar() : SharedCookieJarQt::shared();
    return !!jar;
}

bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/, Vector<Cookie>& rawCookies)
{
    // FIXME: Not yet implemented
    rawCookies.clear();
    return false; // return true when implemented
}

void deleteCookie(const NetworkStorageSession&, const URL&, const String&)
{
    // FIXME: Not yet implemented
}



#include "config.h"
#include "ProxyServer.h"

#include "URL.h"
#include "NetworkingContext.h"

#include <QNetworkAccessManager>


namespace WebCore {

Vector<ProxyServer> proxyServersForURL(const URL& url, const NetworkingContext* context)
{
    Vector<ProxyServer> servers;
    

Lines 570-576 void QNetworkReplyHandler::sendResponseIfNeeded() a/Source/WebCore/platform/network/qt/QNetworkReplyHandler.cpp_sec1
- a/Source/WebCore/platform/network/qt/QNetworkReplyHandler.cpp -1 / +1 lines
570	mimeType = MIMETypeRegistry::getMIMETypeForPath(m_replyWrapper->reply()->url().path());	570	mimeType = MIMETypeRegistry::getMIMETypeForPath(m_replyWrapper->reply()->url().path());
571	}	571	}
572		572
573	KURL url(m_replyWrapper->reply()->url());	573	URL url(m_replyWrapper->reply()->url());
574	ResourceResponse response(url, mimeType.lower(),	574	ResourceResponse response(url, mimeType.lower(),
575	m_replyWrapper->reply()->header(QNetworkRequest::ContentLengthHeader).toLongLong(),	575	m_replyWrapper->reply()->header(QNetworkRequest::ContentLengthHeader).toLongLong(),
576	m_replyWrapper->encoding(), String());	576	m_replyWrapper->encoding(), String());



    if (!d->m_user.isEmpty() || !d->m_pass.isEmpty()) {
        // If credentials were specified for this request, add them to the url,
        // so that they will be passed to QNetworkRequest.
        URL urlWithCredentials(firstRequest().url());
        urlWithCredentials.setUser(d->m_user);
        urlWithCredentials.setPass(d->m_pass);
        d->m_firstRequest.setURL(urlWithCredentials);

    if (!d->m_user.isEmpty() || !d->m_pass.isEmpty()) {
        // If credentials were specified for this request, add them to the url,
        // so that they will be passed to QNetworkRequest.
        URL urlWithCredentials(d->m_firstRequest.url());
        urlWithCredentials.setUser(d->m_user);
        urlWithCredentials.setPass(d->m_pass);
        d->m_firstRequest.setURL(urlWithCredentials);



    class ResourceRequest : public ResourceRequestBase {
    public:
        ResourceRequest(const String& url) 
            : ResourceRequestBase(URL(ParsedURLString, url), UseProtocolCachePolicy)
        {
        }

        ResourceRequest(const URL& url) 
            : ResourceRequestBase(url, UseProtocolCachePolicy)
        {
        }

        ResourceRequest(const URL& url, const String& referrer, ResourceRequestCachePolicy policy = UseProtocolCachePolicy) 
            : ResourceRequestBase(url, policy)
        {
            setHTTPReferrer(referrer);
        }

        ResourceRequest()
            : ResourceRequestBase(URL(), UseProtocolCachePolicy)
        {
        }


Lines 36-42 public: a/Source/WebCore/platform/network/qt/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/qt/ResourceResponse.h -1 / +1 lines
36	{	36	{
37	}	37	}
38		38
39	ResourceResponse(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)	39	ResourceResponse(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
40	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)	40	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)
41	{	41	{
42	}	42	}




    class SocketStreamHandle : public RefCounted<SocketStreamHandle>, public SocketStreamHandleBase {
    public:
        static PassRefPtr<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(url, client)); }
        static PassRefPtr<SocketStreamHandle> create(QTcpSocket* socket, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(socket, client)); }

        virtual ~SocketStreamHandle();

        virtual void platformClose();

    private:
        SocketStreamHandle(const URL&, SocketStreamHandleClient*);
        SocketStreamHandle(QTcpSocket*, SocketStreamHandleClient*);

        // No authentication for streams per se, but proxy may ask for credentials.

Lines 46-52 class SocketStreamHandlePrivate; a/Source/WebCore/platform/network/qt/SocketStreamHandlePrivate.h_sec1
- a/Source/WebCore/platform/network/qt/SocketStreamHandlePrivate.h -1 / +1 lines
46	class SocketStreamHandlePrivate : public QObject {	46	class SocketStreamHandlePrivate : public QObject {
47	Q_OBJECT	47	Q_OBJECT
48	public:	48	public:
49	SocketStreamHandlePrivate(SocketStreamHandle*, const KURL&);	49	SocketStreamHandlePrivate(SocketStreamHandle*, const URL&);
50	SocketStreamHandlePrivate(SocketStreamHandle, QTcpSocket);	50	SocketStreamHandlePrivate(SocketStreamHandle, QTcpSocket);
51	~SocketStreamHandlePrivate();	51	~SocketStreamHandlePrivate();
52		52



#include "config.h"
#include "SocketStreamHandle.h"

#include "URL.h"
#include "Logging.h"
#include "NotImplemented.h"
#include "SocketStreamError.h"


namespace WebCore {

SocketStreamHandlePrivate::SocketStreamHandlePrivate(SocketStreamHandle* streamHandle, const URL& url)
{
    m_streamHandle = streamHandle;
    m_socket = 0;

}
#endif

SocketStreamHandle::SocketStreamHandle(const URL& url, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(url, client)
{
    LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);

}

SocketStreamHandle::SocketStreamHandle(QTcpSocket* socket, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(URL(), client)
{
    LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);
    m_p = new SocketStreamHandlePrivate(this, socket);




#include "Cookie.h"
#include "GOwnPtrSoup.h"
#include "URL.h"
#include "NetworkingContext.h"
#include "PlatformCookieJar.h"
#include "ResourceHandle.h"

    return false;
}

void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
{
    SoupCookieJar* jar = cookieJarForSession(session);
    if (!jar)

    soup_cookies_free(existingCookies);
}

static String cookiesForSession(const NetworkStorageSession& session, const URL& url, bool forHTTPHeader)
{
    SoupCookieJar* jar = cookieJarForSession(session);
    if (!jar)

    return String::fromUTF8(cookies.get());
}

String cookiesForDOM(const NetworkStorageSession& session, const URL&, const URL& url)
{
    return cookiesForSession(session, url, false);
}

String cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url)
{
    return cookiesForSession(session, url, true);
}

bool cookiesEnabled(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/)
{
    return !!cookieJarForSession(session);
}

bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, Vector<Cookie>& rawCookies)
{
    rawCookies.clear();
    SoupCookieJar* jar = cookieJarForSession(session);

    return true;
}

void deleteCookie(const NetworkStorageSession& session, const URL& url, const String& name)
{
    SoupCookieJar* jar = cookieJarForSession(session);
    if (!jar)



#include "config.h"
#include "ProxyServer.h"

#include "URL.h"

namespace WebCore {

Vector<ProxyServer> proxyServersForURL(const URL&, const NetworkingContext*)
{
    // FIXME: Implement.
    return Vector<ProxyServer>();



    // We always put the credentials into the URL. In the CFNetwork-port HTTP family credentials are applied in
    // the didReceiveAuthenticationChallenge callback, but libsoup requires us to use this method to override
    // any previously remembered credentials. It has its own per-session credential storage.
    URL urlWithCredentials(request.url());
    urlWithCredentials.setUser(user);
    urlWithCredentials.setPass(password);
    request.setURL(urlWithCredentials);

    return true;
}

static bool shouldRedirectAsGET(SoupMessage* message, URL& newURL, bool crossOrigin)
{
    if (message->method == SOUP_METHOD_GET || message->method == SOUP_METHOD_HEAD)
        return false;

    ResourceRequest newRequest = handle->firstRequest();
    SoupMessage* message = d->m_soupMessage.get();
    const char* location = soup_message_headers_get_one(message->response_headers, "Location");
    URL newURL = URL(soupURIToKURL(soup_message_get_uri(message)), location);
    bool crossOrigin = !protocolHostAndPortAreEqual(handle->firstRequest().url(), newURL);
    newRequest.setURL(newURL);
    newRequest.setFirstPartyForCookies(newURL);


static void addEncodedBlobToSoupMessageBody(SoupMessage* message, const FormDataElement& element, unsigned long& totalBodySize)
{
    RefPtr<BlobStorageData> blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromURL(URL(ParsedURLString, element.m_url));
    if (!blobData)
        return;




    class ResourceRequest : public ResourceRequestBase {
    public:
        ResourceRequest(const String& url)
            : ResourceRequestBase(URL(ParsedURLString, url), UseProtocolCachePolicy)
            , m_acceptEncoding(true)
            , m_soupFlags(static_cast<SoupMessageFlags>(0))
        {
        }

        ResourceRequest(const URL& url)
            : ResourceRequestBase(url, UseProtocolCachePolicy)
            , m_acceptEncoding(true)
            , m_soupFlags(static_cast<SoupMessageFlags>(0))
        {
        }

        ResourceRequest(const URL& url, const String& referrer, ResourceRequestCachePolicy policy = UseProtocolCachePolicy)
            : ResourceRequestBase(url, policy)
            , m_acceptEncoding(true)
            , m_soupFlags(static_cast<SoupMessageFlags>(0))

        }

        ResourceRequest()
            : ResourceRequestBase(URL(), UseProtocolCachePolicy)
            , m_acceptEncoding(true)
            , m_soupFlags(static_cast<SoupMessageFlags>(0))
        {
        }

        ResourceRequest(SoupMessage* soupMessage)
            : ResourceRequestBase(URL(), UseProtocolCachePolicy)
            , m_acceptEncoding(true)
            , m_soupFlags(static_cast<SoupMessageFlags>(0))
        {

Lines 140-146 SoupURI* ResourceRequest::soupURI() const a/Source/WebCore/platform/network/soup/ResourceRequestSoup.cpp_sec1
- a/Source/WebCore/platform/network/soup/ResourceRequestSoup.cpp -1 / +1 lines
140	return soup_uri_new(urlString.utf8().data());	140	return soup_uri_new(urlString.utf8().data());
141	}	141	}
142		142
143	KURL url = m_url;	143	URL url = m_url;
144	url.removeFragmentIdentifier();	144	url.removeFragmentIdentifier();
145	SoupURI* uri = soup_uri_new(url.string().utf8().data());	145	SoupURI* uri = soup_uri_new(url.string().utf8().data());
146		146

Lines 42-48 public: a/Source/WebCore/platform/network/soup/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/soup/ResourceResponse.h -1 / +1 lines
42	{	42	{
43	}	43	}
44		44
45	ResourceResponse(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)	45	ResourceResponse(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
46	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)	46	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)
47	, m_soupFlags(static_cast<SoupMessageFlags>(0))	47	, m_soupFlags(static_cast<SoupMessageFlags>(0))
48	, m_tlsErrors(static_cast<GTlsCertificateFlags>(0))	48	, m_tlsErrors(static_cast<GTlsCertificateFlags>(0))




    class SocketStreamHandle : public RefCounted<SocketStreamHandle>, public SocketStreamHandleBase {
    public:
        static PassRefPtr<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(url, client)); }
        static PassRefPtr<SocketStreamHandle> create(GSocketConnection* socketConnection, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(socketConnection, client)); }

        virtual ~SocketStreamHandle();

        char* m_readBuffer;
        void* m_id;

        SocketStreamHandle(const URL&, SocketStreamHandleClient*);
        SocketStreamHandle(GSocketConnection*, SocketStreamHandleClient*);

        // No authentication for streams per se, but proxy may ask for credentials.



#include "config.h"
#include "SocketStreamHandle.h"

#include "URL.h"
#include "Logging.h"
#include "NotImplemented.h"
#include "SocketStreamError.h"

    return id;
}

SocketStreamHandle::SocketStreamHandle(const URL& url, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(url, client)
    , m_readBuffer(0)
{

}

SocketStreamHandle::SocketStreamHandle(GSocketConnection* socketConnection, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(URL(), client)
    , m_readBuffer(0)
{
    LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);



// soup_uri_to_string, and thus the requests are not properly
// built. Fixing soup_uri_to_string is a no-no as the maintainer does
// not want to break compatibility with previous implementations
URL soupURIToKURL(SoupURI* soupURI)
{
    GOwnPtr<gchar> urlString(soup_uri_to_string(soupURI, FALSE));
    URL url(URL(), String::fromUTF8(urlString.get()));

    if (!soupURI->password)
        return url;



#ifndef SoupURIUtils_h
#define SoupURIUtils_h

#include "URL.h"

typedef struct _SoupURI SoupURI;

namespace WebCore {
URL soupURIToKURL(SoupURI* soupURI);
}

#endif



#include "PlatformCookieJar.h"

#include "Cookie.h"
#include "URL.h"
#include "NetworkingContext.h"
#include "ResourceHandle.h"
#include <windows.h>


namespace WebCore {

void setCookiesFromDOM(const NetworkStorageSession&, const URL&, const URL& url, const String& value)
{
    // FIXME: Deal with firstParty argument.
    String str = url.string();

    InternetSetCookie(str.charactersWithNullTermination().data(), 0, val.charactersWithNullTermination().data());
}

String cookiesForDOM(const NetworkStorageSession&, const URL&, const URL& url)
{
    // FIXME: Deal with firstParty argument.


    return String::adopt(buffer);
}

String cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    // FIXME: include HttpOnly cookie
    return cookiesForDOM(session.context(), firstParty, url);
}

bool cookiesEnabled(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/)
{
    return true;
}

bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/, Vector<Cookie>& rawCookies)
{
    // FIXME: Not yet implemented
    rawCookies.clear();
    return false; // return true when implemented
}

void deleteCookie(const NetworkStorageSession&, const URL&, const String&)
{
    // FIXME: Not yet implemented
}

Lines 28-34 a/Source/WebCore/platform/network/win/ProxyServerWin.cpp_sec1
- a/Source/WebCore/platform/network/win/ProxyServerWin.cpp -1 / +1 lines
28		28
29	namespace WebCore {	29	namespace WebCore {
30		30
31	Vector<ProxyServer> proxyServersForURL(const KURL&, const NetworkingContext*)	31	Vector<ProxyServer> proxyServersForURL(const URL&, const NetworkingContext*)
32	{	32	{
33	// FIXME: Implement.	33	// FIXME: Implement.
34	return Vector<ProxyServer>();	34	return Vector<ProxyServer>();

Lines 174-180 void ResourceHandle::internetStatusCallback(HINTERNET internetHandle, DWORD_PTR a/Source/WebCore/platform/network/win/ResourceHandleWin.cpp_sec1
- a/Source/WebCore/platform/network/win/ResourceHandleWin.cpp -1 / +1 lines
174	void ResourceHandle::onRedirect()	174	void ResourceHandle::onRedirect()
175	{	175	{
176	ResourceRequest newRequest = firstRequest();	176	ResourceRequest newRequest = firstRequest();
177	newRequest.setURL(KURL(ParsedURLString, d->m_redirectUrl));	177	newRequest.setURL(URL(ParsedURLString, d->m_redirectUrl));
178		178
179	ResourceResponse response(firstRequest().url(), String(), 0, String(), String());	179	ResourceResponse response(firstRequest().url(), String(), 0, String(), String());
180		180



class ResourceRequest : public ResourceRequestBase {
public:
    ResourceRequest(const String& url)
        : ResourceRequestBase(URL(ParsedURLString, url), UseProtocolCachePolicy)
    {
    }

    ResourceRequest(const URL& url)
        : ResourceRequestBase(url, UseProtocolCachePolicy)
    {
    }

    ResourceRequest(const URL& url, const String& referrer, ResourceRequestCachePolicy policy = UseProtocolCachePolicy)
        : ResourceRequestBase(url, policy)
    {
        setHTTPReferrer(referrer);
    }

    ResourceRequest()
        : ResourceRequestBase(URL(), UseProtocolCachePolicy)
    {
    }


Lines 35-41 public: a/Source/WebCore/platform/network/win/ResourceResponse.h_sec1
- a/Source/WebCore/platform/network/win/ResourceResponse.h -1 / +1 lines
35	{	35	{
36	}	36	}
37		37
38	ResourceResponse(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)	38	ResourceResponse(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
39	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)	39	: ResourceResponseBase(url, mimeType, expectedLength, textEncodingName, filename)
40	{	40	{
41	}	41	}




class SocketStreamHandle : public RefCounted<SocketStreamHandle>, public SocketStreamHandleBase {
public:
    static PassRefPtr<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(url, client)); }

    virtual ~SocketStreamHandle();


    virtual void platformClose();

private:
    SocketStreamHandle(const URL&, SocketStreamHandleClient*);

    // No authentication for streams per se, but proxy may ask for credentials.
    void didReceiveAuthenticationChallenge(const AuthenticationChallenge&);



#include "config.h"
#include "SocketStreamHandle.h"

#include "URL.h"
#include "Logging.h"
#include "NotImplemented.h"
#include "SocketStreamHandleClient.h"

namespace WebCore {

SocketStreamHandle::SocketStreamHandle(const URL& url, SocketStreamHandleClient* client)
    : SocketStreamHandleBase(url, client)
{
    LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);

Lines 56-62 void Pasteboard::write(const PasteboardURL&) a/Source/WebCore/platform/nix/PasteboardNix.cpp_sec1
- a/Source/WebCore/platform/nix/PasteboardNix.cpp -1 / +1 lines
56	notImplemented();	56	notImplemented();
57	}	57	}
58		58
59	void Pasteboard::writeImage(Node*, const KURL&, const String&)	59	void Pasteboard::writeImage(Node*, const URL&, const String&)
60	{	60	{
61	notImplemented();	61	notImplemented();
62	}	62	}



/*
 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
 *
 * 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.
 *
 */
#include "config.h"
#include "KURL.h"

#include "NotImplemented.h"
#include "TextEncoding.h"
#include "qurl.h"
#include <wtf/text/CString.h>

namespace WebCore {

KURL::KURL(const QUrl& url)
{
    *this = KURL(KURL(), url.toEncoded().constData(), UTF8Encoding());
}

KURL::operator QUrl() const
{
    return QUrl(m_string);
}

String KURL::fileSystemPath() const
{
    if (!isValid())
        return String();

    if (isLocalFile())
        return static_cast<QUrl>(*this).toLocalFile();

    // A valid qrc resource path begins with a colon.
    if (protocolIs("qrc"))
        return ":" + decodeURLEscapeSequences(path());

    return String();
}

}

Lines 205-211 void Pasteboard::write(const PasteboardURL& pasteboardURL) a/Source/WebCore/platform/qt/PasteboardQt.cpp_sec1
- a/Source/WebCore/platform/qt/PasteboardQt.cpp -1 / +1 lines
205	#endif	205	#endif
206	}	206	}
207		207
208	void Pasteboard::writeImage(Node* node, const KURL&, const String&)	208	void Pasteboard::writeImage(Node* node, const URL&, const String&)
209	{	209	{
210	ASSERT(node);	210	ASSERT(node);
211		211

Lines 26-32 a/Source/WebCore/platform/qt/PlatformSupport.h_sec1
- a/Source/WebCore/platform/qt/PlatformSupport.h -1 / +1 lines
26	#ifndef PlatformSupport_h	26	#ifndef PlatformSupport_h
27	#define PlatformSupport_h	27	#define PlatformSupport_h
28		28
29	#include "KURL.h"	29	#include "URL.h"
30		30
31	#include <wtf/Vector.h>	31	#include <wtf/Vector.h>
32	#include <wtf/text/WTFString.h>	32	#include <wtf/text/WTFString.h>



#include "GraphicsContext.h"
#include "IconLoader.h"
#include "IntPoint.h"
#include "URL.h"
#include "Language.h"
#include "LocalizedStrings.h"
#include "Node.h"

    notImplemented();
}

String signedPublicKeyAndChallengeString(unsigned, const String&, const URL&)
{
    return String();
}



#include "config.h"
#include "BString.h"

#include "URL.h"
#include <windows.h>
#include <wtf/text/AtomicString.h>
#include <wtf/text/WTFString.h>

        m_bstr = SysAllocStringLen(s.characters(), s.length());
}

BString::BString(const URL& url)
{
    if (url.isNull())
        m_bstr = 0;




namespace WebCore {

    class URL;

    class BString {
    public:

        BString(const wchar_t*, size_t length);
        BString(const String&);
        BString(const AtomicString&);
        BString(const URL&);
#if USE(CF)
        BString(CFStringRef);
#endif



#include "ClipboardUtilitiesWin.h"

#include "DocumentFragment.h"
#include "KURL.h"
#include "TextEncoding.h"
#include "URL.h"
#include "markup.h"
#include <shlobj.h>
#include <wininet.h> // for INTERNET_MAX_URL_LENGTH

    return &texthtmlFormat;
}

HGLOBAL createGlobalData(const URL& url, const String& title)
{
    String mutableURL(url.string());
    String mutableTitle(title);



namespace WebCore {

class Document;
class URL;

HGLOBAL createGlobalData(const String&);
HGLOBAL createGlobalData(const Vector<char>&);
HGLOBAL createGlobalData(const URL& url, const String& title);

FORMATETC* urlWFormat();
FORMATETC* urlFormat();



#include "GraphicsContext.h"
#include "HWndDC.h"
#include "Image.h"
#include "URL.h"
#include "StringTruncator.h"
#include "TextRun.h"
#include "WebCoreTextRenderer.h"

    return result;
}

DragImageRef createDragImageForLink(URL& url, const String& inLabel, FontRenderingMode fontRenderingMode)
{
    // This is more or less an exact match for the Mac OS X code.




#include "HWndDC.h"
#include "HitTestResult.h"
#include "Image.h"
#include "URL.h"
#include "NotImplemented.h"
#include "Page.h"
#include "Range.h"

#endif
}

static bool writeURL(WCDataObject *data, const URL& url, String title, bool withPlainText, bool withHTML)
{
    ASSERT(data);


    ClipboardDataType winType = clipboardTypeFromMIMEType(type);

    if (winType == ClipboardDataTypeURL)
        return WebCore::writeURL(m_writableDataObject.get(), URL(URL(), data), String(), false, true);

    if (winType == ClipboardDataTypeText) {
        STGMEDIUM medium = {0};

    }

    if (!lstrlen(fsPathBuffer)) {
        URL kurl(URL(), url);
        usedURL = true;
        // The filename for any content based drag or file url should be the last element of 
        // the path. If we can't find it, or we're coming up with the name for a link

    return hr;
}

void Pasteboard::writeURLToDataObject(const URL& kurl, const String& titleStr)
{
    if (!m_writableDataObject)
        return;
    WebCore::writeURL(m_writableDataObject.get(), kurl, titleStr, true, true);

    String url = kurl.string();
    ASSERT(url.containsOnlyASCII()); // URL::string() is URL encoded.

    String fsPath = filesystemPathFromUrlOrTitle(url, titleStr, L".URL", true);
    String contentString("[InternetShortcut]\r\nURL=" + url + "\r\n");

    writeURLToDataObject(pasteboardURL.url, pasteboardURL.title);
}

void Pasteboard::writeImage(Node* node, const URL&, const String&)
{
    ASSERT(node);


    return memObj;
}

static HGLOBAL createGlobalHDropContent(const URL& url, String& fileName, SharedBuffer* data)
{
    if (fileName.isEmpty() || !data)
        return 0;

    return memObj;
}

void Pasteboard::writeImageToDataObject(Element* element, const URL& url)
{
    // Shove image data into a DataObject for use as a file
    CachedImage* cachedImage = getCachedImage(element);

    writeFileToDataObject(m_writableDataObject.get(), imageFileDescriptor, imageFileContent, hDropContent);
}

void Pasteboard::writeURLToWritableDataObject(const URL& url, const String& title)
{
    WebCore::writeURL(m_writableDataObject.get(), url, title, true, false);
}

Lines 35-41 void WebCore::getSupportedKeySizes(Vector<String>& v) a/Source/WebCore/platform/win/SSLKeyGeneratorWin.cpp_sec1
- a/Source/WebCore/platform/win/SSLKeyGeneratorWin.cpp -1 / +1 lines
35	v.append("Medium Grade");	35	v.append("Medium Grade");
36	}	36	}
37		37
38	String WebCore::signedPublicKeyAndChallengeString(unsigned index, const String& challenge, const KURL& url)	38	String WebCore::signedPublicKeyAndChallengeString(unsigned index, const String& challenge, const URL& url)
39	{	39	{
40	String keyString;	40	String keyString;
41		41

Lines 34-40 a/Source/WebCore/platform/win/TemporaryLinkStubs.cpp_sec1
- a/Source/WebCore/platform/win/TemporaryLinkStubs.cpp -1 / +1 lines
34	namespace WebCore {	34	namespace WebCore {
35		35
36	// <keygen>	36	// <keygen>
37	String signedPublicKeyAndChallengeString(unsigned, const String&, const KURL&) { notImplemented(); return String(); }	37	String signedPublicKeyAndChallengeString(unsigned, const String&, const URL&) { notImplemented(); return String(); }
38	void getSupportedKeySizes(Vector<String>&) { notImplemented(); }	38	void getSupportedKeySizes(Vector<String>&) { notImplemented(); }
39		39
40	#if !USE(CFNETWORK)	40	#if !USE(CFNETWORK)



#include "PluginDatabase.h"

#include "Frame.h"
#include "URL.h"
#include "PluginPackage.h"
#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
#include "FileSystem.h"

    return mimeTypeForPlugin.get(pluginChoices[0]);
}

PluginPackage* PluginDatabase::findPlugin(const URL& url, String& mimeType)
{
    if (!mimeType.isEmpty())
        return pluginForMIMEType(mimeType);



    class Element;
    class Frame;
    class IntSize;
    class URL;
    class PluginDatabaseClient;
    class PluginPackage;


        static bool isPreferredPluginDirectory(const String& directory);
        static int preferredPluginCompare(const void*, const void*);

        PluginPackage* findPlugin(const URL&, String& mimeType);
        PluginPackage* pluginForMIMEType(const String& mimeType);
        void setPreferredPluginForMIMEType(const String& mimeType, PluginPackage* plugin);




{
    ASSERT(m_streamState == StreamBeforeStarted);

    const URL& responseURL = m_resourceResponse.url();

    // Some plugins (Flash) expect that javascript URLs are passed back decoded as this is the
    // format used when requesting the URL.

    } 
}

void PluginStream::sendJavaScriptStream(const URL& requestURL, const CString& resultString)
{
    didReceiveResponse(0, ResourceResponse(requestURL, "text/plain", resultString.length(), "", ""));




#define PluginStream_h

#include "FileSystem.h"
#include "URL.h"
#include "NetscapePlugInStreamLoader.h"
#include "PluginQuirkSet.h"
#include "ResourceRequest.h"


        void setLoadManually(bool loadManually) { m_loadManually = loadManually; }

        void sendJavaScriptStream(const URL& requestURL, const WTF::CString& resultString);
        void cancelAndDestroyStream(NPReason);

        static NPP ownerForStream(NPStream*);



    return map;
}

static String scriptStringIfJavaScriptURL(const URL& url)
{
    if (!protocolIsJavaScript(url))
        return String();

    if (m_parentFrame->loader().documentLoader() != m_parentFrame->loader().activeDocumentLoader() && (targetFrameName.isNull() || m_parentFrame->tree().find(targetFrameName) != m_parentFrame))
        return;

    URL requestURL = request->frameLoadRequest().resourceRequest().url();
    String jsString = scriptStringIfJavaScriptURL(requestURL);

    UserGestureIndicator gestureIndicator(request->shouldAllowPopups() ? DefinitelyProcessingUserGesture : PossiblyProcessingUserGesture);

{
    ASSERT(frameLoadRequest.resourceRequest().httpMethod() == "GET" || frameLoadRequest.resourceRequest().httpMethod() == "POST");

    URL url = frameLoadRequest.resourceRequest().url();
    
    if (url.isEmpty())
        return NPERR_INVALID_URL;

    return NPERR_NO_ERROR;
}

static URL makeURL(const URL& baseURL, const char* relativeURLString)
{
    String urlString = relativeURLString;


    urlString.replaceWithLiteral('\n', "");
    urlString.replaceWithLiteral('\r', "");

    return URL(baseURL, urlString);
}

NPError PluginView::getURLNotify(const char* url, const char* target, void* notifyData)

    m_paramCount = paramCount;
}

PluginView::PluginView(Frame* parentFrame, const IntSize& size, PluginPackage* plugin, HTMLPlugInElement* element, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
    : m_parentFrame(parentFrame)
    , m_plugin(plugin)
    , m_element(element)

    return s_callingPlugin > 0;
}

PassRefPtr<PluginView> PluginView::create(Frame* parentFrame, const IntSize& size, HTMLPlugInElement* element, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
    // if we fail to find a plugin for this MIME type, findPlugin will search for
    // a plugin by the file extension and update the MIME type, so pass a mutable String


    switch (variable) {
    case NPNURLVCookie: {
        URL u(m_parentFrame->document()->baseURL(), url);
        if (u.isValid()) {
            Frame* frame = getFrame(parentFrame(), m_element);
            if (frame) {

        break;
    }
    case NPNURLVProxy: {
        URL u(m_parentFrame->document()->baseURL(), url);
        if (u.isValid()) {
            Frame* frame = getFrame(parentFrame(), m_element);
            const FrameLoader* frameLoader = frame ? &frame->loader() : 0;


    switch (variable) {
    case NPNURLVCookie: {
        URL u(m_parentFrame->document()->baseURL(), url);
        if (u.isValid()) {
            const String cookieStr = String::fromUTF8(value, len);
            Frame* frame = getFrame(parentFrame(), m_element);



    class HTMLPlugInElement;
    class KeyboardEvent;
    class MouseEvent;
    class URL;
#if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
    class PluginMessageThrottlerWin;
#endif

                     , public PluginManualLoader
                     , private MediaCanStartListener {
    public:
        static PassRefPtr<PluginView> create(Frame* parentFrame, const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);
        virtual ~PluginView();

        PluginPackage* plugin() const { return m_plugin.get(); }


        const String& pluginsPage() const { return m_pluginsPage; }
        const String& mimeType() const { return m_mimeType; }
        const URL& url() const { return m_url; }

#if defined(XP_MACOSX) && ENABLE(NETSCAPE_PLUGIN_API)
        bool popUpContextMenu(NPMenu*);

#endif

    private:
        PluginView(Frame* parentFrame, const IntSize&, PluginPackage*, HTMLPlugInElement*, const URL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually);

        void setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues);
        bool startOrAddToUnstartedList();

        RefPtr<PluginPackage> m_plugin;
        HTMLPlugInElement* m_element;
        bool m_isStarted;
        URL m_url;
        PluginStatus m_status;
        Vector<IntRect> m_invalidRects;


Lines 29-35 a/Source/WebCore/plugins/win/PluginDatabaseWin.cpp_sec1
- a/Source/WebCore/plugins/win/PluginDatabaseWin.cpp -1 / +1 lines
29	#include "PluginDatabase.h"	29	#include "PluginDatabase.h"
30		30
31	#include "Frame.h"	31	#include "Frame.h"
32	#include "KURL.h"	32	#include "URL.h"
33	#include "PluginPackage.h"	33	#include "PluginPackage.h"
34	#include <wtf/WindowsExtras.h>	34	#include <wtf/WindowsExtras.h>
35		35

Lines 41-47 class Frame; a/Source/WebCore/rendering/HitTestLocation.h_sec1
- a/Source/WebCore/rendering/HitTestLocation.h -1 / +1 lines
41	class HTMLMediaElement;	41	class HTMLMediaElement;
42	#endif	42	#endif
43	class Image;	43	class Image;
44	class KURL;	44	class URL;
45	class Node;	45	class Node;
46	class RenderRegion;	46	class RenderRegion;
47	class Scrollbar;	47	class Scrollbar;



    return m_innerNonSharedNode->renderBox()->absoluteContentQuad().enclosingBoundingBox();
}

URL HitTestResult::absoluteImageURL() const
{
    if (!m_innerNonSharedNode)
        return URL();

    if (!(m_innerNonSharedNode->renderer() && m_innerNonSharedNode->renderer()->isImage()))
        return URL();

    AtomicString urlString;
    if (m_innerNonSharedNode->hasTagName(embedTag)

        Element* element = toElement(m_innerNonSharedNode.get());
        urlString = element->imageSourceURL();
    } else
        return URL();

    return m_innerNonSharedNode->document().completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
}

URL HitTestResult::absolutePDFURL() const
{
    if (!m_innerNonSharedNode)
        return URL();

    if (!m_innerNonSharedNode->hasTagName(embedTag) && !m_innerNonSharedNode->hasTagName(objectTag))
        return URL();

    HTMLPlugInImageElement* element = toHTMLPlugInImageElement(m_innerNonSharedNode.get());
    URL url = m_innerNonSharedNode->document().completeURL(stripLeadingAndTrailingHTMLSpaces(element->url()));
    if (!url.isValid())
        return URL();

    if (element->serviceType() == "application/pdf" || (element->serviceType().isEmpty() && url.path().lower().endsWith(".pdf")))
        return url;
    return URL();
}

URL HitTestResult::absoluteMediaURL() const
{
#if ENABLE(VIDEO)
    if (HTMLMediaElement* mediaElt = mediaElement())
        return mediaElt->currentSrc();
    return URL();
#else
    return URL();
#endif
}


#endif
}

URL HitTestResult::absoluteLinkURL() const
{
    if (!m_innerURLElement)
        return URL();

    AtomicString urlString;
    if (isHTMLAnchorElement(m_innerURLElement.get()) || isHTMLAreaElement(m_innerURLElement.get()) || m_innerURLElement->hasTagName(linkTag))

        urlString = m_innerURLElement->getAttribute(XLinkNames::hrefAttr);
#endif
    else
        return URL();

    return m_innerURLElement->document().completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
}



class HTMLMediaElement;
#endif
class Image;
class URL;
class Node;
class RenderRegion;
class Scrollbar;

    String titleDisplayString() const;
    Image* image() const;
    IntRect imageRect() const;
    URL absoluteImageURL() const;
    URL absolutePDFURL() const;
    URL absoluteMediaURL() const;
    URL absoluteLinkURL() const;
    String textContent() const;
    bool isLiveLink() const;
    bool isOverLink() const;



#include "CachedResourceHandle.h"
#include "CachedShader.h"
#include "CustomFilterProgram.h"
#include "URL.h"
#include "StyleShader.h"
#include <wtf/FastMalloc.h>


class StyleCustomFilterProgram : public CustomFilterProgram, public CachedResourceClient {
    WTF_MAKE_FAST_ALLOCATED;
public:
    static PassRefPtr<StyleCustomFilterProgram> create(URL vertexShaderURL, PassRefPtr<StyleShader> vertexShader, 
        URL fragmentShaderURL, PassRefPtr<StyleShader> fragmentShader, CustomFilterProgramType programType,
        const CustomFilterProgramMixSettings& mixSettings, CustomFilterMeshType meshType)
    {
        return adoptRef(new StyleCustomFilterProgram(vertexShaderURL, vertexShader, fragmentShaderURL, fragmentShader, programType, mixSettings, meshType));

    void setCache(StyleCustomFilterProgramCache* cache) { m_cache = cache; }
    bool inCache() const { return m_cache; }
    
    URL vertexShaderURL() const { return m_vertexShaderURL; }
    URL fragmentShaderURL() const { return m_fragmentShaderURL; }

private:
    StyleCustomFilterProgram(URL vertexShaderURL, PassRefPtr<StyleShader> vertexShader, URL fragmentShaderURL, PassRefPtr<StyleShader> fragmentShader, 
        CustomFilterProgramType programType, const CustomFilterProgramMixSettings& mixSettings, CustomFilterMeshType meshType)
        : CustomFilterProgram(programType, mixSettings, meshType)
        , m_vertexShader(vertexShader)


    // The URLs form the key of the StyleCustomFilterProgram in the cache and are used
    // to lookup the StyleCustomFilterProgram when it's removed from the cache.
    URL m_vertexShaderURL;
    URL m_fragmentShaderURL;

    // The Cache is responsible of invalidating this reference.
    StyleCustomFilterProgramCache* m_cache;

Lines 132-138 void SVGCursorElement::svgAttributeChanged(const QualifiedName& attrName) a/Source/WebCore/svg/SVGCursorElement.cpp_sec1
- a/Source/WebCore/svg/SVGCursorElement.cpp -1 / +1 lines
132	(*it)->setNeedsStyleRecalc();	132	(*it)->setNeedsStyleRecalc();
133	}	133	}
134		134
135	void SVGCursorElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	135	void SVGCursorElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
136	{	136	{
137	SVGElement::addSubresourceAttributeURLs(urls);	137	SVGElement::addSubresourceAttributeURLs(urls);
138		138

Lines 56-62 private: a/Source/WebCore/svg/SVGCursorElement.h_sec1
- a/Source/WebCore/svg/SVGCursorElement.h -1 / +1 lines
56		56
57	virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE { return false; }	57	virtual bool rendererIsNeeded(const RenderStyle&) OVERRIDE { return false; }
58		58
59	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	59	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
60		60
61	BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGCursorElement)	61	BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGCursorElement)
62	DECLARE_ANIMATED_LENGTH(X, x)	62	DECLARE_ANIMATED_LENGTH(X, x)

Lines 35-41 a/Source/WebCore/svg/SVGDocument.cpp_sec1
- a/Source/WebCore/svg/SVGDocument.cpp -1 / +1 lines
35		35
36	namespace WebCore {	36	namespace WebCore {
37		37
38	SVGDocument::SVGDocument(Frame* frame, const KURL& url)	38	SVGDocument::SVGDocument(Frame* frame, const URL& url)
39	: Document(frame, url, SVGDocumentClass)	39	: Document(frame, url, SVGDocumentClass)
40	{	40	{
41	}	41	}




class SVGDocument FINAL : public Document {
public:
    static PassRefPtr<SVGDocument> create(Frame* frame, const URL& url)
    {
        return adoptRef(new SVGDocument(frame, url));
    }

    void updatePan(const FloatPoint& pos) const;

private:
    SVGDocument(Frame*, const URL&);

    virtual bool childShouldCreateRenderer(const Node*) const;


Lines 209-215 PassRefPtr<FilterEffect> SVGFEImageElement::build(SVGFilterBuilder, Filter fil a/Source/WebCore/svg/SVGFEImageElement.cpp_sec1
- a/Source/WebCore/svg/SVGFEImageElement.cpp -1 / +1 lines
209	return FEImage::createWithIRIReference(filter, document(), href(), preserveAspectRatio());	209	return FEImage::createWithIRIReference(filter, document(), href(), preserveAspectRatio());
210	}	210	}
211		211
212	void SVGFEImageElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	212	void SVGFEImageElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
213	{	213	{
214	SVGFilterPrimitiveStandardAttributes::addSubresourceAttributeURLs(urls);	214	SVGFilterPrimitiveStandardAttributes::addSubresourceAttributeURLs(urls);
215		215

Lines 51-57 private: a/Source/WebCore/svg/SVGFEImageElement.h_sec1
- a/Source/WebCore/svg/SVGFEImageElement.h -1 / +1 lines
51	virtual void svgAttributeChanged(const QualifiedName&);	51	virtual void svgAttributeChanged(const QualifiedName&);
52	virtual void notifyFinished(CachedResource*);	52	virtual void notifyFinished(CachedResource*);
53		53
54	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	54	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
55	virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder, Filter);	55	virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder, Filter);
56		56
57	void clearResourceReferences();	57	void clearResourceReferences();

Lines 219-225 const AtomicString& SVGImageElement::imageSourceURL() const a/Source/WebCore/svg/SVGImageElement.cpp_sec1
- a/Source/WebCore/svg/SVGImageElement.cpp -1 / +1 lines
219	return getAttribute(XLinkNames::hrefAttr);	219	return getAttribute(XLinkNames::hrefAttr);
220	}	220	}
221		221
222	void SVGImageElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	222	void SVGImageElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
223	{	223	{
224	SVGGraphicsElement::addSubresourceAttributeURLs(urls);	224	SVGGraphicsElement::addSubresourceAttributeURLs(urls);
225		225

Lines 56-62 private: a/Source/WebCore/svg/SVGImageElement.h_sec1
- a/Source/WebCore/svg/SVGImageElement.h -1 / +1 lines
56	virtual RenderElement* createRenderer(RenderArena&, RenderStyle&);	56	virtual RenderElement* createRenderer(RenderArena&, RenderStyle&);
57		57
58	virtual const AtomicString& imageSourceURL() const OVERRIDE;	58	virtual const AtomicString& imageSourceURL() const OVERRIDE;
59	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	59	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
60		60
61	virtual bool haveLoadedRequiredResources();	61	virtual bool haveLoadedRequiredResources();
62		62




String SVGImageLoader::sourceURI(const AtomicString& attribute) const
{
    URL base = element()->baseURI();
    if (base.isValid())
        return URL(base, stripLeadingAndTrailingHTMLSpaces(attribute)).string();
    return element()->document().completeURL(stripLeadingAndTrailingHTMLSpaces(attribute));
}


Lines 153-159 void SVGScriptElement::setType(const String& type) a/Source/WebCore/svg/SVGScriptElement.cpp_sec1
- a/Source/WebCore/svg/SVGScriptElement.cpp -1 / +1 lines
153	m_type = type;	153	m_type = type;
154	}	154	}
155		155
156	void SVGScriptElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const	156	void SVGScriptElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
157	{	157	{
158	SVGElement::addSubresourceAttributeURLs(urls);	158	SVGElement::addSubresourceAttributeURLs(urls);
159		159

Lines 53-59 private: a/Source/WebCore/svg/SVGScriptElement.h_sec1
- a/Source/WebCore/svg/SVGScriptElement.h -1 / +1 lines
53	virtual bool isURLAttribute(const Attribute&) const OVERRIDE;	53	virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
54	virtual void finishParsingChildren();	54	virtual void finishParsingChildren();
55		55
56	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	56	virtual void addSubresourceAttributeURLs(ListHashSet<URL>&) const;
57		57
58	virtual bool haveLoadedRequiredResources() { return SVGExternalResourcesRequired::haveLoadedRequiredResources(); }	58	virtual bool haveLoadedRequiredResources() { return SVGExternalResourcesRequired::haveLoadedRequiredResources(); }
59		59



#include "Attribute.h"
#include "Document.h"
#include "Element.h"
#include "URL.h"
#include "XLinkNames.h"

namespace WebCore {

    if (start == notFound)
        return emptyString();

    URL base = start ? URL(document.baseURI(), url.substring(0, start)) : document.baseURI();
    String fragmentIdentifier = url.substring(start);
    URL kurl(base, fragmentIdentifier);
    if (equalIgnoringFragmentIdentifier(kurl, document.url()))
        return fragmentIdentifier.substring(1);


    return emptyString();
}

static inline URL urlFromIRIStringWithFragmentIdentifier(const String& url, Document& document, String& fragmentIdentifier)
{
    size_t startOfFragmentIdentifier = url.find('#');
    if (startOfFragmentIdentifier == notFound)
        return URL();

    // Exclude the '#' character when determining the fragmentIdentifier.
    fragmentIdentifier = url.substring(startOfFragmentIdentifier + 1);
    if (startOfFragmentIdentifier) {
        URL base(document.baseURI(), url.substring(0, startOfFragmentIdentifier));
        return URL(base, url.substring(startOfFragmentIdentifier));
    }

    return URL(document.baseURI(), url.substring(startOfFragmentIdentifier));
}

Element* SVGURIReference::targetElementFromIRIString(const String& iri, Document& document, String* fragmentIdentifier, Document* externalDocument)
{
    // If there's no fragment identifier contained within the IRI string, we can't lookup an element.
    String id;
    URL url = urlFromIRIStringWithFragmentIdentifier(iri, document, id);
    if (url == URL())
        return 0;

    if (fragmentIdentifier)

Lines 47-53 public: a/Source/WebCore/svg/SVGURIReference.h_sec1
- a/Source/WebCore/svg/SVGURIReference.h -1 / +1 lines
47	return false;	47	return false;
48		48
49	// If the URI matches our documents URL, we're dealing with a local reference.	49	// If the URI matches our documents URL, we're dealing with a local reference.
50	KURL url = document.completeURL(uri);	50	URL url = document.completeURL(uri);
51	return !equalIgnoringFragmentIdentifier(url, document.url());	51	return !equalIgnoringFragmentIdentifier(url, document.url());
52	}	52	}
53		53

Lines 241-247 void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName) a/Source/WebCore/svg/SVGUseElement.cpp_sec1
- a/Source/WebCore/svg/SVGUseElement.cpp -1 / +1 lines
241	if (SVGURIReference::isKnownAttribute(attrName)) {	241	if (SVGURIReference::isKnownAttribute(attrName)) {
242	bool isExternalReference = isExternalURIReference(href(), document());	242	bool isExternalReference = isExternalURIReference(href(), document());
243	if (isExternalReference) {	243	if (isExternalReference) {
244	KURL url = document().completeURL(href());	244	URL url = document().completeURL(href());
245	if (url.hasFragmentIdentifier()) {	245	if (url.hasFragmentIdentifier()) {
246	CachedResourceRequest request(ResourceRequest(url.string()));	246	CachedResourceRequest request(ResourceRequest(url.string()));
247	request.setInitiator(this);	247	request.setInitiator(this);

Lines 372-378 bool SVGImage::dataChanged(bool allDataReceived) a/Source/WebCore/svg/graphics/SVGImage.cpp_sec1
- a/Source/WebCore/svg/graphics/SVGImage.cpp -1 / +1 lines
372		372
373	ASSERT(loader.activeDocumentLoader()); // DocumentLoader should have been created by frame->init().	373	ASSERT(loader.activeDocumentLoader()); // DocumentLoader should have been created by frame->init().
374	loader.activeDocumentLoader()->writer()->setMIMEType("image/svg+xml");	374	loader.activeDocumentLoader()->writer()->setMIMEType("image/svg+xml");
375	loader.activeDocumentLoader()->writer()->begin(KURL()); // create the empty document	375	loader.activeDocumentLoader()->writer()->begin(URL()); // create the empty document
376	loader.activeDocumentLoader()->writer()->addData(data()->data(), data()->size());	376	loader.activeDocumentLoader()->writer()->addData(data()->data(), data()->size());
377	loader.activeDocumentLoader()->writer()->end();	377	loader.activeDocumentLoader()->writer()->end();
378		378



    ActiveDOMObject::contextDestroyed(); 
}

URL AbstractWorker::resolveURL(const String& url, ExceptionCode& ec)
{
    if (url.isEmpty()) {
        ec = SYNTAX_ERR;
        return URL();
    }

    // FIXME: This should use the dynamic global scope (bug #27887)
    URL scriptURL = scriptExecutionContext()->completeURL(url);
    if (!scriptURL.isValid()) {
        ec = SYNTAX_ERR;
        return URL();
    }

    if (!scriptExecutionContext()->securityOrigin()->canRequest(scriptURL)) {
        ec = SECURITY_ERR;
        return URL();
    }

    if (scriptExecutionContext()->contentSecurityPolicy() && !scriptExecutionContext()->contentSecurityPolicy()->allowScriptFromSource(scriptURL)) {
        ec = SECURITY_ERR;
        return URL();
    }

    return scriptURL;




namespace WebCore {

    class URL;
    class ScriptExecutionContext;

    class AbstractWorker : public RefCounted<AbstractWorker>, public ActiveDOMObject, public EventTargetWithInlineData {


    protected:
        // Helper function that converts a URL to an absolute URL and checks the result for validity.
        URL resolveURL(const String& url, ExceptionCode& ec);
        intptr_t asID() const { return reinterpret_cast<intptr_t>(this); }

    private:




namespace WebCore {

PassRefPtr<DedicatedWorkerGlobalScope> DedicatedWorkerGlobalScope::create(const URL& url, const String& userAgent, PassOwnPtr<GroupSettings> settings, DedicatedWorkerThread* thread, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin)
{
    RefPtr<DedicatedWorkerGlobalScope> context = adoptRef(new DedicatedWorkerGlobalScope(url, userAgent, settings, thread, topOrigin));
    context->applyContentSecurityPolicyFromString(contentSecurityPolicy, contentSecurityPolicyType);
    return context.release();
}

DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(const URL& url, const String& userAgent, PassOwnPtr<GroupSettings> settings, DedicatedWorkerThread* thread, PassRefPtr<SecurityOrigin> topOrigin)
    : WorkerGlobalScope(url, userAgent, settings, thread, topOrigin)
{
}



    class DedicatedWorkerGlobalScope : public WorkerGlobalScope {
    public:
        typedef WorkerGlobalScope Base;
        static PassRefPtr<DedicatedWorkerGlobalScope> create(const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, DedicatedWorkerThread*, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin);
        virtual ~DedicatedWorkerGlobalScope();

        virtual bool isDedicatedWorkerGlobalScope() const OVERRIDE { return true; }

        DedicatedWorkerThread* thread();

    private:
        DedicatedWorkerGlobalScope(const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, DedicatedWorkerThread*, PassRefPtr<SecurityOrigin> topOrigin);
    };

} // namespace WebCore




namespace WebCore {

PassRefPtr<DedicatedWorkerThread> DedicatedWorkerThread::create(const URL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerLoaderProxy& workerLoaderProxy, WorkerObjectProxy& workerObjectProxy, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
{
    return adoptRef(new DedicatedWorkerThread(scriptURL, userAgent, settings, sourceCode, workerLoaderProxy, workerObjectProxy, startMode, contentSecurityPolicy, contentSecurityPolicyType, topOrigin));
}

DedicatedWorkerThread::DedicatedWorkerThread(const URL& url, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerLoaderProxy& workerLoaderProxy, WorkerObjectProxy& workerObjectProxy, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
    : WorkerThread(url, userAgent, settings, sourceCode, workerLoaderProxy, workerObjectProxy, startMode, contentSecurityPolicy, contentSecurityPolicyType, topOrigin)
    , m_workerObjectProxy(workerObjectProxy)
{

{
}

PassRefPtr<WorkerGlobalScope> DedicatedWorkerThread::createWorkerGlobalScope(const URL& url, const String& userAgent, PassOwnPtr<GroupSettings> settings, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin> topOrigin)
{
    return DedicatedWorkerGlobalScope::create(url, userAgent, settings, this, contentSecurityPolicy, contentSecurityPolicyType, topOrigin);
}




    class DedicatedWorkerThread : public WorkerThread {
    public:
        static PassRefPtr<DedicatedWorkerThread> create(const URL& scriptURL, const String& userAgent, const GroupSettings*, const String& sourceCode, WorkerLoaderProxy&, WorkerObjectProxy&, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType, const SecurityOrigin* topOrigin);
        WorkerObjectProxy& workerObjectProxy() const { return m_workerObjectProxy; }
        virtual ~DedicatedWorkerThread();

    protected:
        virtual PassRefPtr<WorkerGlobalScope> createWorkerGlobalScope(const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType, PassRefPtr<SecurityOrigin> topOrigin) OVERRIDE;
        virtual void runEventLoop() OVERRIDE;

    private:
        DedicatedWorkerThread(const URL&, const String& userAgent, const GroupSettings*, const String& sourceCode, WorkerLoaderProxy&, WorkerObjectProxy&, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType, const SecurityOrigin* topOrigin);

        WorkerObjectProxy& m_workerObjectProxy;
    };




class SharedWorkerProxy : public ThreadSafeRefCounted<SharedWorkerProxy>, public WorkerLoaderProxy, public WorkerReportingProxy {
public:
    static PassRefPtr<SharedWorkerProxy> create(const String& name, const URL& url, PassRefPtr<SecurityOrigin> origin) { return adoptRef(new SharedWorkerProxy(name, url, origin)); }

    void setThread(PassRefPtr<SharedWorkerThread> thread) { m_thread = thread; }
    SharedWorkerThread* thread() { return m_thread.get(); }
    bool isClosing() const { return m_closing; }
    URL url() const
    {
        // Don't use m_url.copy() because it isn't a threadsafe method.
        return URL(ParsedURLString, m_url.string().isolatedCopy());
    }

    String name() const { return m_name.isolatedCopy(); }
    bool matches(const String& name, PassRefPtr<SecurityOrigin> origin, const URL& urlToMatch) const;

    // WorkerLoaderProxy
    virtual void postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task>);

    GroupSettings* groupSettings() const; // Page GroupSettings used by worker thread.

private:
    SharedWorkerProxy(const String& name, const URL&, PassRefPtr<SecurityOrigin>);
    void close();

    bool m_closing;
    String m_name;
    URL m_url;
    // The thread is freed when the proxy is destroyed, so we need to make sure that the proxy stays around until the SharedWorkerGlobalScope exits.
    RefPtr<SharedWorkerThread> m_thread;
    RefPtr<SecurityOrigin> m_origin;

    Mutex m_workerDocumentsLock;
};

SharedWorkerProxy::SharedWorkerProxy(const String& name, const URL& url, PassRefPtr<SecurityOrigin> origin)
    : m_closing(false)
    , m_name(name.isolatedCopy())
    , m_url(url.copy())

    ASSERT(m_origin->hasOneRef());
}

bool SharedWorkerProxy::matches(const String& name, PassRefPtr<SecurityOrigin> origin, const URL& urlToMatch) const
{
    // If the origins don't match, or the names don't match, then this is not the proxy we are looking for.
    if (!origin->equal(m_origin.get()))

class SharedWorkerScriptLoader : public RefCounted<SharedWorkerScriptLoader>, private WorkerScriptLoaderClient {
public:
    SharedWorkerScriptLoader(PassRefPtr<SharedWorker>, PassOwnPtr<MessagePortChannel>, PassRefPtr<SharedWorkerProxy>);
    void load(const URL&);

private:
    // WorkerScriptLoaderClient callbacks

{
}

void SharedWorkerScriptLoader::load(const URL& url)
{
    // Stay alive (and keep the SharedWorker and JS wrapper alive) until the load finishes.
    this->ref();

        m_proxies[i]->documentDetached(document);
}

void DefaultSharedWorkerRepository::connectToWorker(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const URL& url, const String& name, ExceptionCode& ec)
{
    MutexLocker lock(m_lock);
    ASSERT(worker->scriptExecutionContext()->securityOrigin()->canAccess(SecurityOrigin::create(url).get()));

}

// Creates a new SharedWorkerProxy or returns an existing one from the repository. Must only be called while the repository mutex is held.
PassRefPtr<SharedWorkerProxy> DefaultSharedWorkerRepository::getProxy(const String& name, const URL& url)
{
    // Look for an existing worker, and create one if it doesn't exist.
    // Items in the cache are freed on another thread, so do a threadsafe copy of the URL before creating the origin,
    // to make sure no references to external strings linger.
    RefPtr<SecurityOrigin> origin = SecurityOrigin::create(URL(ParsedURLString, url.string().isolatedCopy()));
    for (unsigned i = 0; i < m_proxies.size(); i++) {
        if (!m_proxies[i]->isClosing() && m_proxies[i]->matches(name, origin, url))
            return m_proxies[i];



namespace WebCore {

    class Document;
    class URL;
    class MessagePortChannel;
    class ScriptExecutionContext;
    class SharedWorker;

        void workerScriptLoaded(SharedWorkerProxy&, const String& userAgent, const String& workerScript, PassOwnPtr<MessagePortChannel>, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType);

        // Internal implementation of SharedWorkerRepository::connect()
        void connectToWorker(PassRefPtr<SharedWorker>, PassOwnPtr<MessagePortChannel>, const URL&, const String& name, ExceptionCode&);

        // Notification that a document has been detached.
        void documentDetached(Document*);

        DefaultSharedWorkerRepository();
        ~DefaultSharedWorkerRepository();

        PassRefPtr<SharedWorkerProxy> getProxy(const String& name, const URL&);
        // Mutex used to protect internal data structures.
        Mutex m_lock;




#include "ExceptionCode.h"
#include "FeatureObserver.h"
#include "InspectorInstrumentation.h"
#include "URL.h"
#include "MessageChannel.h"
#include "MessagePort.h"
#include "ScriptExecutionContext.h"


    worker->suspendIfNeeded();

    URL scriptURL = worker->resolveURL(url, ec);
    if (scriptURL.isEmpty())
        return 0;




}

// static
PassRefPtr<SharedWorkerGlobalScope> SharedWorkerGlobalScope::create(const String& name, const URL& url, const String& userAgent, PassOwnPtr<GroupSettings> settings, SharedWorkerThread* thread, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
{
    RefPtr<SharedWorkerGlobalScope> context = adoptRef(new SharedWorkerGlobalScope(name, url, userAgent, settings, thread));
    context->applyContentSecurityPolicyFromString(contentSecurityPolicy, contentSecurityPolicyType);
    return context.release();
}

SharedWorkerGlobalScope::SharedWorkerGlobalScope(const String& name, const URL& url, const String& userAgent, PassOwnPtr<GroupSettings> settings, SharedWorkerThread* thread)
    : WorkerGlobalScope(url, userAgent, settings, thread, 0)
    , m_name(name)
{



    class SharedWorkerGlobalScope : public WorkerGlobalScope {
    public:
        typedef WorkerGlobalScope Base;
        static PassRefPtr<SharedWorkerGlobalScope> create(const String& name, const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, SharedWorkerThread*, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType);
        virtual ~SharedWorkerGlobalScope();

        virtual bool isSharedWorkerGlobalScope() const OVERRIDE { return true; }

        SharedWorkerThread* thread();

    private:
        SharedWorkerGlobalScope(const String& name, const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, SharedWorkerThread*);
        virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack>) OVERRIDE;

        String m_name;

Lines 41-47 bool SharedWorkerRepository::isAvailable() a/Source/WebCore/workers/SharedWorkerRepository.cpp_sec1
- a/Source/WebCore/workers/SharedWorkerRepository.cpp -1 / +1 lines
41	return DefaultSharedWorkerRepository::instance().isAvailable();	41	return DefaultSharedWorkerRepository::instance().isAvailable();
42	}	42	}
43		43
44	void SharedWorkerRepository::connect(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const KURL& url, const String& name, ExceptionCode& ec)	44	void SharedWorkerRepository::connect(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const URL& url, const String& name, ExceptionCode& ec)
45	{	45	{
46	DefaultSharedWorkerRepository::instance().connectToWorker(worker, port, url, name, ec);	46	DefaultSharedWorkerRepository::instance().connectToWorker(worker, port, url, name, ec);
47	}	47	}



namespace WebCore {

    class Document;
    class URL;
    class MessagePortChannel;
    class SharedWorker;


        static bool isAvailable();

        // Connects the passed SharedWorker object with the specified worker thread, creating a new thread if necessary.
        static void connect(PassRefPtr<SharedWorker>, PassOwnPtr<MessagePortChannel>, const URL&, const String& name, ExceptionCode&);

        // Invoked when a document has been detached.
        static void documentDetached(Document*);




namespace WebCore {

PassRefPtr<SharedWorkerThread> SharedWorkerThread::create(const String& name, const URL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerLoaderProxy& workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
{
    return adoptRef(new SharedWorkerThread(name, scriptURL, userAgent, settings, sourceCode, workerLoaderProxy, workerReportingProxy, startMode, contentSecurityPolicy, contentSecurityPolicyType));
}

SharedWorkerThread::SharedWorkerThread(const String& name, const URL& url, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerLoaderProxy& workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType)
    : WorkerThread(url, userAgent, settings, sourceCode, workerLoaderProxy, workerReportingProxy, startMode, contentSecurityPolicy, contentSecurityPolicyType, 0)
    , m_name(name.isolatedCopy())
{

{
}

PassRefPtr<WorkerGlobalScope> SharedWorkerThread::createWorkerGlobalScope(const URL& url, const String& userAgent, PassOwnPtr<GroupSettings> settings, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, PassRefPtr<SecurityOrigin>)
{
    return SharedWorkerGlobalScope::create(m_name, url, userAgent, settings, this, contentSecurityPolicy, contentSecurityPolicyType);
}




    class SharedWorkerThread : public WorkerThread {
    public:
        static PassRefPtr<SharedWorkerThread> create(const String& name, const URL&, const String& userAgent, const GroupSettings*, const String& sourceCode, WorkerLoaderProxy&, WorkerReportingProxy&, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType);
        virtual ~SharedWorkerThread();

    protected:
        virtual PassRefPtr<WorkerGlobalScope> createWorkerGlobalScope(const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType, PassRefPtr<SecurityOrigin> topOrigin) OVERRIDE;

    private:
        SharedWorkerThread(const String& name, const URL&, const String& userAgent, const GroupSettings*, const String& sourceCode, WorkerLoaderProxy&, WorkerReportingProxy&, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType);

        String m_name;
    };

Lines 84-90 PassRefPtr<Worker> Worker::create(ScriptExecutionContext* context, const String& a/Source/WebCore/workers/Worker.cpp_sec1
- a/Source/WebCore/workers/Worker.cpp -1 / +1 lines
84		84
85	worker->suspendIfNeeded();	85	worker->suspendIfNeeded();
86		86
87	KURL scriptURL = worker->resolveURL(url, ec);	87	URL scriptURL = worker->resolveURL(url, ec);
88	if (scriptURL.isEmpty())	88	if (scriptURL.isEmpty())
89	return 0;	89	return 0;
90		90



#include "Event.h"
#include "EventException.h"
#include "InspectorConsoleInstrumentation.h"
#include "URL.h"
#include "MessagePort.h"
#include "NotImplemented.h"
#include "ScheduledAction.h"

    virtual bool isCleanupTask() const { return true; }
};

WorkerGlobalScope::WorkerGlobalScope(const URL& url, const String& userAgent, PassOwnPtr<GroupSettings> settings, WorkerThread* thread, PassRefPtr<SecurityOrigin> topOrigin)
    : m_url(url)
    , m_userAgent(userAgent)
    , m_groupSettings(settings)

    contentSecurityPolicy()->didReceiveHeader(policy, contentSecurityPolicyType);
}

URL WorkerGlobalScope::completeURL(const String& url) const
{
    // Always return a null URL when passed a null string.
    // FIXME: Should we change the URL constructor to have this behavior?
    if (url.isNull())
        return URL();
    // Always use UTF-8 in Workers.
    return URL(m_url, url);
}

String WorkerGlobalScope::userAgent(const URL&) const
{
    return m_userAgent;
}

    ASSERT(contentSecurityPolicy());
    ec = 0;
    Vector<String>::const_iterator urlsEnd = urls.end();
    Vector<URL> completedURLs;
    for (Vector<String>::const_iterator it = urls.begin(); it != urlsEnd; ++it) {
        const URL& url = scriptExecutionContext()->completeURL(*it);
        if (!url.isValid()) {
            ec = SYNTAX_ERR;
            return;
        }
        completedURLs.append(url);
    }
    Vector<URL>::const_iterator end = completedURLs.end();

    for (Vector<URL>::const_iterator it = completedURLs.begin(); it != end; ++it) {
        RefPtr<WorkerScriptLoader> scriptLoader(WorkerScriptLoader::create());
#if PLATFORM(BLACKBERRY)
        scriptLoader->setTargetType(ResourceRequest::TargetIsScript);



        virtual bool isSharedWorkerGlobalScope() const { return false; }
        virtual bool isDedicatedWorkerGlobalScope() const { return false; }

        virtual const URL& url() const OVERRIDE FINAL { return m_url; }
        virtual URL completeURL(const String&) const OVERRIDE FINAL;

        const GroupSettings* groupSettings() { return m_groupSettings.get(); }
        virtual String userAgent(const URL&) const;

        virtual void disableEval(const String& errorMessage) OVERRIDE;


        virtual SecurityOrigin* topOrigin() const OVERRIDE { return m_topOrigin.get(); }

    protected:
        WorkerGlobalScope(const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, WorkerThread*, PassRefPtr<SecurityOrigin> topOrigin);
        void applyContentSecurityPolicyFromString(const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType);

        virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack>) OVERRIDE;


        virtual WorkerEventQueue& eventQueue() const OVERRIDE FINAL;

        URL m_url;
        String m_userAgent;
        OwnPtr<GroupSettings> m_groupSettings;





namespace WebCore {

    class URL;
    class Worker;

    // A proxy to talk to the worker context.


        virtual ~WorkerGlobalScopeProxy() { }

        virtual void startWorkerGlobalScope(const URL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode) = 0;

        virtual void terminateWorkerGlobalScope() = 0;





#if ENABLE(WORKERS)

#include "URL.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>


    class WorkerLocation : public RefCounted<WorkerLocation> {
    public:
        static PassRefPtr<WorkerLocation> create(const URL& url)
        {
            return adoptRef(new WorkerLocation(url));
        }

        const URL& url() const { return m_url; }

        String href() const;


        String toString() const { return href(); }

    private:
        explicit WorkerLocation(const URL& url) : m_url(url) { }

        URL m_url;
    };

} // namespace WebCore

Lines 296-302 WorkerMessagingProxy::~WorkerMessagingProxy() a/Source/WebCore/workers/WorkerMessagingProxy.cpp_sec1
- a/Source/WebCore/workers/WorkerMessagingProxy.cpp -1 / +1 lines
296	\|\| (m_scriptExecutionContext->isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(m_scriptExecutionContext.get())->thread()->threadID()));	296	\|\| (m_scriptExecutionContext->isWorkerGlobalScope() && currentThread() == static_cast<WorkerGlobalScope*>(m_scriptExecutionContext.get())->thread()->threadID()));
297	}	297	}
298		298
299	void WorkerMessagingProxy::startWorkerGlobalScope(const KURL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode startMode)	299	void WorkerMessagingProxy::startWorkerGlobalScope(const URL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode startMode)
300	{	300	{
301	// FIXME: This need to be revisited when we support nested worker one day	301	// FIXME: This need to be revisited when we support nested worker one day
302	ASSERT(m_scriptExecutionContext->isDocument());	302	ASSERT(m_scriptExecutionContext->isDocument());

Lines 53-59 namespace WebCore { a/Source/WebCore/workers/WorkerMessagingProxy.h_sec1
- a/Source/WebCore/workers/WorkerMessagingProxy.h -1 / +1 lines
53		53
54	// Implementations of WorkerGlobalScopeProxy.	54	// Implementations of WorkerGlobalScopeProxy.
55	// (Only use these methods in the worker object thread.)	55	// (Only use these methods in the worker object thread.)
56	virtual void startWorkerGlobalScope(const KURL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode) OVERRIDE;	56	virtual void startWorkerGlobalScope(const URL& scriptURL, const String& userAgent, const String& sourceCode, WorkerThreadStartMode) OVERRIDE;
57	virtual void terminateWorkerGlobalScope() OVERRIDE;	57	virtual void terminateWorkerGlobalScope() OVERRIDE;
58	virtual void postMessageToWorkerGlobalScope(PassRefPtr<SerializedScriptValue>, PassOwnPtr<MessagePortChannelArray>) OVERRIDE;	58	virtual void postMessageToWorkerGlobalScope(PassRefPtr<SerializedScriptValue>, PassOwnPtr<MessagePortChannelArray>) OVERRIDE;
59	virtual bool hasPendingActivity() const OVERRIDE;	59	virtual bool hasPendingActivity() const OVERRIDE;



{
}

void WorkerScriptLoader::loadSynchronously(ScriptExecutionContext* scriptExecutionContext, const URL& url, CrossOriginRequestPolicy crossOriginRequestPolicy)
{
    m_url = url;


    WorkerThreadableLoader::loadResourceSynchronously(static_cast<WorkerGlobalScope*>(scriptExecutionContext), *request, *this, options);
}
    
void WorkerScriptLoader::loadAsynchronously(ScriptExecutionContext* scriptExecutionContext, const URL& url, CrossOriginRequestPolicy crossOriginRequestPolicy, WorkerScriptLoaderClient* client)
{
    ASSERT(client);
    m_client = client;

    m_threadableLoader = ThreadableLoader::create(scriptExecutionContext, this, *request, options);
}

const URL& WorkerScriptLoader::responseURL() const
{
    ASSERT(!failed());
    return m_responseURL;




#if ENABLE(WORKERS)

#include "URL.h"
#include "ResourceRequest.h"
#include "ThreadableLoader.h"
#include "ThreadableLoaderClient.h"

            return adoptRef(new WorkerScriptLoader());
        }

        void loadSynchronously(ScriptExecutionContext*, const URL&, CrossOriginRequestPolicy);
        void loadAsynchronously(ScriptExecutionContext*, const URL&, CrossOriginRequestPolicy, WorkerScriptLoaderClient*);

        void notifyError();

        String script();
        const URL& url() const { return m_url; }
        const URL& responseURL() const;
        bool failed() const { return m_failed; }
        unsigned long identifier() const { return m_identifier; }


        String m_responseEncoding;        
        RefPtr<TextResourceDecoder> m_decoder;
        StringBuilder m_script;
        URL m_url;
        URL m_responseURL;
        bool m_failed;
        unsigned long m_identifier;
        bool m_finishing;




#include "DedicatedWorkerGlobalScope.h"
#include "InspectorInstrumentation.h"
#include "KURL.h"
#include "ScriptSourceCode.h"
#include "ScriptValue.h"
#include "SecurityOrigin.h"
#include "ThreadGlobalData.h"
#include "URL.h"
#include <utility>
#include <wtf/Noncopyable.h>
#include <wtf/text/WTFString.h>

struct WorkerThreadStartupData {
    WTF_MAKE_NONCOPYABLE(WorkerThreadStartupData); WTF_MAKE_FAST_ALLOCATED;
public:
    static PassOwnPtr<WorkerThreadStartupData> create(const URL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
    {
        return adoptPtr(new WorkerThreadStartupData(scriptURL, userAgent, settings, sourceCode, startMode, contentSecurityPolicy, contentSecurityPolicyType, topOrigin));
    }

    URL m_scriptURL;
    String m_userAgent;
    OwnPtr<GroupSettings> m_groupSettings;
    String m_sourceCode;

    ContentSecurityPolicy::HeaderType m_contentSecurityPolicyType;
    RefPtr<SecurityOrigin> m_topOrigin;
private:
    WorkerThreadStartupData(const URL& scriptURL, const String& userAgent, const GroupSettings*, const String& sourceCode, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin);
};

WorkerThreadStartupData::WorkerThreadStartupData(const URL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
    : m_scriptURL(scriptURL.copy())
    , m_userAgent(userAgent.isolatedCopy())
    , m_sourceCode(sourceCode.isolatedCopy())

    m_groupSettings->setIndexedDBDatabasePath(settings->indexedDBDatabasePath().isolatedCopy());
}

WorkerThread::WorkerThread(const URL& scriptURL, const String& userAgent, const GroupSettings* settings, const String& sourceCode, WorkerLoaderProxy& workerLoaderProxy, WorkerReportingProxy& workerReportingProxy, WorkerThreadStartMode startMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType contentSecurityPolicyType, const SecurityOrigin* topOrigin)
    : m_threadID(0)
    , m_workerLoaderProxy(workerLoaderProxy)
    , m_workerReportingProxy(workerReportingProxy)




namespace WebCore {

    class URL;
    class NotificationClient;
    class SecurityOrigin;
    class WorkerGlobalScope;

#endif

    protected:
        WorkerThread(const URL&, const String& userAgent, const GroupSettings*,  const String& sourceCode, WorkerLoaderProxy&, WorkerReportingProxy&, WorkerThreadStartMode, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType, const SecurityOrigin* topOrigin);

        // Factory method for creating a new worker context for the thread.
        virtual PassRefPtr<WorkerGlobalScope> createWorkerGlobalScope(const URL&, const String& userAgent, PassOwnPtr<GroupSettings>, const String& contentSecurityPolicy, ContentSecurityPolicy::HeaderType, PassRefPtr<SecurityOrigin> topOrigin) = 0;

        // Executes the event loop for the worker thread. Derived classes can override to perform actions before/after entering the event loop.
        virtual void runEventLoop();

Lines 36-42 PassRefPtr<Document> DOMParser::parseFromString(const String& str, const String& a/Source/WebCore/xml/DOMParser.cpp_sec1
- a/Source/WebCore/xml/DOMParser.cpp -1 / +1 lines
36	return 0;	36	return 0;
37	}	37	}
38		38
39	RefPtr<Document> doc = DOMImplementation::createDocument(contentType, 0, KURL(), false);	39	RefPtr<Document> doc = DOMImplementation::createDocument(contentType, 0, URL(), false);
40	doc->setContent(str);	40	doc->setContent(str);
41	return doc.release();	41	return doc.release();
42	}	42	}



        && !name.startsWith(staticData->m_secHeaderPrefix, false);
}

void XMLHttpRequest::open(const String& method, const URL& url, ExceptionCode& ec)
{
    open(method, url, true, ec);
}

void XMLHttpRequest::open(const String& method, const URL& url, bool async, ExceptionCode& ec)
{
    internalAbort();
    State previousState = m_state;

        m_state = OPENED;
}

void XMLHttpRequest::open(const String& method, const URL& url, bool async, const String& user, ExceptionCode& ec)
{
    URL urlWithCredentials(url);
    urlWithCredentials.setUser(user);

    open(method, urlWithCredentials, async, ec);
}

void XMLHttpRequest::open(const String& method, const URL& url, bool async, const String& user, const String& password, ExceptionCode& ec)
{
    URL urlWithCredentials(url);
    urlWithCredentials.setUser(user);
    urlWithCredentials.setPass(password);




    virtual EventTargetInterface eventTargetInterface() const OVERRIDE FINAL { return XMLHttpRequestEventTargetInterfaceType; }
    virtual ScriptExecutionContext* scriptExecutionContext() const OVERRIDE FINAL { return ActiveDOMObject::scriptExecutionContext(); }

    const URL& url() const { return m_url; }
    String statusText(ExceptionCode&) const;
    int status(ExceptionCode&) const;
    State readyState() const;
    bool withCredentials() const { return m_includeCredentials; }
    void setWithCredentials(bool, ExceptionCode&);
    void open(const String& method, const URL&, ExceptionCode&);
    void open(const String& method, const URL&, bool async, ExceptionCode&);
    void open(const String& method, const URL&, bool async, const String& user, ExceptionCode&);
    void open(const String& method, const URL&, bool async, const String& user, const String& password, ExceptionCode&);
    void send(ExceptionCode&);
    void send(Document*, ExceptionCode&);
    void send(const String&, ExceptionCode&);


    OwnPtr<XMLHttpRequestUpload> m_upload;

    URL m_url;
    String m_method;
    HTTPHeaderMap m_requestHeaders;
    RefPtr<FormData> m_requestEntityBody;



        m_cachedSheet->removeClient(this);
}

void XSLImportRule::setXSLStyleSheet(const String& href, const URL& baseURL, const String& sheet)
{
    if (m_styleSheet)
        m_styleSheet->setParentStyleSheet(0);

    XSLStyleSheet* parentSheet = parentStyleSheet();
    if (!parentSheet->baseURL().isNull())
        // use parent styleheet's URL as the base URL
        absHref = URL(parentSheet->baseURL(), m_strHref).string();
    
    // Check for a cycle in our import chain.  If we encounter a stylesheet
    // in our parent chain with the same URL, then just bail.

Lines 56-62 public: a/Source/WebCore/xml/XSLImportRule.h_sec1
- a/Source/WebCore/xml/XSLImportRule.h -1 / +1 lines
56	private:	56	private:
57	XSLImportRule(XSLStyleSheet* parentSheet, const String& href);	57	XSLImportRule(XSLStyleSheet* parentSheet, const String& href);
58		58
59	virtual void setXSLStyleSheet(const String& href, const KURL& baseURL, const String& sheet);	59	virtual void setXSLStyleSheet(const String& href, const URL& baseURL, const String& sheet);
60		60
61	XSLStyleSheet* m_parentStyleSheet;	61	XSLStyleSheet* m_parentStyleSheet;
62	String m_strHref;	62	String m_strHref;



    
class XSLStyleSheet FINAL : public StyleSheet {
public:
    static PassRefPtr<XSLStyleSheet> create(XSLImportRule* parentImport, const String& originalURL, const URL& finalURL)
    {
        return adoptRef(new XSLStyleSheet(parentImport, originalURL, finalURL));
    }
    static PassRefPtr<XSLStyleSheet> create(ProcessingInstruction* parentNode, const String& originalURL, const URL& finalURL)
    {
        return adoptRef(new XSLStyleSheet(parentNode, originalURL, finalURL, false));
    }
    static PassRefPtr<XSLStyleSheet> createEmbedded(ProcessingInstruction* parentNode, const URL& finalURL)
    {
        return adoptRef(new XSLStyleSheet(parentNode, finalURL.string(), finalURL, true));
    }

    // Taking an arbitrary node is unsafe, because owner node pointer can become stale.
    // XSLTProcessor ensures that the stylesheet doesn't outlive its parent, in part by not exposing it to JavaScript.
    static PassRefPtr<XSLStyleSheet> createForXSLTProcessor(Node* parentNode, const String& originalURL, const URL& finalURL)
    {
        return adoptRef(new XSLStyleSheet(parentNode, originalURL, finalURL, false));
    }

    
    void checkLoaded();
    
    const URL& finalURL() const { return m_finalURL; }

    void loadChildSheets();
    void loadChildSheet(const String& href);

    virtual String title() const OVERRIDE { return emptyString(); }

    virtual void clearOwnerNode() OVERRIDE { m_ownerNode = 0; }
    virtual URL baseURL() const OVERRIDE { return m_finalURL; }
    virtual bool isLoading() const OVERRIDE;

    virtual bool isXSLStyleSheet() const OVERRIDE { return true; }

private:
    XSLStyleSheet(Node* parentNode, const String& originalURL, const URL& finalURL, bool embedded);
    XSLStyleSheet(XSLImportRule* parentImport, const String& originalURL, const URL& finalURL);
    
    Node* m_ownerNode;
    String m_originalURL;
    URL m_finalURL;
    bool m_isDisabled;

    Vector<OwnPtr<XSLImportRule> > m_children;




namespace WebCore {

XSLStyleSheet::XSLStyleSheet(XSLImportRule* parentRule, const String& originalURL, const URL& finalURL)
    : m_ownerNode(0)
    , m_originalURL(originalURL)
    , m_finalURL(finalURL)

{
}

XSLStyleSheet::XSLStyleSheet(Node* parentNode, const String& originalURL, const URL& finalURL,  bool embedded)
    : m_ownerNode(parentNode)
    , m_originalURL(originalURL)
    , m_finalURL(finalURL)




    RefPtr<Document> result;
    if (sourceMIMEType == "text/plain") {
        result = Document::create(frame, sourceIsDocument ? ownerDocument->url() : URL());
        transformTextStringToXHTMLDocumentString(documentSource);
    } else
        result = DOMImplementation::createDocument(sourceMIMEType, frame, sourceIsDocument ? ownerDocument->url() : URL(), false);

    // Before parsing, we need to save & detach the old document and get the new document
    // in place. We have to do this only if we're rendering the result document.

Lines 120-126 static xmlDocPtr docLoaderFunc(const xmlChar* uri, a/Source/WebCore/xml/XSLTProcessorLibxslt.cpp_sec1
- a/Source/WebCore/xml/XSLTProcessorLibxslt.cpp -1 / +1 lines
120	case XSLT_LOAD_DOCUMENT: {	120	case XSLT_LOAD_DOCUMENT: {
121	xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;	121	xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;
122	xmlChar* base = xmlNodeGetBase(context->document->doc, context->node);	122	xmlChar* base = xmlNodeGetBase(context->document->doc, context->node);
123	KURL url(KURL(ParsedURLString, reinterpret_cast<const char>(base)), reinterpret_cast<const char>(uri));	123	URL url(URL(ParsedURLString, reinterpret_cast<const char>(base)), reinterpret_cast<const char>(uri));
124	xmlFree(base);	124	xmlFree(base);
125	ResourceError error;	125	ResourceError error;
126	ResourceResponse response;	126	ResourceResponse response;



    xmlSwitchEncoding(ctxt, BOMHighByte == 0xFF ? XML_CHAR_ENCODING_UTF16LE : XML_CHAR_ENCODING_UTF16BE);
}

static bool shouldAllowExternalLoad(const URL& url)
{
    String urlString = url.string();


    ASSERT(XMLDocumentParserScope::currentCachedResourceLoader);
    ASSERT(currentThread() == libxmlLoaderThread);

    URL url(URL(), uri);

    if (!shouldAllowExternalLoad(url))
        return &globalDescriptor;



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * WebKit.vcxproj/WebKitExportGenerator/WebKitExports.def.in:
        Let the script to try to rename here.

2013-09-26  Eric Carlson  <eric.carlson@apple.com>

        [MediaStream] make MediaStream testable

Lines 393-399 EXPORTS a/Source/WebKit/WebKit.vcxproj/WebKitExportGenerator/WebKitExports.def.in_sec1
- a/Source/WebKit/WebKit.vcxproj/WebKitExportGenerator/WebKitExports.def.in -1 / +1 lines
393	symbolWithPointer(?addAuthorSheet@DocumentStyleSheetCollection@WebCore@@QAEXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z, ?addAuthorSheet@DocumentStyleSheetCollection@WebCore@@QEAAXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z)	393	symbolWithPointer(?addAuthorSheet@DocumentStyleSheetCollection@WebCore@@QAEXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z, ?addAuthorSheet@DocumentStyleSheetCollection@WebCore@@QEAAXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z)
394	symbolWithPointer(?parseString@StyleSheetContents@WebCore@@QAE_NABVString@WTF@@@Z, ?parseString@StyleSheetContents@WebCore@@QEAA_NAEBVString@WTF@@@Z)	394	symbolWithPointer(?parseString@StyleSheetContents@WebCore@@QAE_NABVString@WTF@@@Z, ?parseString@StyleSheetContents@WebCore@@QEAA_NAEBVString@WTF@@@Z)
395	symbolWithPointer(?emptyString@WTF@@YAABVString@1@XZ, ?emptyString@WTF@@YAAEBVString@1@XZ)	395	symbolWithPointer(?emptyString@WTF@@YAABVString@1@XZ, ?emptyString@WTF@@YAAEBVString@1@XZ)
396	symbolWithPointer(?invalidate@KURL@WebCore@@AAEXXZ, ?invalidate@KURL@WebCore@@AEAAXXZ)	396	symbolWithPointer(?invalidate@URL@WebCore@@AAEXXZ, ?invalidate@URL@WebCore@@AEAAXXZ)
397	symbolWithPointer(??0StyleSheetContents@WebCore@@AAE@PAVStyleRuleImport@1@ABVString@WTF@@ABUCSSParserContext@1@@Z, ??0StyleSheetContents@WebCore@@AEAA@PEAVStyleRuleImport@1@AEBVString@WTF@@AEBUCSSParserContext@1@@Z)	397	symbolWithPointer(??0StyleSheetContents@WebCore@@AAE@PAVStyleRuleImport@1@ABVString@WTF@@ABUCSSParserContext@1@@Z, ??0StyleSheetContents@WebCore@@AEAA@PEAVStyleRuleImport@1@AEBVString@WTF@@AEBUCSSParserContext@1@@Z)
398	symbolWithPointer(?addUserSheet@DocumentStyleSheetCollection@WebCore@@QAEXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z, ?addUserSheet@DocumentStyleSheetCollection@WebCore@@QEAAXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z)	398	symbolWithPointer(?addUserSheet@DocumentStyleSheetCollection@WebCore@@QAEXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z, ?addUserSheet@DocumentStyleSheetCollection@WebCore@@QEAAXV?$PassRefPtr@VStyleSheetContents@WebCore@@@WTF@@@Z)
399	symbolWithPointer(??1StyleSheetContents@WebCore@@QAE@XZ, ??1StyleSheetContents@WebCore@@QEAA@XZ)	399	symbolWithPointer(??1StyleSheetContents@WebCore@@QAE@XZ, ??1StyleSheetContents@WebCore@@QEAA@XZ)



#include "WebCookieJar.h"

#include "CookieManager.h"
#include "URL.h"
#include <BlackBerryPlatformString.h>

using namespace WebCore;


std::vector<BlackBerry::Platform::String> WebCookieJar::cookies(const BlackBerry::Platform::String& url)
{
    URL kurl = URL(URL(), url);

    Vector<RefPtr<ParsedCookie> > rawCookies;
    cookieManager().getRawCookies(rawCookies, kurl, WithHttpOnlyCookies);


void WebCookieJar::setCookies(const BlackBerry::Platform::String& url, const std::vector<BlackBerry::Platform::String>& cookies)
{
    URL kurl = URL(URL(), url);
    Vector<String> coreCookies;
    for (size_t i = 0; i < cookies.size(); ++i)
        coreCookies.append(cookies[i]);

Lines 19-25 a/Source/WebKit/blackberry/Api/WebKitTextCodec.cpp_sec1
- a/Source/WebKit/blackberry/Api/WebKitTextCodec.cpp -1 / +1 lines
19	#include "config.h"	19	#include "config.h"
20	#include "WebKitTextCodec.h"	20	#include "WebKitTextCodec.h"
21		21
22	#include "KURL.h"	22	#include "URL.h"
23	#include "TextCodecICU.h"	23	#include "TextCodecICU.h"
24	#include <BlackBerryPlatformString.h>	24	#include <BlackBerryPlatformString.h>
25	#include <wtf/Vector.h>	25	#include <wtf/Vector.h>



const double zoomFactorEpsilon = 0.0001;

// Helper function to parse a URL and fill in missing parts.
static URL parseUrl(const String& url)
{
    String urlString(url);
    URL kurl = URL(URL(), urlString);
    if (kurl.protocol().isEmpty()) {
        urlString.insert("http://", 0);
        kurl = URL(URL(), urlString);
    }

    return kurl;


class DeferredTaskLoadManualScript: public DeferredTask<&WebPagePrivate::m_wouldLoadManualScript> {
public:
    explicit DeferredTaskLoadManualScript(WebPagePrivate* webPagePrivate, const URL& url)
        : DeferredTaskType(webPagePrivate)
    {
        webPagePrivate->m_cachedManualScript = url;

    } else
        m_mainFrame->setInViewSourceMode(false);

    URL kurl = parseUrl(urlString);
    if (protocolIs(kurl, "javascript")) {
        // Never run javascript while loading is deferred.
        if (m_page->defersLoading())


void WebPagePrivate::loadString(const BlackBerry::Platform::String& string, const BlackBerry::Platform::String& baseURL, const BlackBerry::Platform::String& contentType, const BlackBerry::Platform::String& failingURL)
{
    URL kurl = parseUrl(baseURL);
    ResourceRequest request(kurl);
    WTF::RefPtr<SharedBuffer> buffer
        = SharedBuffer::create(string.c_str(), string.length());
    SubstituteData substituteData(buffer,
        extractMIMETypeFromMediaType(contentType),
        extractCharsetFromMediaType(contentType),
        !failingURL.empty() ? parseUrl(failingURL) : URL());
    m_mainFrame->loader().load(FrameLoadRequest(m_mainFrame, request, substituteData));
}


        return false;
    }
    String str = String(data, lengthCopied);
    ScriptSourceCode sourceCode(str, URL());
    return d->executeJavaScriptInIsolatedWorld(sourceCode, returnType, returnValue);
}

bool WebPage::executeJavaScriptInIsolatedWorld(const BlackBerry::Platform::String& scriptUTF8, JavaScriptDataType& returnType, BlackBerry::Platform::String& returnValue)
{
    BLACKBERRY_ASSERT(scriptUTF8.isUtf8());
    ScriptSourceCode sourceCode(scriptUTF8, URL());
    return d->executeJavaScriptInIsolatedWorld(sourceCode, returnType, returnValue);
}


    if (source->isUnique())
        return;

    URL destination(URL(), destinationOrigin);
    SecurityPolicy::addOriginAccessWhitelistEntry(*source, destination.protocol(), destination.host(), allowDestinationSubdomains);
}


    if (source->isUnique())
        return;

    URL destination(URL(), destinationOrigin);
    SecurityPolicy::removeOriginAccessWhitelistEntry(*source, destination.protocol(), destination.host(), allowDestinationSubdomains);
}


    return m_client->isActive();
}

void WebPagePrivate::authenticationChallenge(const URL& url, const ProtectionSpace& protectionSpace, const Credential& inputCredential)
{
    AuthenticationChallengeManager* authmgr = AuthenticationChallengeManager::instance();
    BlackBerry::Platform::String username;

    Node* linkNode = node->enclosingLinkEventParentOrSelf();
    // Set link url only when the node is linked image, or text inside anchor. Prevent CCM popup when long press non-link element(eg. button) inside an anchor.
    if (linkNode && (node == linkNode || node->isTextNode() || nodeIsImage)) {
        URL href;
        if (linkNode->isLink() && linkNode->hasAttributes()) {
            if (const Attribute* attribute = toElement(linkNode)->findAttributeByName(HTMLNames::hrefAttr))
                href = linkNode->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(attribute->value()));

    d->m_pagePopup->initialize(webPage);
}

String WebPagePrivate::findPatternStringForUrl(const URL& url) const
{
    if ((m_webSettings->shouldHandlePatternUrls() && protocolIs(url, "pattern"))
        || protocolIs(url, "tel")


    BlackBerry::Platform::String stylesheetURL = webSettings->userStyleSheetLocation();
    if (!stylesheetURL.empty())
        coreSettings->setUserStyleSheetLocation(URL(URL(), stylesheetURL));

    coreSettings->setFirstScheduledLayoutDelay(webSettings->firstScheduledLayoutDelay());
    coreSettings->setUseCache(webSettings->useWebKitCache());



#include "LayerRenderer.h"
#include <EGL/egl.h>
#endif
#include "URL.h"
#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
#include "NotificationManager.h"
#endif

    virtual int showAlertDialog(WebPageClient::AlertType atype);
    virtual bool isActive() const;
    virtual bool isVisible() const { return m_visible; }
    virtual void authenticationChallenge(const WebCore::URL&, const WebCore::ProtectionSpace&, const WebCore::Credential&);
    virtual SaveCredentialType notifyShouldSaveCredential(bool);
    virtual void syncProxyCredential(const WebCore::Credential&);



    // If this url should be handled as a pattern, returns the pattern
    // otherwise, returns an empty string.
    String findPatternStringForUrl(const WebCore::URL&) const;

    void suspendBackingStore();
    void resumeBackingStore();

    int m_cachedPopupListSelectedIndex;
    BlackBerry::Platform::String m_cachedDateTimeInput;
    BlackBerry::Platform::String m_cachedColorInput;
    WebCore::URL m_cachedManualScript;

    class DeferredTaskBase {
    public:



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-25  Brent Fulgham  <bfulgham@apple.com>

        Refactor RuntimeEnabledFeatures as a Singleton.



#include "HitTestResult.h"
#include "Icon.h"
#include "InputHandler.h"
#include "KURL.h"
#include "Node.h"
#include "NotImplemented.h"
#include "Page.h"

#include "SecurityOrigin.h"
#include "Settings.h"
#include "SharedPointer.h"
#include "URL.h"
#include "ViewportArguments.h"
#include "WebPage.h"
#include "WebPageClient.h"

    // Bail out early when we aren't allowed to display the target origin, otherwise,
    // it would be harmful and the window would be useless. This is the same check
    // as the one in FrameLoader::loadFrameRequest().
    const URL& url = request.resourceRequest().url();
    if (!request.requester()->canDisplay(url)) {
        frame->loader().reportLocalLoadFailed(frame, url.string());
        return 0;

Lines 24-30 a/Source/WebKit/blackberry/WebCoreSupport/CredentialManager.cpp_sec1
- a/Source/WebKit/blackberry/WebCoreSupport/CredentialManager.cpp -1 / +1 lines
24	#include "CredentialBackingStore.h"	24	#include "CredentialBackingStore.h"
25	#include "CredentialTransformData.h"	25	#include "CredentialTransformData.h"
26	#include "HTMLFormElement.h"	26	#include "HTMLFormElement.h"
27	#include "KURL.h"	27	#include "URL.h"
28	#include "Logging.h"	28	#include "Logging.h"
29	#include "PageClientBlackBerry.h"	29	#include "PageClientBlackBerry.h"
30		30

Lines 33-39 class String; a/Source/WebKit/blackberry/WebCoreSupport/CredentialManager.h_sec1
- a/Source/WebKit/blackberry/WebCoreSupport/CredentialManager.h -1 / +1 lines
33	}	33	}
34		34
35	namespace WebCore {	35	namespace WebCore {
36	class KURL;	36	class URL;
37	class ProtectionSpace;	37	class ProtectionSpace;
38	class CredentialTransformData;	38	class CredentialTransformData;
39		39



#include "CredentialTransformData.h"

#include "HTMLInputElement.h"
#include "URL.h"
#include <wtf/Vector.h>

namespace WebCore {

static const size_t maxPasswords = 3;

// Helper method to clear url of unneeded parts.
URL stripURL(const URL& url)
{
    URL strippedURL = url;
    strippedURL.setUser(String());
    strippedURL.setPass(String());
    strippedURL.setQuery(String());

    ASSERT(form);

    // Get the document URL
    URL fullOrigin(ParsedURLString, form->document()->documentURI());

    // Calculate the canonical action URL
    String action = form->action();
    if (action.isNull())
        action = ""; // missing 'action' attribute implies current URL
    URL fullAction = form->document()->completeURL(action);
    if (!fullAction.isValid())
        return;


    if (!isForSaving && m_oldPasswordElement)
        return;

    URL url = stripURL(fullOrigin);
    m_action = stripURL(fullAction);
    m_protectionSpace = ProtectionSpace(url.host(), url.port(), ProtectionSpaceServerHTTP, "Form", ProtectionSpaceAuthenticationSchemeHTMLForm);
    m_credential = Credential(m_userNameElement->value(), m_passwordElement->value(), CredentialPersistencePermanent);



#include "Credential.h"
#include "HTMLFormElement.h"
#include "HTMLInputElement.h"
#include "URL.h"
#include "ProtectionSpace.h"

#include <wtf/RefPtr.h>

    bool findPasswordFormFields(const HTMLFormElement*);
    bool locateSpecificPasswords(const Vector<HTMLInputElement*>& passwords);

    URL m_action;
    ProtectionSpace m_protectionSpace;
    mutable Credential m_credential;
    RefPtr<HTMLInputElement> m_userNameElement;



    m_clientRedirectIsPending = false;
}

void FrameLoaderClientBlackBerry::dispatchWillPerformClientRedirect(const URL&, double, double)
{
    if (m_webPagePrivate->m_dumpRenderTree)
        m_webPagePrivate->m_dumpRenderTree->didDispatchWillPerformClientRedirect();

{
    PolicyAction decision = PolicyIgnore;

    const URL& url = request.url();
    if (!url.isNull()) {
        // Fragment scrolls on the same page should always be handled internally.
        // (Only count as a fragment scroll if we are scrolling to a #fragment url, not back to the top, and reloading
        // the same url is not a fragment scroll even if it has a #fragment.)
        const URL& currentUrl = m_frame->document()->url();
        bool isFragmentScroll = url.hasFragmentIdentifier() && url != currentUrl && equalIgnoringFragmentIdentifier(currentUrl, url);
        decision = decidePolicyForExternalLoad(request, isFragmentScroll);


}

PassRefPtr<Widget> FrameLoaderClientBlackBerry::createPlugin(const IntSize& pluginSize,
    HTMLPlugInElement* element, const URL& url, const Vector<String>& paramNames,
    const Vector<String>& paramValues, const String& mimeTypeIn, bool loadManually)
{
    String mimeType(mimeTypeIn);

        if (!source.isEmpty()) {
            // Always ignore existing substitute data if any.
            WTF::RefPtr<SharedBuffer> buffer = SharedBuffer::create(source.is8Bit() ? reinterpret_cast<const char*>(source.characters8()) : source.latin1().data(), source.length());
            substituteDataLocal = SubstituteData(buffer, "text/html", "latin1", URL());
        }
    }


    }
}

String FrameLoaderClientBlackBerry::userAgent(const URL&)
{
    return m_webPagePrivate->m_webSettings->userAgentString();
}

        m_webPagePrivate->m_dumpRenderTree->didReceiveTitleForFrame(title.string(), m_frame);
}

void FrameLoaderClientBlackBerry::setTitle(const StringWithDirection& /*title*/, const URL& /*url*/)
{
    // Used by Apple WebKit to update the title of an existing history item.
    // QtWebKit doesn't accomodate this on history items. If it ever does,

        return;

    String errorPage = m_webPagePrivate->m_client->getErrorPage(error.errorCode(), error.localizedDescription(), error.failingURL());
    SubstituteData errorData(utf8Buffer(errorPage), "text/html", "utf-8", URL(URL(), error.failingURL()));

    // Loading using SubstituteData will replace the original request with our
    // error data. This must be done within dispatchDidFailProvisionalLoad,

    }
}

PassRefPtr<Frame> FrameLoaderClientBlackBerry::createFrame(const URL& url, const String& name
    , HTMLFrameOwnerElement* ownerElement, const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
{
    if (!m_webPagePrivate)

    return childFrame.release();
}

ObjectContentType FrameLoaderClientBlackBerry::objectContentType(const URL& url, const String& mimeTypeIn, bool shouldPreferPlugInsForImages)
{
    String mimeType = mimeTypeIn;
    if (mimeType.isEmpty())

    // and exposed to client. Before that, don't return PolicyIgnore so we can continue to
    // create new window and get to dispatchDecidePolicyForNavigationAction() where the client
    // is given a chance to decide how to handle patterns such as 'mailto:'.
    const URL& url = request.url();
    String pattern = m_webPagePrivate->findPatternStringForUrl(url);
    if (!pattern.isEmpty()) {
        m_webPagePrivate->m_client->handleStringPattern(pattern.characters(), pattern.length());

    m_webPagePrivate->m_client->notifyDidLoadFromApplicationCache();
}

PassRefPtr<SecurityOrigin> FrameLoaderClientBlackBerry::securityOriginForNewDocument(const URL& url)
{
    // What we are trying to do here is to keep using the old path as origin when a file-based html page
    // changes its location to some html in a subfolder. This will allow some file-based html packages



    virtual void dispatchDidHandleOnloadEvents();
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() { notImplemented(); }
    virtual void dispatchDidCancelClientRedirect();
    virtual void dispatchWillPerformClientRedirect(const URL&, double, double);
    virtual void dispatchDidChangeLocationWithinPage();
    virtual void dispatchDidPushStateWithinPage();
    virtual void dispatchDidReplaceStateWithinPage();

    virtual void dispatchDidReceiveIcon();
    virtual void dispatchDidStartProvisionalLoad();
    virtual void dispatchDidReceiveTitle(const StringWithDirection&);
    virtual void setTitle(const StringWithDirection& title, const URL&);
    virtual void dispatchDidCommitLoad();
    virtual void dispatchDidFailProvisionalLoad(const ResourceError&);
    virtual void dispatchDidFailLoad(const ResourceError&);

    virtual void dispatchWillUpdateApplicationCache(const ResourceRequest&);
    virtual void dispatchDidLoadFromApplicationCache(const ResourceRequest&);
    virtual void didDisplayInsecureContent() { notImplemented(); }
    virtual void didRunInsecureContent(SecurityOrigin*, const URL&) { notImplemented(); }
    virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); }
    virtual ResourceError cancelledError(const ResourceRequest&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); }
    virtual ResourceError blockedError(const ResourceRequest&) { notImplemented(); return ResourceError(emptyString(), 0, emptyString(), emptyString()); }

    virtual void didFinishLoad() { notImplemented(); }
    virtual void prepareForDataSourceReplacement() { notImplemented(); }
    virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&);
    virtual void setTitle(const String&, const URL&) { notImplemented(); }
    virtual String userAgent(const URL&);
    virtual void savePlatformDataToCachedFrame(CachedFrame*) { notImplemented(); }
    virtual void transitionToCommittedFromCachedFrame(CachedFrame*) { notImplemented(); }
    virtual void transitionToCommittedForNewPage();

    virtual void didRestoreFromPageCache();
    virtual void dispatchDidBecomeFrameset(bool) { }
    virtual void convertMainResourceLoadToDownload(DocumentLoader*, const ResourceRequest&, const ResourceResponse&);
    virtual PassRefPtr<Frame> createFrame(const URL&, const String&, HTMLFrameOwnerElement*, const String&, bool, int, int);
    virtual bool shouldAlwaysUsePluginDocument(const String&) const;
    virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool);
    virtual void redirectDataToPlugin(Widget*);
    virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&) { notImplemented(); return 0; }

    virtual ObjectContentType objectContentType(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages);
    virtual String overrideMediaType() const { notImplemented(); return String(); }
    virtual void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
    virtual void documentElementAvailable() { notImplemented(); }

    virtual bool shouldLoadIconExternally() { return false; }
    virtual void loadIconExternally(const String& originalPageUrl, const String& finalPageUrl, const String& iconUrl);

    virtual void didDetectXSS(const URL&, bool) { }
    virtual void dispatchDidChangeIcons(IconType) { notImplemented(); };
    virtual void dispatchWillSendSubmitEvent(PassRefPtr<FormState>);



    virtual PassRefPtr<FrameNetworkingContext> createNetworkingContext();

    virtual PassRefPtr<SecurityOrigin> securityOriginForNewDocument(const URL&);

    void readyToRender(bool pageIsVisuallyNonEmpty);


    bool m_childFrameCreationSuppressed;

    // This set includes the original and final urls for server redirects.
    HashSet<URL> m_historyNavigationSourceURLs;
    HashSet<URL> m_redirectURLsToSkipDueToHistoryNavigation;

    // Plugin view to redirect data to.
    PluginView* m_pluginView;



}

// CookiesStrategy
String PlatformStrategiesBlackBerry::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesForDOM(session, firstParty, url);
}

void PlatformStrategiesBlackBerry::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool PlatformStrategiesBlackBerry::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesEnabled(session, firstParty, url);
}

String PlatformStrategiesBlackBerry::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool PlatformStrategiesBlackBerry::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void PlatformStrategiesBlackBerry::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(session, url, cookieName);
}

}

// VisitedLinkStrategy
bool PlatformStrategiesBlackBerry::isLinkVisited(Page* page, LinkHash hash, const URL&, const AtomicString&)
{
    return page->group().isLinkVisited(hash);
}



    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy();

    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&);

    // WebCore::DatabaseStrategy
    // - Using default implementation.

    virtual void getPluginInfo(const WebCore::Page*, Vector<WebCore::PluginInfo>&);

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL& baseURL, const WTF::AtomicString& attributeURL);
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash);
};




#include "JSDOMWindowBase.h"
#include "JSObject.h"
#include "JSRetainPtr.h"
#include "KURL.h"
#include "PagePopupClient.h"
#include "Settings.h"
#include "URL.h"
#include "WebPage.h"
#include "WebPage_p.h"
#include <JavaScriptCore/API/JSCallbackObject.h>

{
    ASSERT(writer);
    writer->setMIMEType("text/html");
    writer->begin(URL());

    // All the popups have the same html head and the page content should be non-zoomable.
    StringBuilder source;



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-25  Brent Fulgham  <bfulgham@apple.com>

        Refactor RuntimeEnabledFeatures as a Singleton.



#include "FrameLoaderClientEfl.h"
#include "HitTestResult.h"
#include "IntRect.h"
#include "URL.h"
#include "NavigationAction.h"
#include "NotImplemented.h"
#include "PopupMenuEfl.h"

    // FIXME, compare with old link, look at Qt impl.
    bool isLink = hit.isLiveLink();
    if (isLink) {
        URL url = hit.absoluteLinkURL();
        if (!url.isEmpty() && url != m_hoveredLinkURL) {
            const char* link[2];
            TextDirection dir;

        }
    } else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
        ewk_view_mouse_link_hover_out(m_view);
        m_hoveredLinkURL = URL();
    }
}




#define ChromeClientEfl_h

#include "ChromeClient.h"
#include "URL.h"
#include "PopupMenu.h"

#if ENABLE(INPUT_TYPE_COLOR)

#endif

    Evas_Object* m_view;
    URL m_hoveredLinkURL;
#if ENABLE(FULLSCREEN_API)
    RefPtr<Element> m_fullScreenElement;
#endif




#include "ContextMenu.h"
#include "HitTestResult.h"
#include "URL.h"
#include "NotImplemented.h"
#include <wtf/RefCounted.h>


    notImplemented();
}

void ContextMenuClientEfl::downloadURL(const URL&)
{
    notImplemented();
}

Lines 45-51 public: a/Source/WebKit/efl/WebCoreSupport/ContextMenuClientEfl.h_sec1
- a/Source/WebKit/efl/WebCoreSupport/ContextMenuClientEfl.h -1 / +1 lines
45	virtual PassOwnPtr<ContextMenu> customizeMenu(PassOwnPtr<ContextMenu>);	45	virtual PassOwnPtr<ContextMenu> customizeMenu(PassOwnPtr<ContextMenu>);
46	virtual void contextMenuItemSelected(ContextMenuItem, const ContextMenu);	46	virtual void contextMenuItemSelected(ContextMenuItem, const ContextMenu);
47		47
48	virtual void downloadURL(const KURL&);	48	virtual void downloadURL(const URL&);
49	virtual void lookUpInDictionary(Frame*);	49	virtual void lookUpInDictionary(Frame*);
50	virtual void speak(const String&);	50	virtual void speak(const String&);
51	virtual bool isSpeaking();	51	virtual bool isSpeaking();



    return String("frame (anonymous)");
}

const WebCore::URL DumpRenderTreeSupportEfl::provisionalURL(const Evas_Object* ewkFrame)
{
    DRT_SUPPORT_FRAME_GET_OR_RETURN(ewkFrame, frame, WebCore::URL());

    WebCore::DocumentLoader* provisionalDocumentLoader = frame->loader().provisionalDocumentLoader();
    if (!provisionalDocumentLoader)
        return WebCore::URL();

    return provisionalDocumentLoader->url();
}

{
    DRT_SUPPRT_PAGE_GET_OR_RETURN(ewkView, page);

    page->group().addUserScriptToWorld(WebCore::mainThreadNormalWorld(), sourceCode, WebCore::URL(),
                                       Vector<String>(), Vector<String>(), runAtStart ? WebCore::InjectAtDocumentStart : WebCore::InjectAtDocumentEnd,
                                       allFrames ? WebCore::InjectInAllFrames : WebCore::InjectInTopFrameOnly);
}

{
    DRT_SUPPRT_PAGE_GET_OR_RETURN(ewkView, page);

    page->group().addUserStyleSheetToWorld(WebCore::mainThreadNormalWorld(), sourceCode, WebCore::URL(), Vector<String>(), Vector<String>(), allFrames ? WebCore::InjectInAllFrames : WebCore::InjectInTopFrameOnly);
}

void DumpRenderTreeSupportEfl::clearUserStyleSheets(const Evas_Object* ewkView)



#ifndef DumpRenderTreeSupportEfl_h
#define DumpRenderTreeSupportEfl_h

#include "URL.h"
#include <Eina.h>
#include <FindOptions.h>
#include <IntRect.h>

    static String responseMimeType(const Evas_Object* ewkFrame);
    static WebCore::IntRect selectionRectangle(const Evas_Object* ewkFrame);
    static String suitableDRTFrameName(const Evas_Object* ewkFrame);
    static const WebCore::URL provisionalURL(const Evas_Object* ewkFrame);
    static String layerTreeAsText(const Evas_Object* ewkFrame);
    static void setValueForUser(JSContextRef, JSValueRef nodeObject, const String& value);
    static void setDefersLoading(Evas_Object* ewkView, bool defers);



    return m_customUserAgent;
}

String FrameLoaderClientEfl::userAgent(const URL&)
{
    if (!m_customUserAgent.isEmpty())
        return m_customUserAgent;

    evas_object_smart_callback_call(m_view, "resource,request,willsend", &messages);

    if (request.url != orig.url) {
        coreRequest.setURL(URL(URL(), request.url));

        // Calling client might have changed our url pointer.
        // Free the new allocated string.

    callPolicyFunction(function, policy);
}

PassRefPtr<Widget> FrameLoaderClientEfl::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
    ASSERT(m_frame);
    ASSERT(m_view);

                                  mimeType, loadManually);
}

PassRefPtr<Frame> FrameLoaderClientEfl::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer, bool /*allowsScrolling*/, int /*marginWidth*/, int /*marginHeight*/)
{
    ASSERT(m_frame);
    ASSERT(m_view);

        m_hasSentResponseToPlugin = false;
}

PassRefPtr<Widget> FrameLoaderClientEfl::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&,
                                                                const Vector<String>& /*paramNames*/, const Vector<String>& /*paramValues*/)
{
    notImplemented();
    return 0;
}

ObjectContentType FrameLoaderClientEfl::objectContentType(const URL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
{
    // FIXME: once plugin support is enabled, this method needs to correctly handle the 'shouldPreferPlugInsForImages' flag. See
    // WebCore::FrameLoader::defaultObjectContentType() for an example.

    ewk_frame_mixed_content_displayed_set(m_frame, true);
}

void FrameLoaderClientEfl::didRunInsecureContent(SecurityOrigin*, const URL&)
{
    ewk_frame_mixed_content_run_set(m_frame, true);
}

void FrameLoaderClientEfl::didDetectXSS(const URL& insecureURL, bool didBlockEntirePage)
{
    CString cs = insecureURL.string().utf8();
    Ewk_Frame_Xss_Notification xssInfo = { cs.data(), didBlockEntirePage };

    ewk_frame_redirect_cancelled(m_frame);
}

void FrameLoaderClientEfl::dispatchWillPerformClientRedirect(const URL& url, double, double)
{
    ewk_frame_redirect_requested(m_frame, url.string().utf8().data());
}

    notImplemented();
}

void FrameLoaderClientEfl::setTitle(const StringWithDirection&, const URL&)
{
    // no need for, dispatchDidReceiveTitle is the right callback
}



    virtual void dispatchDidHandleOnloadEvents();
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad();
    virtual void dispatchDidCancelClientRedirect();
    virtual void dispatchWillPerformClientRedirect(const URL&, double, double);
    virtual void dispatchDidChangeLocationWithinPage();
    virtual void dispatchWillClose();
    virtual void dispatchDidReceiveIcon();

    virtual void postProgressEstimateChangedNotification();
    virtual void postProgressFinishedNotification();

    virtual PassRefPtr<Frame> createFrame(const URL&, const String& name, HTMLFrameOwnerElement*,
                               const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight);

    virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const WTF::Vector<String>&, const WTF::Vector<String>&, const String&, bool);
    virtual void recreatePlugin(Widget*) { }
    virtual void redirectDataToPlugin(Widget* pluginWidget);
    virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL& baseURL, const WTF::Vector<String>& paramNames, const WTF::Vector<String>& paramValues);
    virtual String overrideMediaType() const;
    virtual void documentElementAvailable();



    virtual void registerForIconNotification(bool);

    virtual ObjectContentType objectContentType(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages);

    virtual void setMainFrameDocumentReady(bool);


    virtual bool shouldGoToHistoryItem(HistoryItem*) const;
    virtual bool shouldStopLoadingForHistoryItem(HistoryItem*) const;
    virtual void didDisplayInsecureContent();
    virtual void didRunInsecureContent(SecurityOrigin*, const URL&);
    virtual void didDetectXSS(const URL&, bool didBlockEntirePage);

    virtual ResourceError cancelledError(const ResourceRequest&);
    virtual ResourceError blockedError(const ResourceRequest&);

    virtual void prepareForDataSourceReplacement();

    virtual WTF::PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&);
    virtual void setTitle(const StringWithDirection& title, const URL&);

    virtual String userAgent(const URL&);

    virtual void savePlatformDataToCachedFrame(CachedFrame*);
    virtual void transitionToCommittedFromCachedFrame(CachedFrame*);



}

// CookiesStrategy
String PlatformStrategiesEfl::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesForDOM(session, firstParty, url);
}

void PlatformStrategiesEfl::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool PlatformStrategiesEfl::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesEnabled(session, firstParty, url);
}

String PlatformStrategiesEfl::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool PlatformStrategiesEfl::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void PlatformStrategiesEfl::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(session, url, cookieName);
}

}

// VisitedLinkStrategy
bool PlatformStrategiesEfl::isLinkVisited(Page* page, LinkHash hash, const URL&, const AtomicString&)
{
    return page->group().isLinkVisited(hash);
}



    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy();

    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&);

    // WebCore::DatabaseStrategy
    // - Using default implementation.

    virtual void getPluginInfo(const WebCore::Page*, Vector<WebCore::PluginInfo>&);

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL& baseURL, const WTF::AtomicString& attributeURL);
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash);
};




#include "HitTestRequest.h"
#include "HitTestResult.h"
#include "IntSize.h"
#include "URL.h"
#include "PlatformEvent.h"
#include "PlatformKeyboardEvent.h"
#include "PlatformMessagePortChannel.h"

Eina_Bool ewk_frame_uri_set(Evas_Object* ewkFrame, const char* uri)
{
    EWK_FRAME_SD_GET_OR_RETURN(ewkFrame, smartData, false);
    WebCore::URL kurl(WebCore::URL(), WTF::String::fromUTF8(uri));
    WebCore::ResourceRequest req(kurl);
    smartData->frame->loader().load(WebCore::FrameLoadRequest(smartData->frame, req));


    if (!baseUri)
        baseUri = "about:blank";

    WebCore::URL baseKURL(WebCore::URL(), WTF::String::fromUTF8(baseUri));
    WebCore::URL unreachableKURL;
    if (unreachableUri)
        unreachableKURL = WebCore::URL(WebCore::URL(), WTF::String::fromUTF8(unreachableUri));
    else
        unreachableKURL = WebCore::URL();

    WTF::RefPtr<WebCore::SharedBuffer> buffer = WebCore::SharedBuffer::create(contents, contentsSize);
    WebCore::SubstituteData substituteData


    const WebCore::FrameLoader& frameLoader = smartData->frame->loader();
    const WebCore::DocumentLoader* documentLoader = frameLoader.documentLoader();
    const WebCore::URL documentURL = documentLoader->requestURL();

    if (!documentURL.protocolIs("https"))
        return EWK_CERTIFICATE_STATUS_NO_CERTIFICATE;

 *
 * Creates plugin.
 */
WTF::PassRefPtr<WebCore::Widget> ewk_frame_plugin_create(Evas_Object* ewkFrame, const WebCore::IntSize& pluginSize, WebCore::HTMLPlugInElement* element, const WebCore::URL& url, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues, const WTF::String& mimeType, bool loadManually)
{
#if ENABLE(NETSCAPE_PLUGIN_API)
    DBG("ewkFrame=%p, size=%dx%d, element=%p, url=%s, mimeType=%s",



class HistoryItem;
class HTMLPlugInElement;
class HTMLFrameOwnerElement;
class URL;
class Frame;
class IntSize;
class Widget;

void ewk_frame_force_layout(Evas_Object* ewkFrame);
void ewk_frame_icon_changed(Evas_Object* ewkFrame);

WTF::PassRefPtr<WebCore::Widget> ewk_frame_plugin_create(Evas_Object* ewkFrame, const WebCore::IntSize& pluginSize, WebCore::HTMLPlugInElement* element, const WebCore::URL& url, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues, const WTF::String& mimeType, bool loadManually);

void ewk_frame_editor_client_contents_changed(Evas_Object* ewkFrame);
void ewk_frame_editor_client_selection_changed(Evas_Object* ewkFrame);



#include "config.h"
#include "ewk_security_policy.h"

#include "URL.h"
#include "SecurityOrigin.h"
#include "SecurityPolicy.h"


void ewk_security_policy_whitelist_origin_add(const char* sourceUrl, const char* destinationUrl, Eina_Bool allowSubdomains)
{
    const RefPtr<SecurityOrigin> source = SecurityOrigin::createFromString(sourceUrl);
    const URL destination(URL(), destinationUrl);

    SecurityPolicy::addOriginAccessWhitelistEntry(*source, destination.protocol(), destination.host(), allowSubdomains);
}

void ewk_security_policy_whitelist_origin_del(const char* sourceUrl, const char* destinationUrl, Eina_Bool allowSubdomains)
{
    const RefPtr<SecurityOrigin> source = SecurityOrigin::createFromString(sourceUrl);
    const URL destination(URL(), destinationUrl);

    SecurityPolicy::removeOriginAccessWhitelistEntry(*source, destination.protocol(), destination.host(), allowSubdomains);
}



#include "IconDatabase.h"
#include "Image.h"
#include "IntSize.h"
#include "URL.h"
#include "LocalFileSystem.h"
#include "MemoryCache.h"
#include "PageCache.h"

{
    EINA_SAFETY_ON_NULL_RETURN(url);

    const WebCore::URL kurl(WebCore::URL(), WTF::String::fromUTF8(url));
    WebCore::StorageTracker::tracker().deleteOrigin(WebCore::SecurityOrigin::create(kurl).get());
}


{
    EINA_SAFETY_ON_NULL_RETURN_VAL(url, 0);

    WebCore::URL kurl(WebCore::URL(), WTF::String::fromUTF8(url));
    RefPtr<cairo_surface_t> icon = WebCore::iconDatabase().synchronousNativeIconForPageURL(kurl.string(), WebCore::IntSize(16, 16));
    if (!icon)
        ERR("no icon for url %s", url);

    EINA_SAFETY_ON_NULL_RETURN_VAL(url, 0);
    EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);

    WebCore::URL kurl(WebCore::URL(), WTF::String::fromUTF8(url));
    RefPtr<cairo_surface_t> surface = WebCore::iconDatabase().synchronousNativeIconForPageURL(kurl.string(), WebCore::IntSize(16, 16));

    if (!surface) {



    Ewk_View_Private_Data* priv = new Ewk_View_Private_Data;
    memset(priv, 0, sizeof(Ewk_View_Private_Data));
    AtomicString string;
    WebCore::URL url;

    WebCore::Page::PageClients pageClients;
    pageClients.chromeClient = new WebCore::ChromeClientEfl(smartData->self);

    EINA_SAFETY_ON_NULL_RETURN_VAL(priv->page, false);
    EINA_SAFETY_ON_NULL_RETURN_VAL(priv->page->groupPtr(), false);

    WebCore::URL kurl(WebCore::URL(), WTF::String::fromUTF8(visitedUrl));
    priv->page->groupPtr()->addVisitedLink(kurl);
    return true;
}

    EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData, false);
    EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv, false);
    if (eina_stringshare_replace(&priv->settings.userStylesheet, uri)) {
        WebCore::URL kurl(WebCore::URL(), String::fromUTF8(uri));
        priv->pageSettings->setUserStyleSheetLocation(kurl);
    }
    return true;

    _ewk_view_smart_changed(smartData);
}

WTF::PassRefPtr<WebCore::Widget> ewk_view_plugin_create(Evas_Object* ewkView, Evas_Object* frame, const WebCore::IntSize& pluginSize, WebCore::HTMLPlugInElement* element, const WebCore::URL& url, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues, const WTF::String& mimeType, bool loadManually)
{
    DBG("ewkView=%p, frame=%p, size=%dx%d, element=%p, url=%s, mimeType=%s",
        ewkView, frame, pluginSize.width(), pluginSize.height(), element,

Lines 114-120 WebCore::Page* ewk_view_core_page_get(const Evas_Object* ewkView); a/Source/WebKit/efl/ewk/ewk_view_private.h_sec1
- a/Source/WebKit/efl/ewk/ewk_view_private.h -1 / +1 lines
114		114
115	void ewk_view_frame_rect_changed(Evas_Object* ewkView);	115	void ewk_view_frame_rect_changed(Evas_Object* ewkView);
116		116
117	WTF::PassRefPtr<WebCore::Widget> ewk_view_plugin_create(Evas_Object* ewkView, Evas_Object* frame, const WebCore::IntSize& pluginSize, WebCore::HTMLPlugInElement* element, const WebCore::KURL& url, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues, const WTF::String& mimeType, bool loadManually);	117	WTF::PassRefPtr<WebCore::Widget> ewk_view_plugin_create(Evas_Object* ewkView, Evas_Object* frame, const WebCore::IntSize& pluginSize, WebCore::HTMLPlugInElement* element, const WebCore::URL& url, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues, const WTF::String& mimeType, bool loadManually);
118		118
119	#if ENABLE(INPUT_TYPE_COLOR)	119	#if ENABLE(INPUT_TYPE_COLOR)
120	void ewk_view_color_chooser_new(Evas_Object* ewkView, WebCore::ColorChooserClient* client, const WebCore::Color& initialColor);	120	void ewk_view_color_chooser_new(Evas_Object* ewkView, WebCore::ColorChooserClient* client, const WebCore::Color& initialColor);



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-25  Brent Fulgham  <bfulgham@apple.com>

        Refactor RuntimeEnabledFeatures as a Singleton.

Lines 344-350 What's new in WebKitGTK+ 1.9.3? a/Source/WebKit/gtk/NEWS_sec1
- a/Source/WebKit/gtk/NEWS -1 / +1 lines
344	- Fix cursor used for ne-resize.	344	- Fix cursor used for ne-resize.
345	- Fix contractions recognition by the spell checker.	345	- Fix contractions recognition by the spell checker.
346	- Fix a crash rendering scrollbars on GTK wxWebkit.	346	- Fix a crash rendering scrollbars on GTK wxWebkit.
347	- Fix KURL::fileSystemPath() implementation to strip the query part	347	- Fix URL::fileSystemPath() implementation to strip the query part
348	of the uri.	348	of the uri.
349	- Check for GTK2/GTK3 symbol mismatch earlier to fix plugins run	349	- Check for GTK2/GTK3 symbol mismatch earlier to fix plugins run
350	with nspluginwrapper.	350	with nspluginwrapper.



#include "Icon.h"
#include "InspectorController.h"
#include "IntRect.h"
#include "URL.h"
#include "NavigationAction.h"
#include "NotImplemented.h"
#include "PopupMenuClient.h"

    // check if the element is a link...
    bool isLink = hit.isLiveLink();
    if (isLink) {
        URL url = hit.absoluteLinkURL();
        if (!url.isEmpty() && url != m_hoveredLinkURL) {
            TextDirection dir;
            CString titleString = hit.title(dir).utf8();

        }
    } else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
        g_signal_emit_by_name(m_webView, "hovering-over-link", 0, 0);
        m_hoveredLinkURL = URL();
    }

    if (Node* node = hit.innerNonSharedNode()) {



#include "GtkAdjustmentWatcher.h"
#include "IntRect.h"
#include "IntSize.h"
#include "URL.h"
#include "PopupMenu.h"
#include "Region.h"
#include "SearchPopupMenu.h"

    private:
        WebKitWebView* m_webView;
        GtkAdjustmentWatcher m_adjustmentWatcher;
        URL m_hoveredLinkURL;
        unsigned int m_closeSoonTimer;

        Timer <ChromeClient> m_displayTimer;



#include "ContextMenu.h"
#include "ContextMenuController.h"
#include "HitTestResult.h"
#include "URL.h"
#include "LocalizedStrings.h"
#include "NotImplemented.h"
#include "Page.h"

    notImplemented();
}

void ContextMenuClient::downloadURL(const URL& url)
{
    WebKitNetworkRequest* networkRequest = webkit_network_request_new(url.string().utf8().data());


Lines 48-54 namespace WebKit { a/Source/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.h_sec1
- a/Source/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.h -1 / +1 lines
48	virtual WebCore::PlatformMenuDescription getCustomMenuFromDefaultItems(WebCore::ContextMenu*);	48	virtual WebCore::PlatformMenuDescription getCustomMenuFromDefaultItems(WebCore::ContextMenu*);
49	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu);	49	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu);
50		50
51	virtual void downloadURL(const WebCore::KURL& url);	51	virtual void downloadURL(const WebCore::URL& url);
52	virtual void copyImageToClipboard(const WebCore::HitTestResult&);	52	virtual void copyImageToClipboard(const WebCore::HitTestResult&);
53	virtual void searchWithGoogle(const WebCore::Frame*);	53	virtual void searchWithGoogle(const WebCore::Frame*);
54	virtual void lookUpInDictionary(WebCore::Frame*);	54	virtual void lookUpInDictionary(WebCore::Frame*);




    WebKitWebView* webView = getViewFromFrame(frame);
    Page* page = core(webView);
    page->group().addUserScriptToWorld(mainThreadNormalWorld(), sourceCode, URL(), Vector<String>(), Vector<String>(),
        runAtStart ? InjectAtDocumentStart : InjectAtDocumentEnd, allFrames ? InjectInAllFrames : InjectInTopFrameOnly);
}



    WebKitWebView* webView = getViewFromFrame(frame);
    Page* page = core(webView);
    page->group().addUserStyleSheetToWorld(mainThreadNormalWorld(), sourceCode, URL(), Vector<String>(), Vector<String>(), allFrames ? InjectInAllFrames : InjectInTopFrameOnly); 
}

/**



}


String FrameLoaderClient::userAgent(const URL& url)
{
    WebKitWebSettings* settings = webkit_web_view_get_settings(getViewFromFrame(m_frame));
    GOwnPtr<gchar> userAgentString(webkitWebSettingsUserAgentForURI(settings, url.string().utf8().data()));

    // Feed any changes back into the ResourceRequest object.
    SoupMessage* message = webkit_network_request_get_message(networkRequest.get());
    if (!message) {
        request.setURL(URL(URL(), String::fromUTF8(webkit_network_request_get_uri(networkRequest.get()))));
        return;
    }


        webkit_web_policy_decision_use(m_policyDecision);
}

PassRefPtr<Widget> FrameLoaderClient::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
    /* Check if we want to embed a GtkWidget, fallback to plugins later */
    CString urlString = url.string().utf8();

    return 0;
}

PassRefPtr<Frame> FrameLoaderClient::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
                                                 const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
{
    ASSERT(m_frame);

        m_hasSentResponseToPlugin = false;
}

PassRefPtr<Widget> FrameLoaderClient::createJavaAppletWidget(const IntSize& pluginSize, HTMLAppletElement* element, const URL& baseURL, const Vector<String>& paramNames, const Vector<String>& paramValues)
{
    return FrameLoaderClient::createPlugin(pluginSize, element, baseURL, paramNames, paramValues, "application/x-java-applet", false);
}

ObjectContentType FrameLoaderClient::objectContentType(const URL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
{
    return FrameLoader::defaultObjectContentType(url, mimeType, shouldPreferPlugInsForImages);
}

    DumpRenderTreeSupportGtk::s_frameLoadEventCallback(m_frame, DumpRenderTreeSupportGtk::DidDisplayInsecureContent, 0);
}

void FrameLoaderClient::didRunInsecureContent(SecurityOrigin* coreOrigin, const URL& url)
{
    g_signal_emit_by_name(m_frame, "insecure-content-run", kit(coreOrigin), url.string().utf8().data());
}

void FrameLoaderClient::didDetectXSS(const URL&, bool)
{
    if (!DumpRenderTreeSupportGtk::dumpRenderTreeModeEnabled() || !DumpRenderTreeSupportGtk::s_frameLoadEventCallback)
        return;

    DumpRenderTreeSupportGtk::s_frameLoadEventCallback(m_frame, DumpRenderTreeSupportGtk::DidCancelClientRedirect, 0);
}

void FrameLoaderClient::dispatchWillPerformClientRedirect(const URL& url, double, double)
{
    if (!DumpRenderTreeSupportGtk::dumpRenderTreeModeEnabled() || !DumpRenderTreeSupportGtk::s_frameLoadEventCallback)
        return;

    notImplemented();
}

void FrameLoaderClient::setTitle(const StringWithDirection& title, const URL& url)
{
    WebKitWebFramePrivate* frameData = m_frame->priv;
    g_free(frameData->title);

        return;

    const char* uri = webkit_web_resource_get_uri(webResource);
    RefPtr<ArchiveResource> coreResource(loader->subresource(URL(URL(), uri)));

    // If coreResource is NULL here, the resource failed to load,
    // unless it's the main resource.



        virtual void dispatchDidHandleOnloadEvents();
        virtual void dispatchDidReceiveServerRedirectForProvisionalLoad();
        virtual void dispatchDidCancelClientRedirect();
        virtual void dispatchWillPerformClientRedirect(const WebCore::URL&, double, double);
        virtual void dispatchDidChangeLocationWithinPage();
        virtual void dispatchDidNavigateWithinPage();
        virtual void dispatchDidPushStateWithinPage();

        virtual void postProgressEstimateChangedNotification();
        virtual void postProgressFinishedNotification();

        virtual PassRefPtr<WebCore::Frame> createFrame(const WebCore::URL& url, const WTF::String& name, WebCore::HTMLFrameOwnerElement* ownerElement,
                                   const WTF::String& referrer, bool allowsScrolling, int marginWidth, int marginHeight);
        virtual PassRefPtr<WebCore::Widget> createPlugin(const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::URL&, const WTF::Vector<WTF::String>&, const WTF::Vector<WTF::String>&, const WTF::String&, bool);
        virtual void recreatePlugin(WebCore::Widget*) { }
        virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget);
        virtual PassRefPtr<WebCore::Widget> createJavaAppletWidget(const WebCore::IntSize&, WebCore::HTMLAppletElement*, const WebCore::URL& baseURL, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues);
        virtual WTF::String overrideMediaType() const;
        virtual void dispatchDidClearWindowObjectInWorld(WebCore::DOMWrapperWorld*);
        virtual void documentElementAvailable();


        virtual void registerForIconNotification(bool);

        virtual WebCore::ObjectContentType objectContentType(const WebCore::URL&, const WTF::String& mimeType, bool shouldPreferPlugInsForImages);

        virtual void setMainFrameDocumentReady(bool);


        virtual bool shouldStopLoadingForHistoryItem(WebCore::HistoryItem*) const;

        virtual void didDisplayInsecureContent();
        virtual void didRunInsecureContent(WebCore::SecurityOrigin*, const WebCore::URL&);
        virtual void didDetectXSS(const WebCore::URL&, bool didBlockEntirePage);

        virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&);
        virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&);

        virtual void prepareForDataSourceReplacement();

        virtual WTF::PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&);
        virtual void setTitle(const WebCore::StringWithDirection& title, const WebCore::URL&);

        virtual WTF::String userAgent(const WebCore::URL&);

        virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*);
        virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*);



}

// CookiesStrategy
String PlatformStrategiesGtk::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesForDOM(session, firstParty, url);
}

void PlatformStrategiesGtk::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool PlatformStrategiesGtk::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesEnabled(session, firstParty, url);
}

String PlatformStrategiesGtk::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool PlatformStrategiesGtk::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void PlatformStrategiesGtk::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(session, url, cookieName);
}

}

// VisitedLinkStrategy
bool PlatformStrategiesGtk::isLinkVisited(Page* page, LinkHash hash, const URL&, const AtomicString&)
{
    return page->group().isLinkVisited(hash);
}



    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy();

    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&);

    // WebCore::DatabaseStrategy
    // - Using default implementation.

    virtual void getPluginInfo(const WebCore::Page*, Vector<WebCore::PluginInfo>&);

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL& baseURL, const WTF::AtomicString& attributeURL);
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash);
};




#ifndef ConvertToGCharPrivate_h
#define ConvertToGCharPrivate_h

#include "URL.h"
#include <wtf/text/CString.h>
#include <wtf/text/AtomicString.h>
#include <wtf/text/WTFString.h>

    return g_strdup(s.utf8().data());
}

inline gchar* copyAsGchar(WebCore::URL const& s)
{
    return copyAsGchar(s.string());
}

Lines 635-641 const gchar* webkit_download_get_suggested_filename(WebKitDownload* download) a/Source/WebKit/gtk/webkit/webkitdownload.cpp_sec1
- a/Source/WebKit/gtk/webkit/webkitdownload.cpp -1 / +1 lines
635	if (priv->suggestedFilename)	635	if (priv->suggestedFilename)
636	return priv->suggestedFilename;	636	return priv->suggestedFilename;
637		637
638	KURL url = KURL(KURL(), webkit_network_request_get_uri(priv->networkRequest));	638	URL url = URL(URL(), webkit_network_request_get_uri(priv->networkRequest));
639	url.setQuery(String());	639	url.setQuery(String());
640	url.removeFragmentIdentifier();	640	url.removeFragmentIdentifier();
641	priv->suggestedFilename = g_strdup(decodeURLEscapeSequences(url.lastPathComponent()).utf8().data());	641	priv->suggestedFilename = g_strdup(decodeURLEscapeSequences(url.lastPathComponent()).utf8().data());

Lines 24-30 a/Source/WebKit/gtk/webkit/webkithittestresult.cpp_sec1
- a/Source/WebKit/gtk/webkit/webkithittestresult.cpp -1 / +1 lines
24	#include "Frame.h"	24	#include "Frame.h"
25	#include "FrameView.h"	25	#include "FrameView.h"
26	#include "HitTestResult.h"	26	#include "HitTestResult.h"
27	#include "KURL.h"	27	#include "URL.h"
28	#include "WebKitDOMNodePrivate.h"	28	#include "WebKitDOMNodePrivate.h"
29	#include "webkitenumtypes.h"	29	#include "webkitenumtypes.h"
30	#include "webkitglobals.h"	30	#include "webkitglobals.h"

Lines 266-272 WebCore::ResourceRequest core(WebKitNetworkRequest* request) a/Source/WebKit/gtk/webkit/webkitnetworkrequest.cpp_sec1
- a/Source/WebKit/gtk/webkit/webkitnetworkrequest.cpp -1 / +1 lines
266	if (soupMessage)	266	if (soupMessage)
267	return WebCore::ResourceRequest(soupMessage);	267	return WebCore::ResourceRequest(soupMessage);
268		268
269	WebCore::KURL url = WebCore::KURL(WebCore::KURL(), String::fromUTF8(webkit_network_request_get_uri(request)));	269	WebCore::URL url = WebCore::URL(WebCore::URL(), String::fromUTF8(webkit_network_request_get_uri(request)));
270	return WebCore::ResourceRequest(url);	270	return WebCore::ResourceRequest(url);
271	}	271	}
272		272



#include "DocumentLoaderGtk.h"
#include "FrameLoader.h"
#include "FrameLoaderClientGtk.h"
#include "URL.h"
#include "ResourceBuffer.h"
#include "ResourceRequest.h"
#include "SharedBuffer.h"


    const gchar* uri = webkit_network_request_get_uri(request);

    ResourceRequest resourceRequest(ResourceRequest(URL(URL(), String::fromUTF8(uri))));
    WebKitWebDataSource* datasource = kitNew(WebKit::DocumentLoader::create(resourceRequest, SubstituteData()));

    WebKitWebDataSourcePrivate* priv = datasource->priv;

    g_return_val_if_fail(WEBKIT_IS_WEB_DATA_SOURCE(webDataSource), NULL);

    WebKitWebDataSourcePrivate* priv = webDataSource->priv;
    const URL& unreachableURL = priv->loader->unreachableURL();

    if (unreachableURL.isEmpty())
        return NULL;



    if (!coreFrame)
        return;

    coreFrame->loader().load(FrameLoadRequest(coreFrame, ResourceRequest(URL(URL(), String::fromUTF8(uri)))));
}

static void webkit_web_frame_load_data(WebKitWebFrame* frame, const gchar* content, const gchar* mimeType, const gchar* encoding, const gchar* baseURL, const gchar* unreachableURL)

    Frame* coreFrame = core(frame);
    ASSERT(coreFrame);

    URL baseKURL = baseURL ? URL(URL(), String::fromUTF8(baseURL)) : blankURL();

    ResourceRequest request(baseKURL);


    SubstituteData substituteData(sharedBuffer.release(),
                                  mimeType ? String::fromUTF8(mimeType) : String::fromUTF8("text/html"),
                                  encoding ? String::fromUTF8(encoding) : String::fromUTF8("UTF-8"),
                                  URL(URL(), String::fromUTF8(unreachableURL)),
                                  URL(URL(), String::fromUTF8(unreachableURL)));

    coreFrame->loader().load(FrameLoadRequest(coreFrame, request, substituteData));
}



#include "webkitwebhistoryitem.h"

#include "HistoryItem.h"
#include "URL.h"
#include "webkitglobalsprivate.h"
#include "webkitwebhistoryitemprivate.h"
#include <glib.h>

    WebKitWebHistoryItem* webHistoryItem = WEBKIT_WEB_HISTORY_ITEM(g_object_new(WEBKIT_TYPE_WEB_HISTORY_ITEM, NULL));
    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;

    WebCore::URL historyUri(WebCore::URL(), uri);
    WTF::String historyTitle = WTF::String::fromUTF8(title);
    RefPtr<WebCore::HistoryItem> item = WebCore::HistoryItem::create(historyUri, historyTitle, 0);
    priv->historyItem = item.release().leakRef();



#include "webkitwebresource.h"

#include "ArchiveResource.h"
#include "URL.h"
#include "SharedBuffer.h"
#include "webkitenumtypes.h"
#include "webkitglobalsprivate.h"

        size = strlen(data);

    RefPtr<SharedBuffer> buffer = SharedBuffer::create(data, size);
    WebKitWebResource* webResource = webkit_web_resource_new_with_core_resource(ArchiveResource::create(buffer, URL(URL(), String::fromUTF8(uri)), String::fromUTF8(mimeType), String::fromUTF8(encoding), String::fromUTF8(frameName)));

    return webResource;
}




#include "EditingBehavior.h"
#include "FileSystem.h"
#include "URL.h"
#include "PluginDatabase.h"
#include "UserAgentGtk.h"
#include "webkitenumtypes.h"

    return false;
}

static String userAgentForURL(const URL& url)
{
    // For Google domains, drop the browser's custom User Agent string, and use the
    // standard Chrome one, so they don't give us a broken experience.

char* webkitWebSettingsUserAgentForURI(WebKitWebSettings* webSettings, const char* uri)
{
    if (webSettings->priv->enableSiteSpecificQuirks) {
        String userAgentString = userAgentForURL(WebCore::URL(WebCore::URL(), String::fromUTF8(uri)));
        if (!userAgentString.isEmpty())
            return g_strdup(userAgentString.utf8().data());
    }



    coreSettings.setScriptEnabled(settingsPrivate->enableScripts);
    coreSettings.setPluginsEnabled(settingsPrivate->enablePlugins);
    coreSettings.setTextAreasAreResizable(settingsPrivate->resizableTextAreas);
    coreSettings.setUserStyleSheetLocation(URL(URL(), settingsPrivate->userStylesheetURI.data()));
    coreSettings.setDeveloperExtrasEnabled(settingsPrivate->enableDeveloperExtras);
    coreSettings.setPrivateBrowsingEnabled(settingsPrivate->enablePrivateBrowsing);
    coreSettings.setCaretBrowsingEnabled(settingsPrivate->enableCaretBrowsing);

    else if (name == g_intern_string("resizable-text-areas"))
        settings.setTextAreasAreResizable(g_value_get_boolean(&value));
    else if (name == g_intern_string("user-stylesheet-uri"))
        settings.setUserStyleSheetLocation(URL(URL(), g_value_get_string(&value)));
    else if (name == g_intern_string("enable-developer-extras"))
        settings.setDeveloperExtrasEnabled(g_value_get_boolean(&value));
    else if (name == g_intern_string("enable-private-browsing"))



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-26  Eric Carlson  <eric.carlson@apple.com>

        [MediaStream] make MediaStream testable



#import "WebTypesInternal.h"
#import <WebCore/HistoryItem.h>
#import <WebCore/Image.h>
#import <WebCore/URL.h>
#import <WebCore/PageCache.h>
#import <WebCore/RunLoop.h>
#import <WebCore/ThreadCheck.h>

- (NSURL *)URL
{
    ASSERT_MAIN_THREAD();
    const URL& url = core(_private)->url();
    if (url.isEmpty())
        return nil;
    return url;



#import "WebNSDataExtras.h"
#import "WebSystemInterface.h"
#import <Foundation/NSURLRequest.h>
#import <WebCore/URL.h>
#import <WebCore/LoaderNSURLExtras.h>
#import <WebCore/WebCoreNSURLExtras.h>
#import <WebKitSystemInterface.h>

        return self;
    }
    
    // This applies NSURL's concept of canonicalization, but not URL's concept. It would
    // make sense to apply both, but when we tried that it caused a performance degradation
    // (see 5315926). It might make sense to apply only the URL concept and not the NSURL
    // concept, but it's too risky to make that change for WebKit 3.0.
    NSURLRequest *newRequest = [concreteClass canonicalRequestForRequest:request];
    NSURL *newURL = [newRequest URL]; 

Lines 24-30 a/Source/WebKit/mac/Misc/WebUserContentURLPattern.mm_sec1
- a/Source/WebKit/mac/Misc/WebUserContentURLPattern.mm -1 / +1 lines
24		24
25	#import "WebUserContentURLPattern.h"	25	#import "WebUserContentURLPattern.h"
26		26
27	#import <WebCore/KURL.h>	27	#import <WebCore/URL.h>
28	#import <WebCore/UserContentURLPattern.h>	28	#import <WebCore/UserContentURLPattern.h>
29		29
30	using namespace WebCore;	30	using namespace WebCore;

Lines 53-59 a/Source/WebKit/mac/Plugins/Hosted/NetscapePluginInstanceProxy.mm_sec1
- a/Source/WebKit/mac/Plugins/Hosted/NetscapePluginInstanceProxy.mm -1 / +1 lines
53	#import <WebCore/Frame.h>	53	#import <WebCore/Frame.h>
54	#import <WebCore/FrameLoader.h>	54	#import <WebCore/FrameLoader.h>
55	#import <WebCore/FrameTree.h>	55	#import <WebCore/FrameTree.h>
56	#import <WebCore/KURL.h>	56	#import <WebCore/URL.h>
57	#import <WebCore/ProxyServer.h>	57	#import <WebCore/ProxyServer.h>
58	#import <WebCore/SecurityOrigin.h>	58	#import <WebCore/SecurityOrigin.h>
59	#import <WebCore/ScriptController.h>	59	#import <WebCore/ScriptController.h>

Lines 847-853 using namespace WebCore; a/Source/WebKit/mac/Plugins/WebBaseNetscapePluginView.mm_sec1
- a/Source/WebKit/mac/Plugins/WebBaseNetscapePluginView.mm -1 / +1 lines
847	if (!frame->document()->securityOrigin()->canAccess(targetFrame->document()->securityOrigin()))	847	if (!frame->document()->securityOrigin()->canAccess(targetFrame->document()->securityOrigin()))
848	return CString();	848	return CString();
849		849
850	KURL absoluteURL = targetFrame->document()->completeURL(relativeURLString);	850	URL absoluteURL = targetFrame->document()->completeURL(relativeURLString);
851	return absoluteURL.string().utf8();	851	return absoluteURL.string().utf8();
852	}	852	}
853		853




    void cancelLoadAndDestroyStreamWithError(NSError *);

    void setRequestURL(const WebCore::URL& requestURL) { m_requestURL = requestURL; }

    void start();
    void stop();

    bool wantsAllStreams() const;

    RetainPtr<NSMutableData> m_deliveryData;
    WebCore::URL m_requestURL;
    RetainPtr<NSURL> m_responseURL;
    CString m_mimeType;


Lines 39-45 public: a/Source/WebKit/mac/WebCoreSupport/WebContextMenuClient.h_sec1
- a/Source/WebKit/mac/WebCoreSupport/WebContextMenuClient.h -1 / +1 lines
39	virtual NSMutableArray* getCustomMenuFromDefaultItems(WebCore::ContextMenu*) OVERRIDE;	39	virtual NSMutableArray* getCustomMenuFromDefaultItems(WebCore::ContextMenu*) OVERRIDE;
40	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu) OVERRIDE;	40	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu) OVERRIDE;
41		41
42	virtual void downloadURL(const WebCore::KURL&) OVERRIDE;	42	virtual void downloadURL(const WebCore::URL&) OVERRIDE;
43	virtual void searchWithGoogle(const WebCore::Frame*) OVERRIDE;	43	virtual void searchWithGoogle(const WebCore::Frame*) OVERRIDE;
44	virtual void lookUpInDictionary(WebCore::Frame*) OVERRIDE;	44	virtual void lookUpInDictionary(WebCore::Frame*) OVERRIDE;
45	virtual bool isSpeaking() OVERRIDE;	45	virtual bool isSpeaking() OVERRIDE;



#import <WebCore/ContextMenu.h>
#import <WebCore/ContextMenuController.h>
#import <WebCore/Document.h>
#import <WebCore/URL.h>
#import <WebCore/LocalizedStrings.h>
#import <WebCore/Page.h>
#import <WebCore/Frame.h>

    }
}

void WebContextMenuClient::downloadURL(const URL& url)
{
    [m_webView _downloadURL:url];
}



    virtual void dispatchDidHandleOnloadEvents() OVERRIDE;
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() OVERRIDE;
    virtual void dispatchDidCancelClientRedirect() OVERRIDE;
    virtual void dispatchWillPerformClientRedirect(const WebCore::URL&, double interval, double fireDate) OVERRIDE;
    virtual void dispatchDidChangeLocationWithinPage() OVERRIDE;
    virtual void dispatchDidPushStateWithinPage() OVERRIDE;
    virtual void dispatchDidReplaceStateWithinPage() OVERRIDE;

    virtual void updateGlobalHistoryItemForPage() OVERRIDE;

    virtual void didDisplayInsecureContent() OVERRIDE;
    virtual void didRunInsecureContent(WebCore::SecurityOrigin*, const WebCore::URL&) OVERRIDE;
    virtual void didDetectXSS(const WebCore::URL&, bool didBlockEntirePage) OVERRIDE;

    virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) OVERRIDE;
    virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) OVERRIDE;


    virtual bool shouldFallBack(const WebCore::ResourceError&) OVERRIDE;

    virtual WTF::String userAgent(const WebCore::URL&) OVERRIDE;
    
    virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*) OVERRIDE;
    virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*) OVERRIDE;

    virtual void prepareForDataSourceReplacement() OVERRIDE;
    virtual PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&) OVERRIDE;

    virtual void setTitle(const WebCore::StringWithDirection&, const WebCore::URL&) OVERRIDE;

    virtual PassRefPtr<WebCore::Frame> createFrame(const WebCore::URL& url, const WTF::String& name, WebCore::HTMLFrameOwnerElement*,
                                        const WTF::String& referrer, bool allowsScrolling, int marginWidth, int marginHeight) OVERRIDE;
    virtual PassRefPtr<WebCore::Widget> createPlugin(const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::URL&, const Vector<WTF::String>&,
                                          const Vector<WTF::String>&, const WTF::String&, bool) OVERRIDE;
    virtual void recreatePlugin(WebCore::Widget*) OVERRIDE;
    virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget) OVERRIDE;
    
    virtual PassRefPtr<WebCore::Widget> createJavaAppletWidget(const WebCore::IntSize&, WebCore::HTMLAppletElement*, const WebCore::URL& baseURL,
                                                    const Vector<WTF::String>& paramNames, const Vector<WTF::String>& paramValues) OVERRIDE;
    
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
    virtual PassRefPtr<WebCore::Widget> createMediaPlayerProxyPlugin(const WebCore::IntSize&, WebCore::HTMLMediaElement*, const WebCore::URL&, 
                                        const Vector<WTF::String>&, const Vector<WTF::String>&, const WTF::String&) OVERRIDE;
    virtual void hideMediaPlayerProxyPlugin(WebCore::Widget*) OVERRIDE;
    virtual void showMediaPlayerProxyPlugin(WebCore::Widget*) OVERRIDE;
#endif
    
    virtual WebCore::ObjectContentType objectContentType(const WebCore::URL&, const WTF::String& mimeType, bool shouldPreferPlugInsForImages) OVERRIDE;
    virtual WTF::String overrideMediaType() const OVERRIDE;
    
    virtual void dispatchDidClearWindowObjectInWorld(WebCore::DOMWrapperWorld*) OVERRIDE;


    virtual PassRefPtr<WebCore::FrameNetworkingContext> createNetworkingContext();

    virtual bool shouldPaintBrokenImage(const WebCore::URL&) const;

    RetainPtr<WebFrame> m_webFrame;




}
#endif

bool WebFrameLoaderClient::shouldPaintBrokenImage(const URL& imageURL) const
{
    WebView *webView = getWebView(m_webFrame.get());
    WebResourceDelegateImplementationCache* implementations = WebViewGetResourceLoadDelegateImplementations(webView);

        CallFrameLoadDelegate(implementations->didCancelClientRedirectForFrameFunc, webView, @selector(webView:didCancelClientRedirectForFrame:), m_webFrame.get());
}

void WebFrameLoaderClient::dispatchWillPerformClientRedirect(const URL& url, double delay, double fireDate)
{
    WebView *webView = getWebView(m_webFrame.get());
    WebFrameLoadDelegateImplementationCache* implementations = WebViewGetFrameLoadDelegateImplementations(webView);

        CallFrameLoadDelegate(implementations->didDisplayInsecureContentFunc, webView, @selector(webViewDidDisplayInsecureContent:));
}

void WebFrameLoaderClient::didRunInsecureContent(SecurityOrigin* origin, const URL& insecureURL)
{
    WebView *webView = getWebView(m_webFrame.get());   
    WebFrameLoadDelegateImplementationCache* implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    }
}

void WebFrameLoaderClient::didDetectXSS(const URL& insecureURL, bool didBlockEntirePage)
{
    WebView *webView = getWebView(m_webFrame.get());   
    WebFrameLoadDelegateImplementationCache* implementations = WebViewGetFrameLoadDelegateImplementations(webView);

    return loader.release();
}

void WebFrameLoaderClient::setTitle(const StringWithDirection& title, const URL& url)
{
    WebView* view = getWebView(m_webFrame.get());
    

    return m_policyListener;
}

String WebFrameLoaderClient::userAgent(const URL& url)
{
    WebView *webView = getWebView(m_webFrame.get());
    ASSERT(webView);

    // We should never get here with nil for the WebView unless there is a bug somewhere else.
    // But if we do, it's better to return the empty string than just crashing on the spot.
    // Most other call sites are tolerant of nil because of Objective-C behavior, but this one
    // is not because the return value of _userAgentForURL is a const URL&.
    if (!webView)
        return emptyString();


    return [[[m_webFrame.get() _dataSource] representation] isKindOfClass:[WebHTMLRepresentation class]];
}

PassRefPtr<Frame> WebFrameLoaderClient::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
    const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;

    return 0;
}

ObjectContentType WebFrameLoaderClient::objectContentType(const URL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;



#endif // ENABLE(NETSCAPE_PLUGIN_API)

PassRefPtr<Widget> WebFrameLoaderClient::createPlugin(const IntSize& size, HTMLPlugInElement* element, const URL& url,
    const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;

    if (errorCode && m_webFrame) {
        WebResourceDelegateImplementationCache* implementations = WebViewGetResourceLoadDelegateImplementations(webView);
        if (implementations->plugInFailedWithErrorFunc) {
            URL pluginPageURL = document->completeURL(stripLeadingAndTrailingHTMLSpaces(parameterValue(paramNames, paramValues, "pluginspage")));
            if (!pluginPageURL.protocolIsInHTTPFamily())
                pluginPageURL = URL();
            NSString *pluginName = pluginPackage ? (NSString *)[pluginPackage pluginInfo].name : nil;

            NSError *error = [[NSError alloc] _initWithPluginErrorCode:errorCode

    END_BLOCK_OBJC_EXCEPTIONS;
}
    
PassRefPtr<Widget> WebFrameLoaderClient::createJavaAppletWidget(const IntSize& size, HTMLAppletElement* element, const URL& baseURL, 
    const Vector<String>& paramNames, const Vector<String>& paramValues)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;

}

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
PassRefPtr<Widget> WebFrameLoaderClient::createMediaPlayerProxyPlugin(const IntSize& size, HTMLMediaElement* element, const URL& url,
    const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType)
{
    BEGIN_BLOCK_OBJC_EXCEPTIONS;



    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy() OVERRIDE;

    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&) OVERRIDE;
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&) OVERRIDE;
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&) OVERRIDE;
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&) OVERRIDE;
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&) OVERRIDE;
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&) OVERRIDE;

    // WebCore::DatabaseStrategy
    // - Using default implementation.

    // - Using default implementation.

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL& baseURL, const WTF::AtomicString& attributeURL) OVERRIDE;
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash) OVERRIDE;
    
    // WebCore::PasteboardStrategy

    virtual long changeCount(const String& pasteboardName) OVERRIDE;
    virtual String uniqueName() OVERRIDE;
    virtual WebCore::Color color(const String& pasteboardName) OVERRIDE;
    virtual WebCore::URL url(const String& pasteboardName) OVERRIDE;

    virtual long addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) OVERRIDE;
    virtual long setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) OVERRIDE;



    return this;
}

String WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesForDOM(session, firstParty, url);
}

void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool WebPlatformStrategies::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesEnabled(session, firstParty, url);
}

String WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void WebPlatformStrategies::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(session, url, cookieName);
}

    END_BLOCK_OBJC_EXCEPTIONS;
}

bool WebPlatformStrategies::isLinkVisited(Page* page, LinkHash hash, const URL&, const AtomicString&)
{
    return page->group().isLinkVisited(hash);
}

    return PlatformPasteboard(pasteboardName).color();    
}

URL WebPlatformStrategies::url(const String& pasteboardName)
{
    return PlatformPasteboard(pasteboardName).url();
}



#import "WebApplicationCacheQuotaManager.h"
#import "WebDatabaseQuotaManager.h"
#import "WebQuotaManager.h"
#import <WebCore/URL.h>
#import <WebCore/DatabaseManager.h>
#import <WebCore/SecurityOrigin.h>


    if (!self)
        return nil;

    RefPtr<SecurityOrigin> origin = SecurityOrigin::create(URL([url absoluteURL]));
    origin->ref();
    _private = reinterpret_cast<WebSecurityOriginPrivate *>(origin.get());




#import "WebViewInternal.h"
#import <WebCore/ApplicationCacheStorage.h>
#import <WebCore/FrameLoader.h>
#import <WebCore/URL.h>
#import <WebCore/LegacyWebArchive.h>
#import <WebCore/MIMETypeRegistry.h>
#import <WebCore/ResourceBuffer.h>

// May return nil if not initialized with a URL.
- (NSURL *)_URL
{
    const URL& url = toPrivate(_private)->loader->url();
    if (url.isEmpty())
        return nil;
    return url;


- (NSURL *)unreachableURL
{
    const URL& unreachableURL = toPrivate(_private)->loader->unreachableURL();
    if (unreachableURL.isEmpty())
        return nil;
    return unreachableURL;

Lines 1417-1423 static NSURL *createUniqueWebDataURL() a/Source/WebKit/mac/WebView/WebFrame.mm_sec1
- a/Source/WebKit/mac/WebView/WebFrame.mm -1 / +1 lines
1417	if (!pthread_main_np())	1417	if (!pthread_main_np())
1418	return [[self _webkit_invokeOnMainThread] _loadData:data MIMEType:MIMEType textEncodingName:encodingName baseURL:baseURL unreachableURL:unreachableURL];	1418	return [[self _webkit_invokeOnMainThread] _loadData:data MIMEType:MIMEType textEncodingName:encodingName baseURL:baseURL unreachableURL:unreachableURL];
1419		1419
1420	KURL responseURL;	1420	URL responseURL;
1421	if (!baseURL) {	1421	if (!baseURL) {
1422	baseURL = blankURL();	1422	baseURL = blankURL();
1423	responseURL = createUniqueWebDataURL();	1423	responseURL = createUniqueWebDataURL();

Lines 3673-3679 static bool matchesExtensionOrEquivalent(NSString filename, NSString extension a/Source/WebKit/mac/WebView/WebHTMLView.mm_sec1
- a/Source/WebKit/mac/WebView/WebHTMLView.mm -1 / +1 lines
3673	if (!page)	3673	if (!page)
3674	return nil;	3674	return nil;
3675		3675
3676	const KURL& imageURL = page->dragController().draggingImageURL();	3676	const URL& imageURL = page->dragController().draggingImageURL();
3677	ASSERT(!imageURL.isEmpty());	3677	ASSERT(!imageURL.isEmpty());
3678	draggingImageURL = imageURL;	3678	draggingImageURL = imageURL;
3679		3679

Lines 56-62 a/Source/WebKit/mac/WebView/WebPDFView.mm_sec1
- a/Source/WebKit/mac/WebView/WebPDFView.mm -1 / +1 lines
56	#import <WebCore/FrameLoader.h>	56	#import <WebCore/FrameLoader.h>
57	#import <WebCore/HTMLFormElement.h>	57	#import <WebCore/HTMLFormElement.h>
58	#import <WebCore/HTMLFrameOwnerElement.h>	58	#import <WebCore/HTMLFrameOwnerElement.h>
59	#import <WebCore/KURL.h>	59	#import <WebCore/URL.h>
60	#import <WebCore/KeyboardEvent.h>	60	#import <WebCore/KeyboardEvent.h>
61	#import <WebCore/MouseEvent.h>	61	#import <WebCore/MouseEvent.h>
62	#import <WebCore/PlatformEventFactoryMac.h>	62	#import <WebCore/PlatformEventFactoryMac.h>



#import <WebCore/DOMWindow.h>
#import <WebCore/Frame.h>
#import <WebCore/JSDOMWindow.h>
#import <WebCore/URL.h>
#import <WebCore/ScriptController.h>

using namespace JSC;

{
    if (s.isEmpty())
        return nil;
    return URL(ParsedURLString, s);
}

static WebFrame *toWebFrame(JSGlobalObject* globalObject)

Lines 682-688 static NSString *leakOutlookQuirksUserScriptContents() a/Source/WebKit/mac/WebView/WebView.mm_sec1
- a/Source/WebKit/mac/WebView/WebView.mm -1 / +1 lines
682	{	682	{
683	static NSString *outlookQuirksScriptContents = leakOutlookQuirksUserScriptContents();	683	static NSString *outlookQuirksScriptContents = leakOutlookQuirksUserScriptContents();
684	core(self)->group().addUserScriptToWorld(core([WebScriptWorld world]),	684	core(self)->group().addUserScriptToWorld(core([WebScriptWorld world]),
685	outlookQuirksScriptContents, KURL(), Vector<String>(), Vector<String>(), InjectAtDocumentEnd, InjectInAllFrames);	685	outlookQuirksScriptContents, URL(), Vector<String>(), Vector<String>(), InjectAtDocumentEnd, InjectInAllFrames);
686	}	686	}
687		687
688	static bool shouldRespectPriorityInCSSAttributeSetters()	688	static bool shouldRespectPriorityInCSSAttributeSetters()

Lines 49-55 class Element; a/Source/WebKit/mac/WebView/WebViewInternal.h_sec1
- a/Source/WebKit/mac/WebView/WebViewInternal.h -1 / +1 lines
49	class Event;	49	class Event;
50	class Frame;	50	class Frame;
51	class HistoryItem;	51	class HistoryItem;
52	class KURL;	52	class URL;
53	class KeyboardEvent;	53	class KeyboardEvent;
54	class Page;	54	class Page;
55	class RenderBox;	55	class RenderBox;

Lines 26-32 a/Source/WebKit/qt/Api/qwebhistory.cpp_sec1
- a/Source/WebKit/qt/Api/qwebhistory.cpp -1 / +1 lines
26	#include "IconDatabaseBase.h"	26	#include "IconDatabaseBase.h"
27	#include "Image.h"	27	#include "Image.h"
28	#include "IntSize.h"	28	#include "IntSize.h"
29	#include "KURL.h"	29	#include "URL.h"
30	#include "Page.h"	30	#include "Page.h"
31	#include "PageGroup.h"	31	#include "PageGroup.h"
32	#include <QWebPageAdapter.h>	32	#include <QWebPageAdapter.h>

Lines 21-27 a/Source/WebKit/qt/Api/qwebscriptworld.cpp_sec1
- a/Source/WebKit/qt/Api/qwebscriptworld.cpp -1 / +1 lines
21	#include "qwebscriptworld.h"	21	#include "qwebscriptworld.h"
22	#include "qwebscriptworld_p.h"	22	#include "qwebscriptworld_p.h"
23		23
24	#include "KURL.h"	24	#include "URL.h"
25	#include "ScriptController.h"	25	#include "ScriptController.h"
26	#include <QStringList>	26	#include <QStringList>
27		27




#include "ApplicationCacheStorage.h"
#include "DatabaseManager.h"
#include "URL.h"
#include "SchemeRegistry.h"
#include "SecurityOrigin.h"
#include "SecurityPolicy.h"

*/
QWebSecurityOrigin::QWebSecurityOrigin(const QUrl& url)
{
    d = new QWebSecurityOriginPrivate(SecurityOrigin::create(URL(url)));
}

/*!



#endif
#include "InitWebCoreQt.h"
#include "IntSize.h"
#include "URL.h"
#include "MemoryCache.h"
#include "NetworkStateNotifier.h"
#include "Page.h"

        settings->setFrameFlatteningEnabled(value);

        QUrl location = !userStyleSheetLocation.isEmpty() ? userStyleSheetLocation : global->userStyleSheetLocation;
        settings->setUserStyleSheetLocation(WebCore::URL(location));

        QString encoding = !defaultTextEncoding.isEmpty() ? defaultTextEncoding: global->defaultTextEncoding;
        settings->setDefaultTextEncodingName(encoding);

QIcon QWebSettings::iconForUrl(const QUrl& url)
{
    WebCore::initializeWebCoreQt();
    QPixmap* icon = WebCore::iconDatabase().synchronousNativeIconForPageURL(WebCore::URL(url).string(),
                                WebCore::IntSize(16, 16));
    if (!icon)
        return QIcon();



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-27  Allan Sandfeld Jensen  <allan.jensen@digia.com>

        [Qt] Fix force_static_libs_as_shared in WebKit2




#include "ChromeClient.h"
#include "FloatRect.h"
#include "URL.h"
#include "QtPlatformPlugin.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/RefCounted.h>

    QWebFullScreenVideoHandler* createFullScreenVideoHandler();

    QWebPageAdapter* m_webPage;
    URL lastHoverURL;
    String lastHoverTitle;
    String lastHoverContent;





#include "ContextMenu.h"
#include "HitTestResult.h"
#include "URL.h"
#include "NotImplemented.h"

#include <wtf/RefCounted.h>

    notImplemented();
}

void ContextMenuClientQt::downloadURL(const URL&)
{
    notImplemented();
}

Lines 40-46 public: a/Source/WebKit/qt/WebCoreSupport/ContextMenuClientQt.h_sec1
- a/Source/WebKit/qt/WebCoreSupport/ContextMenuClientQt.h -1 / +1 lines
40	virtual PassOwnPtr<ContextMenu> customizeMenu(PassOwnPtr<ContextMenu>);	40	virtual PassOwnPtr<ContextMenu> customizeMenu(PassOwnPtr<ContextMenu>);
41	virtual void contextMenuItemSelected(ContextMenuItem, const ContextMenu);	41	virtual void contextMenuItemSelected(ContextMenuItem, const ContextMenu);
42		42
43	virtual void downloadURL(const KURL&);	43	virtual void downloadURL(const URL&);
44	virtual void lookUpInDictionary(Frame*);	44	virtual void lookUpInDictionary(Frame*);
45	virtual void speak(const String&);	45	virtual void speak(const String&);
46	virtual bool isSpeaking();	46	virtual bool isSpeaking();

Lines 733-739 QUrl DumpRenderTreeSupportQt::mediaContentUrlByElementId(QWebFrameAdapter* adapt a/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.cpp_sec1
- a/Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.cpp -1 / +1 lines
733	// API Candidate?	733	// API Candidate?
734	void DumpRenderTreeSupportQt::setAlternateHtml(QWebFrameAdapter* adapter, const QString& html, const QUrl& baseUrl, const QUrl& failingUrl)	734	void DumpRenderTreeSupportQt::setAlternateHtml(QWebFrameAdapter* adapter, const QString& html, const QUrl& baseUrl, const QUrl& failingUrl)
735	{	735	{
736	KURL kurl(baseUrl);	736	URL kurl(baseUrl);
737	WebCore::Frame* coreFrame = adapter->frame;	737	WebCore::Frame* coreFrame = adapter->frame;
738	WebCore::ResourceRequest request(kurl);	738	WebCore::ResourceRequest request(kurl);
739	const QByteArray utf8 = html.toUtf8();	739	const QByteArray utf8 = html.toUtf8();



    return QString::fromLatin1("Frame with user gesture \"%1\"").arg(QLatin1String("false"));
}

static QString drtDescriptionSuitableForTestResult(const WebCore::URL& kurl)
{
    if (kurl.isEmpty() || !kurl.isLocalFile())
        return kurl.string();

}


void FrameLoaderClientQt::dispatchWillPerformClientRedirect(const URL& url, double, double)
{
    if (dumpFrameLoaderCallbacks)
        printf("%s - willPerformClientRedirectToURL: %s \n", qPrintable(drtDescriptionSuitableForTestResult(m_frame)), qPrintable(drtDescriptionSuitableForTestResult(url)));

{
}

void FrameLoaderClientQt::setTitle(const StringWithDirection& title, const URL& url)
{
    // Used by Apple WebKit to update the title of an existing history item.
    // QtWebKit doesn't accomodate this on history items. If it ever does,

}


String FrameLoaderClientQt::userAgent(const URL& url)
{
    if (m_webFrame)
        return m_webFrame->pageAdapter->userAgentForUrl(url).remove(QLatin1Char('\n')).remove(QLatin1Char('\r'));

    notImplemented();
}

void FrameLoaderClientQt::didRunInsecureContent(WebCore::SecurityOrigin*, const URL&)
{
    if (dumpFrameLoaderCallbacks)
        printf("didRunInsecureContent\n");

    notImplemented();
}

void FrameLoaderClientQt::didDetectXSS(const URL&, bool)
{
    if (dumpFrameLoaderCallbacks)
        printf("didDetectXSS\n");

    if (!page->errorPageExtension(&option, &output))
        return false;

    URL baseUrl(output.baseUrl);
    URL failingUrl(option.url);

    WebCore::ResourceRequest request(baseUrl);
    WTF::RefPtr<WebCore::SharedBuffer> buffer = WebCore::SharedBuffer::create(output.content.constData(), output.content.length());

    m_webFrame->pageAdapter->emitDownloadRequested(request.toNetworkRequest(m_frame->loader().networkingContext()));
}

PassRefPtr<Frame> FrameLoaderClientQt::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
{
    if (!m_webFrame)
        return 0;


    // FIXME: Set override encoding if we have one.

    URL urlToLoad = url;
    if (urlToLoad.isEmpty())
        urlToLoad = blankURL();


    return frameData.frame.release();
}

ObjectContentType FrameLoaderClientQt::objectContentType(const URL& url, const String& mimeTypeIn, bool shouldPreferPlugInsForImages)
{
    // qDebug()<<" ++++++++++++++++ url is "<<url.string()<<", mime = "<<mimeTypeIn;
    QFileInfo fi(url.path());

};


PassRefPtr<Widget> FrameLoaderClientQt::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
    // qDebug()<<"------ Creating plugin in FrameLoaderClientQt::createPlugin for "<<url.string() << mimeType;
    // qDebug()<<"------\t url = "<<url.string();

        m_hasSentResponseToPlugin = false;
}

PassRefPtr<Widget> FrameLoaderClientQt::createJavaAppletWidget(const IntSize& pluginSize, HTMLAppletElement* element, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues)
{
    return createPlugin(pluginSize, element, url, paramNames, paramValues, "application/x-java-applet", true);
}



#include "FrameLoader.h"
#include "FrameLoaderClient.h"
#include "HTMLFormElement.h"
#include "URL.h"
#include "ResourceError.h"
#include "ResourceResponse.h"
#include "WebCore/plugins/PluginView.h"

    virtual void dispatchDidHandleOnloadEvents();
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad();
    virtual void dispatchDidCancelClientRedirect();
    virtual void dispatchWillPerformClientRedirect(const URL&, double interval, double fireDate);
    virtual void dispatchDidNavigateWithinPage() OVERRIDE;
    virtual void dispatchDidChangeLocationWithinPage();
    virtual void dispatchDidPushStateWithinPage();

    virtual bool shouldGoToHistoryItem(HistoryItem*) const;
    virtual bool shouldStopLoadingForHistoryItem(HistoryItem*) const;
    virtual void didDisplayInsecureContent();
    virtual void didRunInsecureContent(SecurityOrigin*, const URL&);
    virtual void didDetectXSS(const URL&, bool didBlockEntirePage);

    virtual ResourceError cancelledError(const ResourceRequest&);
    virtual ResourceError blockedError(const ResourceRequest&);

    virtual void prepareForDataSourceReplacement();

    virtual WTF::PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&);
    virtual void setTitle(const StringWithDirection&, const URL&);

    virtual String userAgent(const WebCore::URL&);

    virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*);
    virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*);

    virtual bool canCachePage() const;
    virtual void convertMainResourceLoadToDownload(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);

    virtual PassRefPtr<Frame> createFrame(const URL&, const String& name, HTMLFrameOwnerElement*, const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight);
    virtual PassRefPtr<Widget> createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool);
    virtual void recreatePlugin(Widget*) { }
    virtual void redirectDataToPlugin(Widget* pluginWidget);

    virtual PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL& baseURL, const Vector<String>& paramNames, const Vector<String>& paramValues);

    virtual ObjectContentType objectContentType(const URL&, const String& mimeTypeIn, bool shouldPreferPlugInsForImages);
    virtual String overrideMediaType() const;

    virtual void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);


    virtual PassRefPtr<FrameNetworkingContext> createNetworkingContext();

    const URL& lastRequestedUrl() const { return m_lastRequestedUrl; }

    QWebFrameAdapter* webFrame() const;


    WebCore::PluginView* m_pluginView;
    bool m_hasSentResponseToPlugin;

    URL m_lastRequestedUrl;
    bool m_isOriginatingLoad;
};




#include "Document.h"
#include "Event.h"
#include "EventNames.h"
#include "KURL.h"
#include "Page.h"
#include "QWebFrameAdapter.h"
#include "QWebPageAdapter.h"
#include "QtPlatformPlugin.h"
#include "ScriptExecutionContext.h"
#include "SecurityOrigin.h"
#include "URL.h"
#include "UserGestureIndicator.h"
#include "qwebkitglobal.h"




    return this;
}

String PlatformStrategiesQt::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesForDOM(session, firstParty, url);
}

void PlatformStrategiesQt::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool PlatformStrategiesQt::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesEnabled(session, firstParty, url);
}

String PlatformStrategiesQt::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool PlatformStrategiesQt::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void PlatformStrategiesQt::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(session, url, cookieName);
}


// VisitedLinkStrategy

bool PlatformStrategiesQt::isLinkVisited(Page* page, LinkHash hash, const URL& baseURL, const AtomicString& attributeURL)
{
    ASSERT(hash);




    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy();
    
    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&);

    // WebCore::DatabaseStrategy
    // - Using default implementation.

    virtual void getPluginInfo(const WebCore::Page*, Vector<WebCore::PluginInfo>&);

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL& baseURL, const WTF::AtomicString& attributeURL);
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash);
};




#include "HitTestResult.h"
#include "InspectorController.h"
#include "JSDOMWindowBase.h"
#include "URL.h"
#include "NavigationScheduler.h"
#include "NetworkingContext.h"
#include "NodeList.h"


void QWebFrameAdapter::setContent(const QByteArray &data, const QString &mimeType, const QUrl &baseUrl)
{
    URL kurl(baseUrl);
    WebCore::ResourceRequest request(kurl);
    WTF::RefPtr<WebCore::SharedBuffer> buffer = WebCore::SharedBuffer::create(data.constData(), data.length());
    QString actualMimeType;

        actualMimeType = extractMIMETypeFromMediaType(mimeType);
        encoding = extractCharsetFromMediaType(mimeType);
    }
    WebCore::SubstituteData substituteData(buffer, WTF::String(actualMimeType), encoding, URL());
    frame->loader().load(WebCore::FrameLoadRequest(frame, request, substituteData));
}

void QWebFrameAdapter::setHtml(const QString &html, const QUrl &baseUrl)
{
    URL kurl(baseUrl);
    WebCore::ResourceRequest request(kurl);
    const QByteArray utf8 = html.toUtf8();
    WTF::RefPtr<WebCore::SharedBuffer> data = WebCore::SharedBuffer::create(utf8.constData(), utf8.length());
    WebCore::SubstituteData substituteData(data, WTF::String("text/html"), WTF::String("utf-8"), URL());
    frame->loader().load(WebCore::FrameLoadRequest(frame, request, substituteData));
}


QUrl QWebFrameAdapter::ensureAbsoluteUrl(const QUrl& url)
{
    // FIXME: it would be nice if we could avoid doing this.
    // Convert to URL and back to preserve the old behavior (e.g. fixup of single slash in 'http:/')
    QUrl validatedUrl = URL(url);

    if (!validatedUrl.isValid() || !validatedUrl.isRelative())
        return validatedUrl;

Lines 1068-1074 void QWebPageAdapter::triggerAction(QWebPageAdapter::MenuAction action, QWebHitT a/Source/WebKit/qt/WebCoreSupport/QWebPageAdapter.cpp_sec1
- a/Source/WebKit/qt/WebCoreSupport/QWebPageAdapter.cpp -1 / +1 lines
1068	frame.loader().loadFrameRequest(frameLoadRequest(hitTestResult->linkUrl, &frame), /lockHistory/ false, /lockBackForwardList/ false, /event/ 0, /FormState/ 0, MaybeSendReferrer);	1068	frame.loader().loadFrameRequest(frameLoadRequest(hitTestResult->linkUrl, &frame), /lockHistory/ false, /lockBackForwardList/ false, /event/ 0, /FormState/ 0, MaybeSendReferrer);
1069	break;	1069	break;
1070	case OpenFrameInNewWindow: {	1070	case OpenFrameInNewWindow: {
1071	KURL url = frame.loader().documentLoader()->unreachableURL();	1071	URL url = frame.loader().documentLoader()->unreachableURL();
1072	if (url.isEmpty())	1072	if (url.isEmpty())
1073	url = frame.loader().documentLoader()->url();	1073	url = frame.loader().documentLoader()->url();
1074	openNewWindow(url, &frame);	1074	openNewWindow(url, &frame);



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-25  Roger Fong  <roger_fong@apple.com>

        [Windows] Attempting to scroll from a non-scrollable layer results the main document getting scrolled.




#include <WebCore/BString.h>
#include <WebCore/IntRect.h>
#include <WebCore/URL.h>
#include <wtf/DateMath.h>
#include <wtf/MathExtras.h>
#include <wtf/text/WTFString.h>

CFArrayCallBacks MarshallingHelpers::kIUnknownArrayCallBacks = {0, IUnknownRetainCallback, IUnknownReleaseCallback, 0, 0};
CFDictionaryValueCallBacks MarshallingHelpers::kIUnknownDictionaryValueCallBacks = {0, IUnknownRetainCallback, IUnknownReleaseCallback, 0, 0};

URL MarshallingHelpers::BSTRToKURL(BSTR urlStr)
{
    return URL(URL(), String(urlStr, SysStringLen(urlStr)));
}

BSTR MarshallingHelpers::URLToBSTR(const URL& url)
{
    return BString(url.string()).release();
}




namespace WebCore {
    class IntRect;
    class URL;
}

class MarshallingHelpers
{
public:
    static WebCore::URL BSTRToKURL(BSTR);
    static BSTR URLToBSTR(const WebCore::URL&);
    static CFURLRef PathStringToFileCFURLRef(const WTF::String&);
    static WTF::String FileCFURLRefToPathString(CFURLRef fileURL);
    static CFURLRef BSTRToCFURLRef(BSTR);



    uiDelegate->contextMenuItemSelected(m_webView, &selectedItem, propertyBag.get());
}

void WebContextMenuClient::downloadURL(const URL& url)
{
    m_webView->downloadURL(url);
}


    if (Page* page = frame->page()) {
        UserGestureIndicator indicator(DefinitelyProcessingUserGesture);
        page->mainFrame().loader().urlSelected(URL(ParsedURLString, url), String(), 0, false, false, MaybeSendReferrer);
    }
}


Lines 39-45 public: a/Source/WebKit/win/WebCoreSupport/WebContextMenuClient.h_sec1
- a/Source/WebKit/win/WebCoreSupport/WebContextMenuClient.h -1 / +1 lines
39	virtual PassOwnPtr<WebCore::ContextMenu> customizeMenu(PassOwnPtr<WebCore::ContextMenu>);	39	virtual PassOwnPtr<WebCore::ContextMenu> customizeMenu(PassOwnPtr<WebCore::ContextMenu>);
40	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu);	40	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu);
41		41
42	virtual void downloadURL(const WebCore::KURL&);	42	virtual void downloadURL(const WebCore::URL&);
43	virtual void searchWithGoogle(const WebCore::Frame*);	43	virtual void searchWithGoogle(const WebCore::Frame*);
44	virtual void lookUpInDictionary(WebCore::Frame*);	44	virtual void lookUpInDictionary(WebCore::Frame*);
45	virtual void speak(const WTF::String&);	45	virtual void speak(const WTF::String&);



#include "WebView.h"
#include <WebCore/BString.h>
#include <WebCore/Document.h>
#include <WebCore/URL.h>

#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)


{
}

NotificationClient::Permission WebDesktopNotificationsDelegate::checkPermission(const URL& url)
{
    int out = 0;
    BString org(SecurityOrigin::create(url)->toString());




namespace WebCore {
class Document;
class URL;
}

class WebDesktopNotificationsDelegate : public WebCore::NotificationClient {

    virtual void requestPermission(WebCore::SecurityOrigin*, PassRefPtr<WebCore::NotificationPermissionCallback>);
#endif
    virtual void cancelRequestsForPermission(WebCore::ScriptExecutionContext*);
    virtual WebCore::NotificationClient::Permission checkPermission(const URL&);

private:
    bool hasNotificationDelegate();



        frameLoadDelegate->didCancelClientRedirectForFrame(webView, m_webFrame);
}

void WebFrameLoaderClient::dispatchWillPerformClientRedirect(const URL& url, double delay, double fireDate)
{
    WebView* webView = m_webFrame->webView();
    COMPtr<IWebFrameLoadDelegate> frameLoadDelegate;

    frameLoadDelegatePriv2->didDisplayInsecureContent(webView);
}

void WebFrameLoaderClient::didRunInsecureContent(SecurityOrigin* origin, const URL& insecureURL)
{
    COMPtr<IWebSecurityOrigin> webSecurityOrigin = WebSecurityOrigin::createInstance(origin);


    frameLoadDelegatePriv2->didRunInsecureContent(webView, webSecurityOrigin.get());
}

void WebFrameLoaderClient::didDetectXSS(const URL&, bool)
{
    // FIXME: propogate call into the private delegate.
}

    return loader.release();
}

void WebFrameLoaderClient::setTitle(const StringWithDirection& title, const URL& url)
{
    WebView* webView = m_webFrame->webView();
    COMPtr<IWebHistoryDelegate> historyDelegate;

{
}

String WebFrameLoaderClient::userAgent(const URL& url)
{
    return m_webFrame->webView()->userAgentForKURL(url);
}

    return true;
}

PassRefPtr<Frame> WebFrameLoaderClient::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
                            const String& referrer, bool /*allowsScrolling*/, int /*marginWidth*/, int /*marginHeight*/)
{
    RefPtr<Frame> result = createFrame(url, name, ownerElement, referrer);

    return result.release();
}

PassRefPtr<Frame> WebFrameLoaderClient::createFrame(const URL& URL, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer)
{
    Frame* coreFrame = core(m_webFrame);
    ASSERT(coreFrame);

    return childFrame.release();
}

ObjectContentType WebFrameLoaderClient::objectContentType(const URL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
{
    return WebCore::FrameLoader::defaultObjectContentType(url, mimeType, shouldPreferPlugInsForImages);
}

    ASSERT(frame == pluginView->parentFrame());

    if (!pluginView->pluginsPage().isNull()) {
        URL pluginPageURL = frame->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(pluginView->pluginsPage()));
        if (pluginPageURL.protocolIsInHTTPFamily()) {
            static CFStringRef key = MarshallingHelpers::LPCOLESTRToCFStringRef(WebKitErrorPlugInPageURLStringKey);
            CFDictionarySetValue(userInfo.get(), key, pluginPageURL.string().createCFString().get());

    resourceLoadDelegate->plugInFailedWithError(webView, error.get(), getWebDataSource(frame->loader().documentLoader()));
}

PassRefPtr<Widget> WebFrameLoaderClient::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
    WebView* webView = m_webFrame->webView();


        m_manualLoader = static_cast<EmbeddedWidget*>(pluginWidget);
}

PassRefPtr<Widget> WebFrameLoaderClient::createJavaAppletWidget(const IntSize& pluginSize, HTMLAppletElement* element, const URL& /*baseURL*/, const Vector<String>& paramNames, const Vector<String>& paramValues)
{
    RefPtr<PluginView> pluginView = PluginView::create(core(m_webFrame), pluginSize, element, URL(), paramNames, paramValues, "application/x-java-applet", false);

    // Check if the plugin can be loaded successfully
    if (pluginView->plugin() && pluginView->plugin()->load())



    virtual void dispatchDidHandleOnloadEvents() OVERRIDE;
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() OVERRIDE;
    virtual void dispatchDidCancelClientRedirect() OVERRIDE;
    virtual void dispatchWillPerformClientRedirect(const WebCore::URL&, double interval, double fireDate) OVERRIDE;
    virtual void dispatchDidChangeLocationWithinPage() OVERRIDE;
    virtual void dispatchDidPushStateWithinPage() OVERRIDE;
    virtual void dispatchDidReplaceStateWithinPage() OVERRIDE;

    virtual void updateGlobalHistoryItemForPage() OVERRIDE;

    virtual void didDisplayInsecureContent() OVERRIDE;
    virtual void didRunInsecureContent(WebCore::SecurityOrigin*, const WebCore::URL&) OVERRIDE;
    virtual void didDetectXSS(const WebCore::URL&, bool didBlockEntirePage) OVERRIDE;

    virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) OVERRIDE;
    virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) OVERRIDE;


    virtual bool shouldFallBack(const WebCore::ResourceError&) OVERRIDE;

    virtual WTF::String userAgent(const WebCore::URL&) OVERRIDE;

    virtual PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&);
    virtual void setTitle(const WebCore::StringWithDirection&, const WebCore::URL&);

    virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*) OVERRIDE;
    virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*) OVERRIDE;


    virtual bool canCachePage() const;

    virtual PassRefPtr<WebCore::Frame> createFrame(const WebCore::URL& url, const WTF::String& name, WebCore::HTMLFrameOwnerElement* ownerElement,
        const WTF::String& referrer, bool allowsScrolling, int marginWidth, int marginHeight) OVERRIDE;
    virtual PassRefPtr<WebCore::Widget> createPlugin(const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::URL&, const Vector<WTF::String>&, const Vector<WTF::String>&, const WTF::String&, bool loadManually) OVERRIDE;
    virtual void recreatePlugin(WebCore::Widget*) OVERRIDE { }
    virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget) OVERRIDE;

    virtual PassRefPtr<WebCore::Widget> createJavaAppletWidget(const WebCore::IntSize&, WebCore::HTMLAppletElement*, const WebCore::URL& baseURL, const Vector<WTF::String>& paramNames, const Vector<WTF::String>& paramValues) OVERRIDE;

    virtual WebCore::ObjectContentType objectContentType(const WebCore::URL&, const WTF::String& mimeType, bool shouldPreferPlugInsForImages) OVERRIDE;
    virtual WTF::String overrideMediaType() const OVERRIDE;

    virtual void dispatchDidClearWindowObjectInWorld(WebCore::DOMWrapperWorld*) OVERRIDE;

    OwnPtr<WebFramePolicyListenerPrivate> m_policyListenerPrivate;

private:
    PassRefPtr<WebCore::Frame> createFrame(const WebCore::URL&, const WTF::String& name, WebCore::HTMLFrameOwnerElement*, const WTF::String& referrer);
    WebHistory* webHistory() const;

    WebFrame* m_webFrame;



    return this;
}

String WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesForDOM(session, firstParty, url);
}

void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool WebPlatformStrategies::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesEnabled(session, firstParty, url);
}

String WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void WebPlatformStrategies::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(session, url, cookieName);
}

    }
}

bool WebPlatformStrategies::isLinkVisited(Page* page, LinkHash hash, const URL&, const AtomicString&)
{
    return page->group().isLinkVisited(hash);
}



    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy();

    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&);

    // WebCore::DatabaseStrategy
    // - Using default implementation.

    virtual void getPluginInfo(const WebCore::Page*, Vector<WebCore::PluginInfo>&);

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL& baseURL, const WTF::AtomicString& attributeURL);
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash);
};




#include <WebCore/Document.h>
#include <WebCore/Frame.h>
#include <WebCore/FrameLoader.h>
#include <WebCore/URL.h>
#include <WebCore/ResourceBuffer.h>

using namespace WebCore;

HRESULT STDMETHODCALLTYPE WebDataSource::unreachableURL( 
    /* [retval][out] */ BSTR* url)
{
    URL unreachableURL = m_loader->unreachableURL();
    BString urlString((LPOLESTR)unreachableURL.string().characters(), unreachableURL.string().length());

    *url = urlString.release();

Lines 82-88 WebDownload* WebDownload::createInstance(ResourceHandle* handle, const ResourceR a/Source/WebKit/win/WebDownload.cpp_sec1
- a/Source/WebKit/win/WebDownload.cpp -1 / +1 lines
82	return instance;	82	return instance;
83	}	83	}
84		84
85	WebDownload* WebDownload::createInstance(const KURL& url, IWebDownloadDelegate* delegate)	85	WebDownload* WebDownload::createInstance(const URL& url, IWebDownloadDelegate* delegate)
86	{	86	{
87	WebDownload* instance = new WebDownload();	87	WebDownload* instance = new WebDownload();
88	instance->AddRef();	88	instance->AddRef();



#endif

namespace WebCore {
    class URL;
    class ResourceHandle;
    class ResourceRequest;
    class ResourceResponse;

#endif
{
public:
    static WebDownload* createInstance(const WebCore::URL&, IWebDownloadDelegate*);
    static WebDownload* createInstance(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, IWebDownloadDelegate*);
    static WebDownload* createInstance();
private:
    WebDownload();
    void init(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, IWebDownloadDelegate*);
    void init(const WebCore::URL&, IWebDownloadDelegate*);
    ~WebDownload();
public:
    // IUnknown

Lines 101-107 void WebDownload::init(ResourceHandle* handle, const ResourceRequest& request, c a/Source/WebKit/win/WebDownloadCFNet.cpp_sec1
- a/Source/WebKit/win/WebDownloadCFNet.cpp -1 / +1 lines
101	CFRelease(connection);	101	CFRelease(connection);
102	}	102	}
103		103
104	void WebDownload::init(const KURL& url, IWebDownloadDelegate* delegate)	104	void WebDownload::init(const URL& url, IWebDownloadDelegate* delegate)
105	{	105	{
106	m_delegate = delegate ? delegate : DefaultDownloadDelegate::sharedInstance();	106	m_delegate = delegate ? delegate : DefaultDownloadDelegate::sharedInstance();
107	LOG_ERROR("Delegate is %p", m_delegate.get());	107	LOG_ERROR("Delegate is %p", m_delegate.get());

Lines 72-78 void WebDownload::init(ResourceHandle* handle, const ResourceRequest& request, c a/Source/WebKit/win/WebDownloadCurl.cpp_sec1
- a/Source/WebKit/win/WebDownloadCurl.cpp -1 / +1 lines
72	start();	72	start();
73	}	73	}
74		74
75	void WebDownload::init(const KURL& url, IWebDownloadDelegate* delegate)	75	void WebDownload::init(const URL& url, IWebDownloadDelegate* delegate)
76	{	76	{
77	m_delegate = delegate;	77	m_delegate = delegate;
78		78

Lines 36-42 a/Source/WebKit/win/WebElementPropertyBag.cpp_sec1
- a/Source/WebKit/win/WebElementPropertyBag.cpp -1 / +1 lines
36	#include <WebCore/HitTestResult.h>	36	#include <WebCore/HitTestResult.h>
37	#include <WebCore/FrameLoader.h>	37	#include <WebCore/FrameLoader.h>
38	#include <WebCore/Image.h>	38	#include <WebCore/Image.h>
39	#include <WebCore/KURL.h>	39	#include <WebCore/URL.h>
40	#include <WebCore/RenderObject.h>	40	#include <WebCore/RenderObject.h>
41		41
42	using namespace WebCore;	42	using namespace WebCore;



    String encodingString(textEncodingName, SysStringLen(textEncodingName));

    // FIXME: We should really be using MarshallingHelpers::BSTRToKURL here,
    // but that would turn a null BSTR into a null URL, and we crash inside of
    // WebCore if we use a null URL in constructing the ResourceRequest.
    URL baseKURL = URL(URL(), String(baseURL ? baseURL : L"", SysStringLen(baseURL)));

    URL failingKURL = MarshallingHelpers::BSTRToKURL(failingURL);

    ResourceRequest request(baseKURL);
    SubstituteData substituteData(data, mimeTypeString, encodingString, failingKURL);

    return *source ? S_OK : E_FAIL;
}

URL WebFrame::url() const
{
    Frame* coreFrame = core(this);
    if (!coreFrame)
        return URL();

    return coreFrame->document()->url();
}



#include <WebCore/AdjustViewSizeOrNot.h>
#include <WebCore/FrameWin.h>
#include <WebCore/GraphicsContext.h>
#include <WebCore/URL.h>
#include <WebCore/ResourceHandleClient.h>

#include <WTF/RefPtr.h>

    HRESULT matchLabelsAgainstElement(const BSTR* labels, int cLabels, IDOMElement* againstElement, BSTR* result);
    HRESULT canProvideDocumentSource(bool* result);

    WebCore::URL url() const;

    WebView* webView() const;
    void setWebView(WebView*);

    class WebFramePrivate;
    WebFramePrivate*    d;
    bool                m_quickRedirectComing;
    WebCore::URL       m_originalRequestURL;
    bool                m_inPrintingMode;
    Vector<WebCore::IntRect> m_pageRects;
    int m_pageHeight;   // height of the page adjusted by margins



#include <CoreFoundation/CoreFoundation.h>
#include <WebCore/BString.h>
#include <WebCore/HistoryItem.h>
#include <WebCore/URL.h>
#include <WebCore/PageGroup.h>
#include <WebCore/SharedBuffer.h>
#include <functional>

    return hr;
}

void WebHistory::visitedURL(const URL& url, const String& title, const String& httpMethod, bool wasFailure, bool increaseVisitCount)
{
    IWebHistoryItem* entry = m_entriesByURL.get(url.string()).get();
    if (entry) {



#include <wtf/RetainPtr.h>

namespace WebCore {
    class URL;
    class PageGroup;
}



    // WebHistory
    static WebHistory* sharedHistory();
    void visitedURL(const WebCore::URL&, const WTF::String& title, const WTF::String& httpMethod, bool wasFailure, bool increaseVisitCount);
    void addVisitedLinksToPageGroup(WebCore::PageGroup&);

    COMPtr<IWebHistoryItem> itemForURLString(const WTF::String&) const;

Lines 33-39 a/Source/WebKit/win/WebHistoryItem.cpp_sec1
- a/Source/WebKit/win/WebHistoryItem.cpp -1 / +1 lines
33	#include <WebCore/BString.h>	33	#include <WebCore/BString.h>
34	#include <WebCore/COMPtr.h>	34	#include <WebCore/COMPtr.h>
35	#include <WebCore/HistoryItem.h>	35	#include <WebCore/HistoryItem.h>
36	#include <WebCore/KURL.h>	36	#include <WebCore/URL.h>
37	#include <wtf/PassOwnPtr.h>	37	#include <wtf/PassOwnPtr.h>
38	#include <wtf/RetainPtr.h>	38	#include <wtf/RetainPtr.h>
39	#include <wtf/text/CString.h>	39	#include <wtf/text/CString.h>



HRESULT STDMETHODCALLTYPE WebMutableURLRequest::mainDocumentURL( 
    /* [retval][out] */ BSTR* result)
{
    *result = MarshallingHelpers::URLToBSTR(m_request.firstPartyForCookies());
    return S_OK;
}


HRESULT STDMETHODCALLTYPE WebMutableURLRequest::URL( 
    /* [retval][out] */ BSTR* result)
{
    *result = MarshallingHelpers::URLToBSTR(m_request.url());
    return S_OK;
}


Lines 35-41 using namespace WebCore; a/Source/WebKit/win/WebResource.cpp_sec1
- a/Source/WebKit/win/WebResource.cpp -1 / +1 lines
35		35
36	// WebResource ---------------------------------------------------------------------	36	// WebResource ---------------------------------------------------------------------
37		37
38	WebResource::WebResource(IStream* data, const WebCore::KURL& url, const WTF::String& mimeType, const WTF::String& textEncodingName, const WTF::String& frameName)	38	WebResource::WebResource(IStream* data, const WebCore::URL& url, const WTF::String& mimeType, const WTF::String& textEncodingName, const WTF::String& frameName)
39	: m_refCount(0)	39	: m_refCount(0)
40	, m_data(data)	40	, m_data(data)
41	, m_url(url)	41	, m_url(url)




#include "WebKit.h"
#include <WebCore/COMPtr.h>
#include <WebCore/KURL.h>
#include <WebCore/ResourceResponse.h>
#include <WebCore/SharedBuffer.h>
#include <WebCore/URL.h>
#include <wtf/PassRefPtr.h>
#include <wtf/text/WTFString.h>


public:
    static WebResource* createInstance(PassRefPtr<WebCore::SharedBuffer> data, const WebCore::ResourceResponse& response);
protected:
    WebResource(IStream* data, const WebCore::URL&, const WTF::String& mimeType, const WTF::String& textEncodingName, const WTF::String& frameName);
    ~WebResource();

public:

private:
    ULONG m_refCount;
    COMPtr<IStream> m_data;
    WebCore::URL m_url;
    WTF::String m_mimeType;
    WTF::String m_textEncodingName;
    WTF::String m_frameName;




#include <wtf/platform.h>
#include <WebCore/BString.h>
#include <WebCore/URL.h>
#include <WebCore/LocalizedStrings.h>
#include <WebCore/ResourceHandle.h>
#include <shlobj.h>

{
    WebURLResponse* instance = new WebURLResponse();
    // fake an http response - so it has the IWebHTTPURLResponse interface
    instance->m_response = ResourceResponse(WebCore::URL(ParsedURLString, "http://"), String(), 0, String(), String());
    instance->AddRef();
    return instance;
}

Lines 29-35 a/Source/WebKit/win/WebUserContentURLPattern.cpp_sec1
- a/Source/WebKit/win/WebUserContentURLPattern.cpp -1 / +1 lines
29	#include "WebKitDLL.h"	29	#include "WebKitDLL.h"
30		30
31	#include <WebCore/BString.h>	31	#include <WebCore/BString.h>
32	#include <WebCore/KURL.h>	32	#include <WebCore/URL.h>
33		33
34	using namespace WebCore;	34	using namespace WebCore;
35		35



    return String(bstr, SysStringLen(bstr));
}

static inline URL toURL(BSTR bstr)
{
    return URL(URL(), toString(bstr));
}

class PreferencesChangedOrRemovedObserver : public IWebNotificationObserver {

    return buildNumberStringPtr;
}

const String& WebView::userAgentForKURL(const URL&)
{
    if (m_userAgentOverridden)
        return m_userAgentCustom;

        settings.setUserStyleSheetLocation(url.get());
        str.clear();
    } else
        settings.setUserStyleSheetLocation(URL());

    hr = preferences->shouldPrintBackgrounds(&enabled);
    if (FAILED(hr))

    if (!pageGroup)
        return E_FAIL;

    pageGroup->addUserScriptToWorld(world->world(), toString(source), toURL(url),
                                    toStringVector(whitelistCount, whitelist), toStringVector(blacklistCount, blacklist),
                                    injectionTime == WebInjectAtDocumentStart ? InjectAtDocumentStart : InjectAtDocumentEnd,
                                    InjectInAllFrames);

    if (!pageGroup)
        return E_FAIL;

    pageGroup->addUserStyleSheetToWorld(world->world(), toString(source), toURL(url),
                                        toStringVector(whitelistCount, whitelist), toStringVector(blacklistCount, blacklist),
                                        InjectInAllFrames);


    if (!pageGroup)
        return E_FAIL;

    pageGroup->removeUserScriptFromWorld(world->world(), toURL(url));

    return S_OK;
}

    if (!pageGroup)
        return E_FAIL;

    pageGroup->removeUserStyleSheetFromWorld(world->world(), toURL(url));

    return S_OK;
}

    return S_OK;
}

void WebView::downloadURL(const URL& url)
{
    // It's the delegate's job to ref the WebDownload to keep it alive - otherwise it will be
    // destroyed when this function returns.




    // Convenient to be able to violate the rules of COM here for easy movement to the frame.
    WebFrame* topLevelFrame() const { return m_mainFrame; }
    const WTF::String& userAgentForKURL(const WebCore::URL& url);

    static bool canHandleRequest(const WebCore::ResourceRequest&);


    bool onGetObject(WPARAM, LPARAM, LRESULT&) const;
    static STDMETHODIMP AccessibleObjectFromWindow(HWND, DWORD objectID, REFIID, void** ppObject);

    void downloadURL(const WebCore::URL&);

#if USE(ACCELERATED_COMPOSITING)
    void flushPendingGraphicsLayerChangesSoon();



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-16  Enrica Casucci  <enrica@apple.com>

        Remove unused function didSetSelectionTypesForPasteboard from EditorClient.

Lines 52-58 void ContextMenuClientWinCE::contextMenuItemSelected(ContextMenuItem*, const Con a/Source/WebKit/wince/WebCoreSupport/ContextMenuClientWinCE.cpp_sec1
- a/Source/WebKit/wince/WebCoreSupport/ContextMenuClientWinCE.cpp -1 / +1 lines
52	notImplemented();	52	notImplemented();
53	}	53	}
54		54
55	void ContextMenuClientWinCE::downloadURL(const KURL& url)	55	void ContextMenuClientWinCE::downloadURL(const URL& url)
56	{	56	{
57	notImplemented();	57	notImplemented();
58	}	58	}

Lines 40-46 public: a/Source/WebKit/wince/WebCoreSupport/ContextMenuClientWinCE.h_sec1
- a/Source/WebKit/wince/WebCoreSupport/ContextMenuClientWinCE.h -1 / +1 lines
40	virtual PassOwnPtr<WebCore::ContextMenu> customizeMenu(PassOwnPtr<WebCore::ContextMenu>);	40	virtual PassOwnPtr<WebCore::ContextMenu> customizeMenu(PassOwnPtr<WebCore::ContextMenu>);
41	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu);	41	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu);
42		42
43	virtual void downloadURL(const WebCore::KURL&);	43	virtual void downloadURL(const WebCore::URL&);
44	virtual void copyImageToClipboard(const WebCore::HitTestResult&);	44	virtual void copyImageToClipboard(const WebCore::HitTestResult&);
45	virtual void searchWithGoogle(const WebCore::Frame*);	45	virtual void searchWithGoogle(const WebCore::Frame*);
46	virtual void lookUpInDictionary(WebCore::Frame*);	46	virtual void lookUpInDictionary(WebCore::Frame*);



{
}

String FrameLoaderClientWinCE::userAgent(const URL&)
{
    DEFINE_STATIC_LOCAL(String, userAgentString, ());


    (m_frame->loader().policyChecker()->*policyFunction)(PolicyUse);
}

PassRefPtr<Widget> FrameLoaderClientWinCE::createPlugin(const IntSize&, HTMLPlugInElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&, bool)
{
    return 0;
}

PassRefPtr<Frame> FrameLoaderClientWinCE::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
                                                 const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
{
    return m_webView->createFrame(url, name, ownerElement, referrer, allowsScrolling, marginWidth, marginHeight);

        m_hasSentResponseToPlugin = false;
}

PassRefPtr<Widget> FrameLoaderClientWinCE::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const URL&, const Vector<String>&, const Vector<String>&)
{
    notImplemented();
    return 0;
}

ObjectContentType FrameLoaderClientWinCE::objectContentType(const URL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
{
    return FrameLoader::defaultObjectContentType(url, mimeType, shouldPreferPlugInsForImages);
}

    notImplemented();
}

void FrameLoaderClientWinCE::didRunInsecureContent(SecurityOrigin*, const URL&)
{
    notImplemented();
}

void FrameLoaderClientWinCE::didDetectXSS(const URL&, bool)
{
    notImplemented();
}

    notImplemented();
}

void FrameLoaderClientWinCE::dispatchWillPerformClientRedirect(const URL&, double, double)
{
    notImplemented();
}

    notImplemented();
}

void FrameLoaderClientWinCE::setTitle(const StringWithDirection&, const URL&)
{
    notImplemented();
}


PassRefPtr<WebCore::FrameNetworkingContext> FrameLoaderClientWinCE::createNetworkingContext()
{
    return FrameNetworkingContextWinCE::create(m_frame, userAgent(URL()));
}

} // namespace WebKit



    virtual void dispatchDidHandleOnloadEvents();
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad();
    virtual void dispatchDidCancelClientRedirect();
    virtual void dispatchWillPerformClientRedirect(const WebCore::URL&, double, double);
    virtual void dispatchDidChangeLocationWithinPage();
    virtual void dispatchDidPushStateWithinPage();
    virtual void dispatchDidReplaceStateWithinPage();

    virtual void postProgressEstimateChangedNotification();
    virtual void postProgressFinishedNotification();

    virtual PassRefPtr<WebCore::Frame> createFrame(const WebCore::URL&, const WTF::String& name, WebCore::HTMLFrameOwnerElement*, const WTF::String& referrer, bool allowsScrolling, int marginWidth, int marginHeight);
    virtual PassRefPtr<WebCore::Widget> createPlugin(const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::URL&, const WTF::Vector<WTF::String>&, const WTF::Vector<WTF::String>&, const WTF::String&, bool);
    virtual PassRefPtr<WebCore::Widget> createPlugin(const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::KURL&, const WTF::Vector<WTF::String>&, const WTF::Vector<WTF::String>&, const WTF::String&, bool);
    virtual void recreatePlugin(WebCore::Widget*) { }
    virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget);
    virtual PassRefPtr<WebCore::Widget> createJavaAppletWidget(const WebCore::IntSize&, WebCore::HTMLAppletElement*, const WebCore::URL& baseURL, const WTF::Vector<WTF::String>& paramNames, const WTF::Vector<WTF::String>& paramValues);
    virtual WTF::String overrideMediaType() const;
    virtual void dispatchDidClearWindowObjectInWorld(WebCore::DOMWrapperWorld*);
    virtual void documentElementAvailable();


    virtual void registerForIconNotification(bool);

    virtual WebCore::ObjectContentType objectContentType(const WebCore::URL&, const WTF::String& mimeType, bool shouldPreferPlugInsForImages);

    virtual void setMainFrameDocumentReady(bool);


    virtual bool shouldStopLoadingForHistoryItem(WebCore::HistoryItem*) const;

    virtual void didDisplayInsecureContent();
    virtual void didRunInsecureContent(WebCore::SecurityOrigin*, const WebCore::URL&);
    virtual void didDetectXSS(const WebCore::URL&, bool didBlockEntirePage);

    virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&);
    virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&);

    virtual void prepareForDataSourceReplacement();

    virtual WTF::PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&);
    virtual void setTitle(const WebCore::StringWithDirection&, const WebCore::URL&);

    virtual WTF::String userAgent(const WebCore::URL&);

    virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*);
    virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*);



    return this;
}

String PlatformStrategiesWinCE::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesForDOM(session, firstParty, url);
}

void PlatformStrategiesWinCE::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool PlatformStrategiesWinCE::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookiesEnabled(session, firstParty, url);
}

String PlatformStrategiesWinCE::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool PlatformStrategiesWinCE::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void PlatformStrategiesWinCE::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(session, url, cookieName);
}

    }
}

bool PlatformStrategiesWinCE::isLinkVisited(Page* page, LinkHash hash, const URL&, const AtomicString&)
{
    return page->group().isLinkVisited(hash);
}



    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy();

    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&);
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&);

    // WebCore::DatabaseStrategy
    // - Using default implementation.

    virtual void getPluginInfo(const WebCore::Page*, Vector<WebCore::PluginInfo>&);

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL&, const WTF::AtomicString&);
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash);
};


Lines 155-161 void WebView::cleanup() a/Source/WebKit/wince/WebView.cpp_sec1
- a/Source/WebKit/wince/WebView.cpp -1 / +1 lines
155	UnregisterClass(kWebViewWindowClassName, WebCore::instanceHandle());	155	UnregisterClass(kWebViewWindowClassName, WebCore::instanceHandle());
156	}	156	}
157		157
158	PassRefPtr<Frame> WebView::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer,	158	PassRefPtr<Frame> WebView::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer,
159	bool /allowsScrolling/, int /marginWidth/, int /marginHeight/)	159	bool /allowsScrolling/, int /marginWidth/, int /marginHeight/)
160	{	160	{
161	Frame* coreFrame = m_frame;	161	Frame* coreFrame = m_frame;



class Page;
class FrameView;
class HTMLFrameOwnerElement;
class URL;
class ResourceRequest;
}



    void frameRect(RECT* rect) const;

    PassRefPtr<WebCore::Frame> createFrame(const WebCore::URL&, const WTF::String&, WebCore::HTMLFrameOwnerElement*, const WTF::String&, bool, int, int);

    // JavaScript Dialog
    void runJavaScriptAlert(const WTF::String& message);



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-27  Allan Sandfeld Jensen  <allan.jensen@digia.com>

        [Qt] Fix force_static_libs_as_shared in WebKit2



{
}

void NetworkBlobRegistry::registerBlobURL(NetworkConnectionToWebProcess* connection, const URL& url, PassOwnPtr<BlobData> data, const Vector<RefPtr<SandboxExtension>>& newSandboxExtensions)
{
    ASSERT(!m_sandboxExtensions.contains(url.string()));


    ASSERT(!m_blobsForConnection.get(connection).contains(url));
    BlobForConnectionMap::iterator mapIterator = m_blobsForConnection.find(connection);
    if (mapIterator == m_blobsForConnection.end())
        mapIterator = m_blobsForConnection.add(connection, HashSet<URL>()).iterator;
    mapIterator->value.add(url);
}

void NetworkBlobRegistry::registerBlobURL(NetworkConnectionToWebProcess* connection, const WebCore::URL& url, const WebCore::URL& srcURL)
{
    blobRegistry().registerBlobURL(url, srcURL);
    SandboxExtensionMap::iterator iter = m_sandboxExtensions.find(srcURL.string());

    m_blobsForConnection.find(connection)->value.add(url);
}

void NetworkBlobRegistry::unregisterBlobURL(NetworkConnectionToWebProcess* connection, const WebCore::URL& url)
{
    blobRegistry().unregisterBlobURL(url);
    m_sandboxExtensions.remove(url.string());

    if (!m_blobsForConnection.contains(connection))
        return;

    HashSet<URL>& blobsForConnection = m_blobsForConnection.find(connection)->value;
    for (HashSet<URL>::iterator iter = blobsForConnection.begin(), end = blobsForConnection.end(); iter != end; ++iter) {
        blobRegistry().unregisterBlobURL(*iter);
        m_sandboxExtensions.remove(*iter);
    }

    m_blobsForConnection.remove(connection);
}

const Vector<RefPtr<SandboxExtension>> NetworkBlobRegistry::sandboxExtensions(const WebCore::URL& url)
{
    return m_sandboxExtensions.get(url.string());
}




#if ENABLE(BLOB) && ENABLE(NETWORK_PROCESS)

#include <WebCore/URLHash.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>


    NetworkBlobRegistry();
    static NetworkBlobRegistry& shared();

    void registerBlobURL(NetworkConnectionToWebProcess*, const WebCore::URL&, PassOwnPtr<WebCore::BlobData>, const Vector<RefPtr<SandboxExtension>>&);
    void registerBlobURL(NetworkConnectionToWebProcess*, const WebCore::URL&, const WebCore::URL& srcURL);
    void unregisterBlobURL(NetworkConnectionToWebProcess*, const WebCore::URL&);

    void connectionToWebProcessDidClose(NetworkConnectionToWebProcess*);

    const Vector<RefPtr<SandboxExtension>> sandboxExtensions(const WebCore::URL&);

private:
    ~NetworkBlobRegistry();

    typedef HashMap<String, Vector<RefPtr<SandboxExtension>>> SandboxExtensionMap;
    SandboxExtensionMap m_sandboxExtensions;

    typedef HashMap<NetworkConnectionToWebProcess*, HashSet<WebCore::URL>> BlobForConnectionMap;
    BlobForConnectionMap m_blobsForConnection;
};




    loader->didConvertHandleToDownload();
}

void NetworkConnectionToWebProcess::cookiesForDOM(bool privateBrowsingEnabled, const URL& firstParty, const URL& url, String& result)
{
    result = WebCore::cookiesForDOM(storageSession(privateBrowsingEnabled), firstParty, url);
}

void NetworkConnectionToWebProcess::setCookiesFromDOM(bool privateBrowsingEnabled, const URL& firstParty, const URL& url, const String& cookieString)
{
    WebCore::setCookiesFromDOM(storageSession(privateBrowsingEnabled), firstParty, url, cookieString);
}

void NetworkConnectionToWebProcess::cookiesEnabled(bool privateBrowsingEnabled, const URL& firstParty, const URL& url, bool& result)
{
    result = WebCore::cookiesEnabled(storageSession(privateBrowsingEnabled), firstParty, url);
}

void NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue(bool privateBrowsingEnabled, const URL& firstParty, const URL& url, String& result)
{
    result = WebCore::cookieRequestHeaderFieldValue(storageSession(privateBrowsingEnabled), firstParty, url);
}

void NetworkConnectionToWebProcess::getRawCookies(bool privateBrowsingEnabled, const URL& firstParty, const URL& url, Vector<Cookie>& result)
{
    WebCore::getRawCookies(storageSession(privateBrowsingEnabled), firstParty, url, result);
}

void NetworkConnectionToWebProcess::deleteCookie(bool privateBrowsingEnabled, const URL& url, const String& cookieName)
{
    WebCore::deleteCookie(storageSession(privateBrowsingEnabled), url, cookieName);
}

void NetworkConnectionToWebProcess::registerBlobURL(const URL& url, const BlobRegistrationData& data)
{
    Vector<RefPtr<SandboxExtension>> extensions;
    for (size_t i = 0, count = data.sandboxExtensions().size(); i < count; ++i) {

    NetworkBlobRegistry::shared().registerBlobURL(this, url, data.releaseData(), extensions);
}

void NetworkConnectionToWebProcess::registerBlobURLFromURL(const URL& url, const URL& srcURL)
{
    NetworkBlobRegistry::shared().registerBlobURL(this, url, srcURL);
}

void NetworkConnectionToWebProcess::unregisterBlobURL(const URL& url)
{
    NetworkBlobRegistry::shared().unregisterBlobURL(this, url);
}



    void performSynchronousLoad(const NetworkResourceLoadParameters&, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);

    void removeLoadIdentifier(ResourceLoadIdentifier);
    void crossOriginRedirectReceived(ResourceLoadIdentifier, const WebCore::URL& redirectURL);
    void servePendingRequests(uint32_t resourceLoadPriority);
    void setSerialLoadingEnabled(bool);
    void startDownload(bool privateBrowsingEnabled, uint64_t downloadID, const WebCore::ResourceRequest&);
    void convertMainResourceLoadToDownload(uint64_t mainResourceLoadIdentifier, uint64_t downloadID, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);

    void cookiesForDOM(bool privateBrowsingEnabled, const WebCore::URL& firstParty, const WebCore::URL&, String& result);
    void setCookiesFromDOM(bool privateBrowsingEnabled, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
    void cookiesEnabled(bool privateBrowsingEnabled, const WebCore::URL& firstParty, const WebCore::URL&, bool& result);
    void cookieRequestHeaderFieldValue(bool privateBrowsingEnabled, const WebCore::URL& firstParty, const WebCore::URL&, String& result);
    void getRawCookies(bool privateBrowsingEnabled, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
    void deleteCookie(bool privateBrowsingEnabled, const WebCore::URL&, const String& cookieName);

    void registerBlobURL(const WebCore::URL&, const BlobRegistrationData&);
    void registerBlobURLFromURL(const WebCore::URL&, const WebCore::URL& srcURL);
    void unregisterBlobURL(const WebCore::URL&);

    RefPtr<CoreIPC::Connection> m_connection;




    StartDownload(bool privateBrowsingEnabled, uint64_t downloadID, WebCore::ResourceRequest request)
    ConvertMainResourceLoadToDownload(uint64_t mainResourceLoadIdentifier, uint64_t downloadID, WebCore::ResourceRequest request, WebCore::ResourceResponse response)

    CookiesForDOM(bool privateBrowsingEnabled, WebCore::URL firstParty, WebCore::URL url) -> (WTF::String result)
    SetCookiesFromDOM(bool privateBrowsingEnabled, WebCore::URL firstParty, WebCore::URL url, WTF::String cookieString)
    CookiesEnabled(bool privateBrowsingEnabled, WebCore::URL firstParty, WebCore::URL url) -> (bool enabled)
    CookieRequestHeaderFieldValue(bool privateBrowsingEnabled, WebCore::URL firstParty, WebCore::URL url) -> (WTF::String result)
    GetRawCookies(bool privateBrowsingEnabled, WebCore::URL firstParty, WebCore::URL url) -> (WTF::Vector<WebCore::Cookie> cookies)
    DeleteCookie(bool privateBrowsingEnabled, WebCore::URL url, WTF::String cookieName)

    RegisterBlobURL(WebCore::URL url, WebKit::BlobRegistrationData data)
    RegisterBlobURLFromURL(WebCore::URL url, WebCore::URL srcURL)
    UnregisterBlobURL(WebCore::URL url)
}

#endif // ENABLE(NETWORK_PROCESS)



    scheduleServePendingRequests();
}

HostRecord* NetworkResourceLoadScheduler::hostForURL(const WebCore::URL& url, CreateHostPolicy createHostPolicy)
{
    if (!url.protocolIsInHTTPFamily())
        return m_nonHTTPProtocolHost.get();

    scheduleServePendingRequests();
}

void NetworkResourceLoadScheduler::receivedRedirect(NetworkResourceLoader* loader, const WebCore::URL& redirectURL)
{
    ASSERT(isMainThread());
    LOG(NetworkScheduling, "(NetworkProcess) NetworkResourceLoadScheduler::receivedRedirect loader originally for '%s' redirected to '%s'", loader->request().url().string().utf8().data(), redirectURL.string().utf8().data());



#if ENABLE(NETWORK_PROCESS)

namespace WebCore {
class URL;
}

namespace WebKit {

    // Called within the NetworkProcess on a background thread when a resource load has finished.
    void scheduleRemoveLoader(NetworkResourceLoader*);

    void receivedRedirect(NetworkResourceLoader*, const WebCore::URL& redirectURL);
    void servePendingRequests(WebCore::ResourceLoadPriority = WebCore::ResourceLoadPriorityVeryLow);

    // For NetworkProcess statistics reporting.

        FindOnly
    };
    
    HostRecord* hostForURL(const WebCore::URL&, CreateHostPolicy = FindOnly);
    
    void scheduleServePendingRequests();
    void requestTimerFired(WebCore::Timer<NetworkResourceLoadScheduler>*);



    NSMutableDictionary *proxySettings = [NSMutableDictionary dictionary];

    if (!httpProxy.isNull()) {
        URL httpProxyURL(URL(), httpProxy);
        if (httpProxyURL.isValid()) {
            [proxySettings setObject:nsStringFromWebCoreString(httpProxyURL.host()) forKey:(NSString *)kCFNetworkProxiesHTTPProxy];
            if (httpProxyURL.hasPort()) {

    }

    if (!httpsProxy.isNull()) {
        URL httpsProxyURL(URL(), httpsProxy);
        if (httpsProxyURL.isValid()) {
            [proxySettings setObject:nsStringFromWebCoreString(httpsProxyURL.host()) forKey:(NSString *)kCFNetworkProxiesHTTPSProxy];
            if (httpsProxyURL.hasPort()) {




void PluginControllerProxy::streamDidReceiveResponse(uint64_t streamID, const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers)
{
    m_plugin->streamDidReceiveResponse(streamID, URL(ParsedURLString, responseURLString), streamLength, lastModifiedTime, mimeType, headers, String());
}

void PluginControllerProxy::streamDidReceiveData(uint64_t streamID, const CoreIPC::DataReference& data)

    if (m_pluginCanceledManualStreamLoad)
        return;

    m_plugin->manualStreamDidReceiveResponse(URL(ParsedURLString, responseURLString), streamLength, lastModifiedTime, mimeType, headers, String());
}

void PluginControllerProxy::manualStreamDidReceiveData(const CoreIPC::DataReference& data)



static bool openCFURLRef(CFURLRef url, int32_t& status, CFURLRef* launchedURL)
{
    String launchedURLString;
    if (!PluginProcess::shared().openURL(URL(url).string(), status, launchedURLString))
        return false;

    if (!launchedURLString.isNull() && launchedURL)
        *launchedURL = URL(ParsedURLString, launchedURLString).createCFURL().leakRef();
    return true;
}


        }
    }

    if (PluginProcess::shared().launchApplicationAtURL(URL(url).string(), arguments)) {
        if (error)
            *error = nil;
        return nil;




#include "WKAPICast.h"
#include "WebURLRequest.h"
#include <WebCore/URL.h>

using namespace WebCore;
using namespace WebKit;


WKURLRequestRef WKURLRequestCreateWithWKURL(WKURLRef url)
{
    return toAPI(WebURLRequest::create(URL(URL(), toImpl(url)->string())).leakRef());
}

WKURLRef WKURLRequestCopyURL(WKURLRequestRef requestRef)

Lines 28-34 a/Source/WebKit2/Shared/API/c/WKURLResponse.cpp_sec1
- a/Source/WebKit2/Shared/API/c/WKURLResponse.cpp -1 / +1 lines
28		28
29	#include "WKAPICast.h"	29	#include "WKAPICast.h"
30	#include "WebURLResponse.h"	30	#include "WebURLResponse.h"
31	#include <WebCore/KURL.h>	31	#include <WebCore/URL.h>
32		32
33	using namespace WebKit;	33	using namespace WebKit;
34		34



    // We first create a CString and then create the CFURL from it. This will ensure that the CFURL is stored in 
    // UTF-8 which uses less memory and is what WebKit clients might expect.

    // This pattern of using UTF-8 and then falling back to Latin1 on failure matches URL::createCFString with the
    // major differnce being that URL does not do a UTF-8 conversion and instead chops off the high bits of the UTF-16
    // character sequence.

    CString buffer = toImpl(URLRef)->string().utf8();

Lines 66-72 QString QtFileDownloader::determineFilename() a/Source/WebKit2/Shared/Downloads/qt/QtFileDownloader.cpp_sec1
- a/Source/WebKit2/Shared/Downloads/qt/QtFileDownloader.cpp -1 / +1 lines
66		66
67	QString filenameCandidate = filenameFromHTTPContentDisposition(QString::fromLatin1(m_reply->rawHeader("Content-Disposition")));	67	QString filenameCandidate = filenameFromHTTPContentDisposition(QString::fromLatin1(m_reply->rawHeader("Content-Disposition")));
68	if (filenameCandidate.isEmpty()) {	68	if (filenameCandidate.isEmpty()) {
69	KURL kurl = m_reply->url();	69	URL kurl = m_reply->url();
70	filenameCandidate = decodeURLEscapeSequences(kurl.lastPathComponent());	70	filenameCandidate = decodeURLEscapeSequences(kurl.lastPathComponent());
71	}	71	}
72		72

Lines 76-82 public: a/Source/WebKit2/Shared/Downloads/soup/DownloadSoup.cpp_sec1
- a/Source/WebKit2/Shared/Downloads/soup/DownloadSoup.cpp -1 / +1 lines
76		76
77	String suggestedFilename = response.suggestedFilename();	77	String suggestedFilename = response.suggestedFilename();
78	if (suggestedFilename.isEmpty()) {	78	if (suggestedFilename.isEmpty()) {
79	KURL url = response.url();	79	URL url = response.url();
80	url.setQuery(String());	80	url.setQuery(String());
81	url.removeFragmentIdentifier();	81	url.removeFragmentIdentifier();
82	suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent());	82	suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent());

Lines 163-169 bool BlobRegistrationData::decode(CoreIPC::ArgumentDecoder& decoder, BlobRegistr a/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.cpp_sec1
- a/Source/WebKit2/Shared/FileAPI/BlobRegistrationData.cpp -1 / +1 lines
163	String url;	163	String url;
164	if (!decoder.decode(url))	164	if (!decoder.decode(url))
165	return false;	165	return false;
166	result.m_data->appendBlob(KURL(KURL(), url), offset, length);	166	result.m_data->appendBlob(URL(URL(), url), offset, length);
167	break;	167	break;
168	}	168	}
169	default:	169	default:

Lines 34-40 a/Source/WebKit2/Shared/Network/CustomProtocols/mac/CustomProtocolManagerMac.mm_sec1
- a/Source/WebKit2/Shared/Network/CustomProtocols/mac/CustomProtocolManagerMac.mm -1 / +1 lines
34	#import "DataReference.h"	34	#import "DataReference.h"
35	#import "WebCoreArgumentCoders.h"	35	#import "WebCoreArgumentCoders.h"
36	#import "WebProcessCreationParameters.h"	36	#import "WebProcessCreationParameters.h"
37	#import <WebCore/KURL.h>	37	#import <WebCore/URL.h>
38	#import <WebCore/ResourceError.h>	38	#import <WebCore/ResourceError.h>
39	#import <WebCore/ResourceRequest.h>	39	#import <WebCore/ResourceRequest.h>
40	#import <WebCore/ResourceResponse.h>	40	#import <WebCore/ResourceResponse.h>




#include "WebData.h"
#include <WebCore/ArchiveResource.h>
#include <WebCore/URL.h>
#include <wtf/RetainPtr.h>

using namespace WebCore;

}

WebArchiveResource::WebArchiveResource(WebData* data, const String& URL, const String& MIMEType, const String& textEncoding)
    : m_archiveResource(ArchiveResource::create(SharedBuffer::create(data->bytes(), data->size()), WebCore::URL(WebCore::URL(), URL), MIMEType, textEncoding, String()))
{
}




#include <WebCore/GraphicsContext.h>
#include <WebCore/GraphicsLayer.h>
#include <WebCore/Image.h>
#include <WebCore/URL.h>
#include <WebCore/PluginData.h>
#include <WebCore/ProtectionSpace.h>
#include <WebCore/ResourceError.h>

        String url;
        if (!decoder.decode(url))
            return false;
        request.setURL(URL(URL(), url));

        String httpMethod;
        if (!decoder.decode(httpMethod))

        String firstPartyForCookies;
        if (!decoder.decode(firstPartyForCookies))
            return false;
        request.setFirstPartyForCookies(URL(URL(), firstPartyForCookies));

        resourceRequest = request;
    }

        String url;
        if (!decoder.decode(url))
            return false;
        response.setURL(URL(URL(), url));

        int32_t httpStatusCode;
        if (!decoder.decode(httpStatusCode))

    return true;
}

void ArgumentCoder<URL>::encode(ArgumentEncoder& encoder, const URL& result)
{
    encoder << result.string();
}
    
bool ArgumentCoder<URL>::decode(ArgumentDecoder& decoder, URL& result)
{
    String urlAsString;
    if (!decoder.decode(urlAsString))
        return false;
    result = URL(WebCore::ParsedURLString, urlAsString);
    return true;
}


    if (!decoder.decode(source))
        return false;

    URL url;
    if (!decoder.decode(url))
        return false;


    if (!decoder.decode(source))
        return false;

    URL url;
    if (!decoder.decode(url))
        return false;




    class IntRect;
    class IntSize;
    class KeyframeValueList;
    class URL;
    class Notification;
    class ProtectionSpace;
    class ResourceError;

    static bool decode(ArgumentDecoder&, WebCore::DragSession&);
};

template<> struct ArgumentCoder<WebCore::URL> {
    static void encode(ArgumentEncoder&, const WebCore::URL&);
    static bool decode(ArgumentDecoder&, WebCore::URL&);
};

template<> struct ArgumentCoder<WebCore::UserStyleSheet> {

Lines 25-31 a/Source/WebKit2/Shared/WebHitTestResult.cpp_sec1
- a/Source/WebKit2/Shared/WebHitTestResult.cpp -1 / +1 lines
25	#include <WebCore/Frame.h>	25	#include <WebCore/Frame.h>
26	#include <WebCore/FrameView.h>	26	#include <WebCore/FrameView.h>
27	#include <WebCore/HitTestResult.h>	27	#include <WebCore/HitTestResult.h>
28	#include <WebCore/KURL.h>	28	#include <WebCore/URL.h>
29	#include <WebCore/Node.h>	29	#include <WebCore/Node.h>
30	#include <wtf/text/WTFString.h>	30	#include <wtf/text/WTFString.h>
31		31



#define WebURL_h

#include "APIObject.h"
#include <WebCore/URL.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/PassRefPtr.h>


    static PassRefPtr<WebURL> create(const WebURL* baseURL, const String& relativeURL)
    {
        using WebCore::URL;

        ASSERT(baseURL);
        baseURL->parseURLIfNecessary();
        URL* absoluteURL = new URL(*baseURL->m_parsedURL.get(), relativeURL);

        return adoptRef(new WebURL(adoptPtr(absoluteURL), absoluteURL->string()));
    }

    {
    }

    WebURL(PassOwnPtr<WebCore::URL> parsedURL, const String& string)
        : m_string(string)
        , m_parsedURL(parsedURL)
    {

    {
        if (m_parsedURL)
            return;
        m_parsedURL = WTF::adoptPtr(new WebCore::URL(WebCore::URL(), m_string));
    }

    String m_string;
    mutable OwnPtr<WebCore::URL> m_parsedURL;
};

} // namespace WebKit

Lines 16-22 using namespace WebCore; a/Source/WebKit2/Shared/WebURLRequest.cpp_sec1
- a/Source/WebKit2/Shared/WebURLRequest.cpp -1 / +1 lines
16		16
17	namespace WebKit {	17	namespace WebKit {
18		18
19	PassRefPtr<WebURLRequest> WebURLRequest::create(const KURL& url)	19	PassRefPtr<WebURLRequest> WebURLRequest::create(const URL& url)
20	{	20	{
21	return adoptRef(new WebURLRequest(ResourceRequest(url)));	21	return adoptRef(new WebURLRequest(ResourceRequest(url)));
22	}	22	}

Lines 40-46 namespace WebKit { a/Source/WebKit2/Shared/WebURLRequest.h_sec1
- a/Source/WebKit2/Shared/WebURLRequest.h -1 / +1 lines
40		40
41	class WebURLRequest : public TypedAPIObject<APIObject::TypeURLRequest> {	41	class WebURLRequest : public TypedAPIObject<APIObject::TypeURLRequest> {
42	public:	42	public:
43	static PassRefPtr<WebURLRequest> create(const WebCore::KURL&);	43	static PassRefPtr<WebURLRequest> create(const WebCore::URL&);
44		44
45	static PassRefPtr<WebURLRequest> create(const WebCore::ResourceRequest& request)	45	static PassRefPtr<WebURLRequest> create(const WebCore::ResourceRequest& request)
46	{	46	{




#include "APIObject.h"

#include <WebCore/URL.h>
#include <WebCore/UserContentURLPattern.h>
#include <wtf/RefPtr.h>


    const String& host() const { return m_pattern.host(); }
    const String& scheme() const { return m_pattern.scheme(); }
    bool isValid() const { return m_pattern.isValid(); };
    bool matchesURL(const String& url) const { return m_pattern.matches(WebCore::URL(WebCore::ParsedURLString, url)); }
    bool matchesSubdomains() const { return m_pattern.matchSubdomains(); }

    const String& patternString() const { return m_patternString; }

Lines 141-147 static bool decodeDataObject(ArgumentDecoder& decoder, RefPtr<DataObjectGtk>& da a/Source/WebKit2/Shared/gtk/ArgumentCodersGtk.cpp_sec1
- a/Source/WebKit2/Shared/gtk/ArgumentCodersGtk.cpp -1 / +1 lines
141	String url;	141	String url;
142	if (!decoder.decode(url))	142	if (!decoder.decode(url))
143	return false;	143	return false;
144	data->setURL(KURL(KURL(), url), String());	144	data->setURL(URL(URL(), url), String());
145	}	145	}
146		146
147	bool hasURIList;	147	bool hasURIList;



#include "NetworkProcessConnection.h"
#include "WebCoreArgumentCoders.h"
#include "WebProcess.h"
#include <WebCore/URL.h>
#include <dlfcn.h>
#include <wtf/MainThread.h>
#include <wtf/RetainPtr.h>

static CFDictionaryRef webKitCookieStorageCopyRequestHeaderFieldsForURL(CFHTTPCookieStorageRef inCookieStorage, CFURLRef inRequestURL)
{
    String cookies;
    URL firstPartyForCookiesURL;
    if (!WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue(false, firstPartyForCookiesURL, inRequestURL), Messages::NetworkConnectionToWebProcess::CookiesForDOM::Reply(cookies), 0))
        return 0;


Lines 27-33 a/Source/WebKit2/Shared/qt/QtNetworkReplyData.cpp_sec1
- a/Source/WebKit2/Shared/qt/QtNetworkReplyData.cpp -1 / +1 lines
27	#include "QtNetworkReplyData.h"	27	#include "QtNetworkReplyData.h"
28		28
29	#include "ArgumentCodersQt.h"	29	#include "ArgumentCodersQt.h"
30	#include "KURL.h"	30	#include "URL.h"
31	#include "SharedMemory.h"	31	#include "SharedMemory.h"
32	#include "WebCoreArgumentCoders.h"	32	#include "WebCoreArgumentCoders.h"
33	#include <QNetworkAccessManager>	33	#include <QNetworkAccessManager>

Lines 139-145 void webkit_uri_request_set_uri(WebKitURIRequest* request, const char* uri) a/Source/WebKit2/UIProcess/API/gtk/WebKitURIRequest.cpp_sec1
- a/Source/WebKit2/UIProcess/API/gtk/WebKitURIRequest.cpp -1 / +1 lines
139	g_return_if_fail(WEBKIT_IS_URI_REQUEST(request));	139	g_return_if_fail(WEBKIT_IS_URI_REQUEST(request));
140	g_return_if_fail(uri);	140	g_return_if_fail(uri);
141		141
142	KURL url(KURL(), uri);	142	URL url(URL(), uri);
143	if (url == request->priv->resourceRequest.url())	143	if (url == request->priv->resourceRequest.url())
144	return;	144	return;
145		145

Lines 588-594 void QQuickWebViewPrivate::processDidCrash() a/Source/WebKit2/UIProcess/API/qt/qquickwebview.cpp_sec1
- a/Source/WebKit2/UIProcess/API/qt/qquickwebview.cpp -1 / +1 lines
588	{	588	{
589	Q_Q(QQuickWebView);	589	Q_Q(QQuickWebView);
590		590
591	QUrl url(KURL(WebCore::ParsedURLString, webPageProxy->urlAtProcessExit()));	591	QUrl url(URL(WebCore::ParsedURLString, webPageProxy->urlAtProcessExit()));
592	qWarning("WARNING: The web process experienced a crash on '%s'.", qPrintable(url.toString(QUrl::RemoveUserInfo)));	592	qWarning("WARNING: The web process experienced a crash on '%s'.", qPrintable(url.toString(QUrl::RemoveUserInfo)));
593		593
594	pageEventHandler->resetGestureRecognizers();	594	pageEventHandler->resetGestureRecognizers();



{
    String url;
    size_t result = parseHTTPRequestLine(data, length, failureReason, m_requestMethod, url, m_httpVersion);
    m_url = URL(URL(), url);
    return result;
}


{
}

HTTPRequest::HTTPRequest(const String& requestMethod, const URL& url, HTTPVersion version)
    : m_url(url)
    , m_httpVersion(version)
    , m_requestMethod(requestMethod)




#include <WebCore/HTTPHeaderMap.h>
#include <WebCore/HTTPParsers.h>
#include <WebCore/URL.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/text/WTFString.h>

class HTTPRequest : public RefCounted<HTTPRequest> {
public:
    static PassRefPtr<HTTPRequest> create() { return adoptRef(new HTTPRequest()); }
    static PassRefPtr<HTTPRequest> create(const String& requestMethod, const WebCore::URL& url, WebCore::HTTPVersion version) { return adoptRef(new HTTPRequest(requestMethod, url, version)); }
    static PassRefPtr<HTTPRequest> parseHTTPRequestFromBuffer(const char* data, size_t length, String& failureReason);
    virtual ~HTTPRequest();

    String requestMethod() const { return m_requestMethod; }
    void setRequestMethod(const String& method) { m_requestMethod = method; }

    WebCore::URL url() const { return m_url; }
    void setURL(const WebCore::URL& url) { m_url = url; }

    const Vector<unsigned char>& body() const { return m_body; }



protected:
    HTTPRequest();
    HTTPRequest(const String& requestMethod, const WebCore::URL&, WebCore::HTTPVersion);

    // Parsing helpers.
    size_t parseRequestLine(const char* data, size_t length, String& failureReason);
    size_t parseHeaders(const char* data, size_t length, String& failureReason);
    size_t parseRequestBody(const char* data, size_t length);

    WebCore::URL m_url;
    WebCore::HTTPVersion m_httpVersion;
    String m_requestMethod;
    WebCore::HTTPHeaderMap m_headerFields;

Lines 111-117 void WebInspectorServer::sendMessageOverConnection(unsigned pageIdForConnection, a/Source/WebKit2/UIProcess/InspectorServer/WebInspectorServer.cpp_sec1
- a/Source/WebKit2/UIProcess/InspectorServer/WebInspectorServer.cpp -1 / +1 lines
111	void WebInspectorServer::didReceiveUnrecognizedHTTPRequest(WebSocketServerConnection* connection, PassRefPtr<HTTPRequest> request)	111	void WebInspectorServer::didReceiveUnrecognizedHTTPRequest(WebSocketServerConnection* connection, PassRefPtr<HTTPRequest> request)
112	{	112	{
113	// request->url() contains only the path extracted from the HTTP request line	113	// request->url() contains only the path extracted from the HTTP request line
114	// and KURL is poor at parsing incomplete URLs, so extract the interesting parts manually.	114	// and URL is poor at parsing incomplete URLs, so extract the interesting parts manually.
115	String path = request->url();	115	String path = request->url();
116	size_t pathEnd = path.find('?');	116	size_t pathEnd = path.find('?');
117	if (pathEnd == notFound)	117	if (pathEnd == notFound)



#if ENABLE(NETSCAPE_PLUGIN_API)

#include "PluginModuleInfo.h"
#include <WebCore/URL.h>
#include <WebCore/MIMETypeRegistry.h>
#include <algorithm>
#include <wtf/ListHashSet.h>

    return PluginModuleInfo();
}

static inline String pathExtension(const URL& url)
{
    String extension;
    String filename = url.lastPathComponent();


#endif

PluginModuleInfo PluginInfoStore::findPlugin(String& mimeType, const URL& url, PluginData::AllowedPluginTypes allowedPluginTypes)
{
    loadPluginsIfNecessary();
    



#include <WebCore/PluginData.h>

namespace WebCore {
    class URL;
}

namespace WebKit {

    // Returns the info for a plug-in that can handle the given MIME type.
    // If the MIME type is null, the file extension of the given url will be used to infer the
    // plug-in type. In that case, mimeType will be filled in with the right MIME type.
    PluginModuleInfo findPlugin(String& mimeType, const WebCore::URL&, WebCore::PluginData::AllowedPluginTypes = WebCore::PluginData::AllPlugins);

    // Returns the info for the plug-in with the given bundle identifier.
    PluginModuleInfo findPluginWithBundleIdentifier(const String& bundleIdentifier);



#import "PluginProcessMessages.h"
#import "WebKitSystemInterface.h"
#import <WebCore/FileSystem.h>
#import <WebCore/URL.h>
#import <WebCore/RuntimeApplicationChecks.h>
#import <crt_externs.h>
#import <mach-o/dyld.h>


    result = true;
    CFURLRef launchedURL;
    status = LSOpenCFURLRef(URL(ParsedURLString, urlString).createCFURL().get(), &launchedURL);

    if (launchedURL) {
        launchedURLString = URL(launchedURL).string();
        CFRelease(launchedURL);
    }
}




static bool isMainInspectorPage(const WebInspectorProxy* webInspectorProxy, WKURLRequestRef requestRef)
{
    // Use URL so we can compare just the paths.
    URL inspectorURL(URL(), webInspectorProxy->inspectorPageURL());
    URL requestURL(URL(), toImpl(requestRef)->url());

    ASSERT(WebCore::SchemeRegistry::shouldTreatURLSchemeAsLocal(inspectorURL.protocol()));





#include "ImmutableArray.h"
#include "WebPageProxy.h"
#include <WebCore/URL.h>
#include <wtf/Vector.h>

using namespace WebCore;

    for (size_t i = 0; i < size; ++i) {
        WebURL* webURL = fileURLsArray->at<WebURL>(i);
        if (webURL) {
            URL url(URL(), webURL->string()); 
            filePaths.uncheckedAppend(url.fileSystemPath());
        }
    }



    if (source.isEmpty())
        return;

    WebCore::UserStyleSheet userStyleSheet = WebCore::UserStyleSheet(source, (baseURL.isEmpty() ? WebCore::blankURL() : WebCore::URL(WebCore::URL(), baseURL)), toStringVector(whitelist), toStringVector(blacklist), injectedFrames, level);

    m_data.userStyleSheets.append(userStyleSheet);
    sendToAllProcessesInGroup(Messages::WebPageGroupProxy::AddUserStyleSheet(userStyleSheet), m_data.pageGroupID);

    if (source.isEmpty())
        return;

    WebCore::UserScript userScript = WebCore::UserScript(source, (baseURL.isEmpty() ? WebCore::blankURL() : WebCore::URL(WebCore::URL(), baseURL)), toStringVector(whitelist), toStringVector(blacklist), injectionTime, injectedFrames);

    m_data.userScripts.append(userScript);
    sendToAllProcessesInGroup(Messages::WebPageGroupProxy::AddUserScript(userScript), m_data.pageGroupID);



    return false;
}

bool WebPageProxy::maybeInitializeSandboxExtensionHandle(const URL& url, SandboxExtension::Handle& sandboxExtensionHandle)
{
    if (!url.isLocalFile())
        return false;

        reattachToWebProcess();

    SandboxExtension::Handle sandboxExtensionHandle;
    bool createdExtension = maybeInitializeSandboxExtensionHandle(URL(URL(), url), sandboxExtensionHandle);
    if (createdExtension)
        m_process->willAcquireUniversalFileReadSandboxExtension();
    m_process->send(Messages::WebPage::LoadURL(url, sandboxExtensionHandle, WebContextUserMessageEncoder(userData)), m_pageID);

    if (!isValid())
        reattachToWebProcess();

    URL fileURL = URL(URL(), fileURLString);
    if (!fileURL.isLocalFile())
        return;

    URL resourceDirectoryURL;
    if (resourceDirectoryURLString.isNull())
        resourceDirectoryURL = URL(ParsedURLString, ASCIILiteral("file:///"));
    else {
        resourceDirectoryURL = URL(URL(), resourceDirectoryURLString);
        if (!resourceDirectoryURL.isLocalFile())
            return;
    }

        setPendingAPIRequestURL(url);

        // We may not have an extension yet if back/forward list was reinstated after a WebProcess crash or a browser relaunch
        bool createdExtension = maybeInitializeSandboxExtensionHandle(URL(URL(), url), sandboxExtensionHandle);
        if (createdExtension)
            m_process->willAcquireUniversalFileReadSandboxExtension();
    }


#if ENABLE(NETSCAPE_PLUGIN_API)
    String newMimeType = mimeType;
    PluginModuleInfo plugin = m_process->context()->pluginInfoStore().findPlugin(newMimeType, URL());
    if (!plugin.path.isNull() && m_pageGroup->preferences()->pluginsEnabled())
        return true;
#endif // ENABLE(NETSCAPE_PLUGIN_API)

    pluginLoadPolicy = PluginModuleLoadNormally;

    PluginData::AllowedPluginTypes allowedPluginTypes = allowOnlyApplicationPlugins ? PluginData::OnlyApplicationPlugins : PluginData::AllPlugins;
    PluginModuleInfo plugin = m_process->context()->pluginInfoStore().findPlugin(newMimeType, URL(URL(), urlString), allowedPluginTypes);
    if (!plugin.path) {
        pluginProcessToken = 0;
        return;

    RefPtr<ImmutableDictionary> pluginInformation;
#if ENABLE(NETSCAPE_PLUGIN_API)
    String newMimeType = mimeType;
    PluginModuleInfo plugin = m_process->context()->pluginInfoStore().findPlugin(newMimeType, URL(URL(), pluginURLString));
    pluginInformation = createPluginInformationDictionary(plugin, frameURLString, mimeType, pageURLString, pluginspageAttributeURLString, pluginURLString);
#endif


    if (!item)
        return;

    bool createdExtension = maybeInitializeSandboxExtensionHandle(URL(URL(), item->url()), sandboxExtensionHandle);
    if (createdExtension)
        m_process->willAcquireUniversalFileReadSandboxExtension();
    m_backForwardList->goToItem(item);

    }
#endif
    if (item.action() == ContextMenuItemTagDownloadImageToDisk) {
        m_process->context()->download(this, URL(URL(), m_activeContextMenuHitTestResultData.absoluteImageURL));
        return;    
    }
    if (item.action() == ContextMenuItemTagDownloadLinkToDisk) {
        m_process->context()->download(this, URL(URL(), m_activeContextMenuHitTestResultData.absoluteLinkURL));
        return;
    }
    if (item.action() == ContextMenuItemTagDownloadMediaToDisk) {
        m_process->context()->download(this, URL(URL(), m_activeContextMenuHitTestResultData.absoluteMediaURL));
        return;
    }
    if (item.action() == ContextMenuItemTagCheckSpellingWhileTyping) {


#if PLATFORM(MAC) && ENABLE(NETSCAPE_PLUGIN_API)
    String newMimeType = mimeType;
    PluginModuleInfo plugin = m_process->context()->pluginInfoStore().findPlugin(newMimeType, URL(URL(), pluginURLString));
    pluginInformation = createPluginInformationDictionary(plugin, frameURLString, mimeType, pageURLString, String(), String(), replacementObscured);
#else
    UNUSED_PARAM(mimeType);

Lines 1014-1020 private: a/Source/WebKit2/UIProcess/WebPageProxy.h_sec1
- a/Source/WebKit2/UIProcess/WebPageProxy.h -1 / +1 lines
1014	void clearPendingAPIRequestURL() { m_pendingAPIRequestURL = String(); }	1014	void clearPendingAPIRequestURL() { m_pendingAPIRequestURL = String(); }
1015	void setPendingAPIRequestURL(const String& pendingAPIRequestURL) { m_pendingAPIRequestURL = pendingAPIRequestURL; }	1015	void setPendingAPIRequestURL(const String& pendingAPIRequestURL) { m_pendingAPIRequestURL = pendingAPIRequestURL; }
1016		1016
1017	bool maybeInitializeSandboxExtensionHandle(const WebCore::KURL&, SandboxExtension::Handle&);	1017	bool maybeInitializeSandboxExtensionHandle(const WebCore::URL&, SandboxExtension::Handle&);
1018		1018
1019	#if PLATFORM(MAC)	1019	#if PLATFORM(MAC)
1020	void substitutionsPanelIsShowing(bool&);	1020	void substitutionsPanelIsShowing(bool&);



#include "WebPluginSiteDataManager.h"
#include "WebProcessMessages.h"
#include "WebProcessProxyMessages.h"
#include <WebCore/URL.h>
#include <WebCore/RunLoop.h>
#include <WebCore/SuddenTermination.h>
#include <stdio.h>


void WebProcessProxy::assumeReadAccessToBaseURL(const String& urlString)
{
    URL url(URL(), urlString);
    if (!url.isLocalFile())
        return;

    // There's a chance that urlString does not point to a directory.
    // Get url's base URL to add to m_localPathsWithAssumedReadAccess.
    URL baseURL(URL(), url.baseAsString());
    
    // Client loads an alternate string. This doesn't grant universal file read, but the web process is assumed
    // to have read access to this directory already.


bool WebProcessProxy::checkURLReceivedFromWebProcess(const String& urlString)
{
    return checkURLReceivedFromWebProcess(URL(URL(), urlString));
}

bool WebProcessProxy::checkURLReceivedFromWebProcess(const URL& url)
{
    // FIXME: Consider checking that the URL is valid. Currently, WebProcess sends invalid URLs in many cases, but it probably doesn't have good reasons to do that.


        return true;

    // If we loaded a string with a file base URL before, loading resources from that subdirectory is fine.
    // There are no ".." components, because all URLs received from WebProcess are parsed with URL, which removes those.
    String path = url.fileSystemPath();
    for (HashSet<String>::const_iterator iter = m_localPathsWithAssumedReadAccess.begin(); iter != m_localPathsWithAssumedReadAccess.end(); ++iter) {
        if (path.startsWith(*iter))

    // Items in back/forward list have been already checked.
    // One case where we don't have sandbox extensions for file URLs in b/f list is if the list has been reinstated after a crash or a browser restart.
    for (WebBackForwardListItemMap::iterator iter = m_backForwardListItemMap.begin(), end = m_backForwardListItemMap.end(); iter != end; ++iter) {
        if (URL(URL(), iter->value->url()).fileSystemPath() == path)
            return true;
        if (URL(URL(), iter->value->originalURL()).fileSystemPath() == path)
            return true;
    }




#endif

namespace WebCore {
class URL;
struct PluginInfo;
};


    void assumeReadAccessToBaseURL(const String&);

    bool checkURLReceivedFromWebProcess(const String&);
    bool checkURLReceivedFromWebProcess(const WebCore::URL&);

    static bool fullKeyboardAccessEnabled();


Lines 600-606 static CFURLStorageSessionRef privateBrowsingSession() a/Source/WebKit2/UIProcess/mac/WebContextMac.mm_sec1
- a/Source/WebKit2/UIProcess/mac/WebContextMac.mm -1 / +1 lines
600	bool WebContext::isURLKnownHSTSHost(const String& urlString, bool privateBrowsingEnabled) const	600	bool WebContext::isURLKnownHSTSHost(const String& urlString, bool privateBrowsingEnabled) const
601	{	601	{
602	#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090	602	#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
603	RetainPtr<CFURLRef> url = KURL(KURL(), urlString).createCFURL();	603	RetainPtr<CFURLRef> url = URL(URL(), urlString).createCFURL();
604		604
605	return _CFNetworkIsKnownHSTSHostWithSession(url.get(), privateBrowsingEnabled ? privateBrowsingSession() : nullptr);	605	return _CFNetworkIsKnownHSTSHostWithSession(url.get(), privateBrowsingEnabled ? privateBrowsingSession() : nullptr);
606	#else	606	#else




namespace WebKit {

void BlobRegistryProxy::registerBlobURL(const URL& url, PassOwnPtr<BlobData> blobData)
{
    ASSERT(WebProcess::shared().usesNetworkProcess());

    WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::RegisterBlobURL(url, BlobRegistrationData(blobData)), 0);
}

void BlobRegistryProxy::registerBlobURL(const URL& url, const URL& srcURL)
{
    ASSERT(WebProcess::shared().usesNetworkProcess());

    WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::RegisterBlobURLFromURL(url, srcURL), 0);
}

void BlobRegistryProxy::unregisterBlobURL(const URL& url)
{
    ASSERT(WebProcess::shared().usesNetworkProcess());





class BlobRegistryProxy : public WebCore::BlobRegistry {
public:
    virtual void registerBlobURL(const WebCore::URL&, PassOwnPtr<WebCore::BlobData>);
    virtual void registerBlobURL(const WebCore::URL&, const WebCore::URL& srcURL);
    virtual void unregisterBlobURL(const WebCore::URL&);
};

}




bool WKBundleFrameAllowsFollowingLink(WKBundleFrameRef frameRef, WKURLRef urlRef)
{
    return toImpl(frameRef)->allowsFollowingLink(WebCore::URL(WebCore::URL(), toWTFString(urlRef)));
}

bool WKBundleFrameHandlesPageScaleGesture(WKBundleFrameRef frameRef)


WKStringRef WKBundleFrameCopySuggestedFilenameForResourceWithURL(WKBundleFrameRef frameRef, WKURLRef urlRef)
{
    return toCopiedAPI(toImpl(frameRef)->suggestedFilenameForResourceWithURL(WebCore::URL(WebCore::URL(), toWTFString(urlRef))));
}

WKStringRef WKBundleFrameCopyMIMETypeForResourceWithURL(WKBundleFrameRef frameRef, WKURLRef urlRef)
{
    return toCopiedAPI(toImpl(frameRef)->mimeTypeForResourceWithURL(WebCore::URL(WebCore::URL(), toWTFString(urlRef))));
}

bool WKBundleFrameContainsAnyFormElements(WKBundleFrameRef frameRef)



#include <WebCore/AXObjectCache.h>
#include <WebCore/AccessibilityObject.h>
#include <WebCore/Frame.h>
#include <WebCore/URL.h>
#include <WebCore/Page.h>
#include <wtf/StdLibExtras.h>



bool WKBundlePageHasLocalDataForURL(WKBundlePageRef pageRef, WKURLRef urlRef)
{
    return toImpl(pageRef)->hasLocalDataForURL(WebCore::URL(WebCore::URL(), toWTFString(urlRef)));
}

bool WKBundlePageCanHandleRequest(WKURLRequestRef requestRef)




void InjectedBundle::addUserScript(WebPageGroupProxy* pageGroup, InjectedBundleScriptWorld* scriptWorld, const String& source, const String& url, ImmutableArray* whitelist, ImmutableArray* blacklist, WebCore::UserScriptInjectionTime injectionTime, WebCore::UserContentInjectedFrames injectedFrames)
{
    // url is not from URL::string(), i.e. it has not already been parsed by URL, so we have to use the relative URL constructor for URL instead of the ParsedURLStringTag version.
    PageGroup::pageGroup(pageGroup->identifier())->addUserScriptToWorld(scriptWorld->coreWorld(), source, URL(URL(), url), toStringVector(whitelist), toStringVector(blacklist), injectionTime, injectedFrames);
}

void InjectedBundle::addUserStyleSheet(WebPageGroupProxy* pageGroup, InjectedBundleScriptWorld* scriptWorld, const String& source, const String& url, ImmutableArray* whitelist, ImmutableArray* blacklist, WebCore::UserContentInjectedFrames injectedFrames)
{
    // url is not from URL::string(), i.e. it has not already been parsed by URL, so we have to use the relative URL constructor for URL instead of the ParsedURLStringTag version.
    PageGroup::pageGroup(pageGroup->identifier())->addUserStyleSheetToWorld(scriptWorld->coreWorld(), source, URL(URL(), url), toStringVector(whitelist), toStringVector(blacklist), injectedFrames);
}

void InjectedBundle::removeUserScript(WebPageGroupProxy* pageGroup, InjectedBundleScriptWorld* scriptWorld, const String& url)
{
    // url is not from URL::string(), i.e. it has not already been parsed by URL, so we have to use the relative URL constructor for URL instead of the ParsedURLStringTag version.
    PageGroup::pageGroup(pageGroup->identifier())->removeUserScriptFromWorld(scriptWorld->coreWorld(), URL(URL(), url));
}

void InjectedBundle::removeUserStyleSheet(WebPageGroupProxy* pageGroup, InjectedBundleScriptWorld* scriptWorld, const String& url)
{
    // url is not from URL::string(), i.e. it has not already been parsed by URL, so we have to use the relative URL constructor for URL instead of the ParsedURLStringTag version.
    PageGroup::pageGroup(pageGroup->identifier())->removeUserStyleSheetFromWorld(scriptWorld->coreWorld(), URL(URL(), url));
}

void InjectedBundle::removeUserScripts(WebPageGroupProxy* pageGroup, InjectedBundleScriptWorld* scriptWorld)

{
    const HashSet<Page*>& pages = PageGroup::pageGroup(pageGroup->identifier())->pages();
    for (HashSet<Page*>::iterator iter = pages.begin(); iter != pages.end(); ++iter)
        (*iter)->settings().setUserStyleSheetLocation(URL(URL(), location));
}

void InjectedBundle::setWebNotificationPermission(WebPage* page, const String& originString, bool allowed)

Lines 34-40 a/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundleHitTestResult.cpp_sec1
- a/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundleHitTestResult.cpp -1 / +1 lines
34	#include <WebCore/Frame.h>	34	#include <WebCore/Frame.h>
35	#include <WebCore/FrameLoader.h>	35	#include <WebCore/FrameLoader.h>
36	#include <WebCore/FrameView.h>	36	#include <WebCore/FrameView.h>
37	#include <WebCore/KURL.h>	37	#include <WebCore/URL.h>
38	#include <wtf/text/WTFString.h>	38	#include <wtf/text/WTFString.h>
39		39
40	using namespace WebCore;	40	using namespace WebCore;

Lines 55-61 static void releaseSharedBuffer(unsigned char, const void data) a/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp_sec1
- a/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp -1 / +1 lines
55	static_cast<SharedBuffer>(const_cast<void>(data))->deref();	55	static_cast<SharedBuffer>(const_cast<void>(data))->deref();
56	}	56	}
57		57
58	void InjectedBundlePageLoaderClient::willLoadDataRequest(WebPage* page, const ResourceRequest& request, const SharedBuffer* data, const String& MIMEType, const String& encodingName, const KURL& unreachableURL, APIObject* userData)	58	void InjectedBundlePageLoaderClient::willLoadDataRequest(WebPage* page, const ResourceRequest& request, const SharedBuffer* data, const String& MIMEType, const String& encodingName, const URL& unreachableURL, APIObject* userData)
59	{	59	{
60	if (!m_client.willLoadDataRequest)	60	if (!m_client.willLoadDataRequest)
61	return;	61	return;



namespace WebCore {
class DOMWindowExtension;
class DOMWrapperWorld;
class URL;
class ResourceError;
class ResourceRequest;
class ResourceResponse;

class InjectedBundlePageLoaderClient : public APIClient<WKBundlePageLoaderClient, kWKBundlePageLoaderClientCurrentVersion> {
public:
    void willLoadURLRequest(WebPage*, const WebCore::ResourceRequest&, APIObject*);
    void willLoadDataRequest(WebPage*, const WebCore::ResourceRequest&, const WebCore::SharedBuffer*, const String&, const String&, const WebCore::URL&, APIObject*);

    bool shouldGoToBackForwardListItem(WebPage*, InjectedBundleBackForwardListItem*, RefPtr<APIObject>& userData);
    void didStartProvisionalLoadForFrame(WebPage*, WebFrame*, RefPtr<APIObject>& userData);

Lines 185-191 void WebResourceLoadScheduler::remove(ResourceLoader* resourceLoader) a/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.cpp_sec1
- a/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.cpp -1 / +1 lines
185	loader->detachFromCoreLoader();	185	loader->detachFromCoreLoader();
186	}	186	}
187		187
188	void WebResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader*, const KURL&)	188	void WebResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader*, const URL&)
189	{	189	{
190	// We handle cross origin redirects entirely within the NetworkProcess.	190	// We handle cross origin redirects entirely within the NetworkProcess.
191	// We override this call in the WebProcess to make it a no-op.	191	// We override this call in the WebProcess to make it a no-op.

Lines 49-55 public: a/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.h_sec1
- a/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.h -1 / +1 lines
49	virtual PassRefPtr<WebCore::NetscapePlugInStreamLoader> schedulePluginStreamLoad(WebCore::Frame, WebCore::NetscapePlugInStreamLoaderClient, const WebCore::ResourceRequest&) OVERRIDE;	49	virtual PassRefPtr<WebCore::NetscapePlugInStreamLoader> schedulePluginStreamLoad(WebCore::Frame, WebCore::NetscapePlugInStreamLoaderClient, const WebCore::ResourceRequest&) OVERRIDE;
50		50
51	virtual void remove(WebCore::ResourceLoader*) OVERRIDE;	51	virtual void remove(WebCore::ResourceLoader*) OVERRIDE;
52	virtual void crossOriginRedirectReceived(WebCore::ResourceLoader*, const WebCore::KURL& redirectURL) OVERRIDE;	52	virtual void crossOriginRedirectReceived(WebCore::ResourceLoader*, const WebCore::URL& redirectURL) OVERRIDE;
53		53
54	virtual void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority = WebCore::ResourceLoadPriorityVeryLow) OVERRIDE;	54	virtual void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority = WebCore::ResourceLoadPriorityVeryLow) OVERRIDE;
55		55



#include <WebCore/GraphicsContext.h>
#include <WebCore/HTTPHeaderMap.h>
#include <WebCore/IntRect.h>
#include <WebCore/URL.h>
#include <WebCore/SharedBuffer.h>
#include <runtime/JSObject.h>
#include <utility>

        pluginStream->sendJavaScriptStream(result);
}

void NetscapePlugin::streamDidReceiveResponse(uint64_t streamID, const URL& responseURL, uint32_t streamLength, 
                                              uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& /* suggestedFileName */)
{
    ASSERT(m_isStarted);

        pluginStream->didFail(wasCancelled);
}

void NetscapePlugin::manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, 
                                                    const String& mimeType, const String& headers, const String& /* suggestedFileName */)
{
    ASSERT(m_isStarted);



    virtual void frameDidFinishLoading(uint64_t requestID);
    virtual void frameDidFail(uint64_t requestID, bool wasCancelled);
    virtual void didEvaluateJavaScript(uint64_t requestID, const String& result);
    virtual void streamDidReceiveResponse(uint64_t streamID, const WebCore::URL& responseURL, uint32_t streamLength, 
                                          uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName);
    virtual void streamDidReceiveData(uint64_t streamID, const char* bytes, int length);
    virtual void streamDidFinishLoading(uint64_t streamID);
    virtual void streamDidFail(uint64_t streamID, bool wasCancelled);
    virtual void manualStreamDidReceiveResponse(const WebCore::URL& responseURL, uint32_t streamLength, 
                                                uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName);
    virtual void manualStreamDidReceiveData(const char* bytes, int length);
    virtual void manualStreamDidFinishLoading();

Lines 63-69 NetscapePluginStream::~NetscapePluginStream() a/Source/WebKit2/WebProcess/Plugins/Netscape/NetscapePluginStream.cpp_sec1
- a/Source/WebKit2/WebProcess/Plugins/Netscape/NetscapePluginStream.cpp -1 / +1 lines
63	ASSERT(m_fileHandle == invalidPlatformFileHandle);	63	ASSERT(m_fileHandle == invalidPlatformFileHandle);
64	}	64	}
65		65
66	void NetscapePluginStream::didReceiveResponse(const KURL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers)	66	void NetscapePluginStream::didReceiveResponse(const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers)
67	{	67	{
68	// Starting the stream could cause the plug-in stream to go away so we keep a reference to it here.	68	// Starting the stream could cause the plug-in stream to go away so we keep a reference to it here.
69	Ref<NetscapePluginStream> protect(*this);	69	Ref<NetscapePluginStream> protect(*this);



#include <wtf/text/CString.h>

namespace WebCore {
class URL;
}

namespace WebKit {

    uint64_t streamID() const { return m_streamID; }
    const NPStream* npStream() const { return &m_npStream; }

    void didReceiveResponse(const WebCore::URL& responseURL, uint32_t streamLength,
                            uint32_t lastModifiedTime, const String& mimeType, const String& headers);
    void didReceiveData(const char* bytes, int length);
    void didFinishLoading();



    virtual void frameDidFinishLoading(uint64_t requestID) OVERRIDE;
    virtual void frameDidFail(uint64_t requestID, bool wasCancelled) OVERRIDE;
    virtual void didEvaluateJavaScript(uint64_t requestID, const String& result) OVERRIDE;
    virtual void streamDidReceiveResponse(uint64_t streamID, const WebCore::URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) OVERRIDE;
    virtual void streamDidReceiveData(uint64_t streamID, const char* bytes, int length) OVERRIDE;
    virtual void streamDidFinishLoading(uint64_t streamID) OVERRIDE;
    virtual void streamDidFail(uint64_t streamID, bool wasCancelled) OVERRIDE;
    virtual void manualStreamDidReceiveResponse(const WebCore::URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& suggestedFileName) OVERRIDE;
    virtual void manualStreamDidReceiveData(const char* bytes, int length) OVERRIDE;
    virtual void manualStreamDidFinishLoading() OVERRIDE;
    virtual void manualStreamDidFail(bool wasCancelled) OVERRIDE;


    WebCore::IntSize m_size;

    WebCore::URL m_sourceURL;

    String m_suggestedFilename;
    RetainPtr<CFMutableDataRef> m_data;



        createPasswordEntryForm();
}

void PDFPlugin::streamDidReceiveResponse(uint64_t streamID, const URL&, uint32_t, uint32_t, const String& mimeType, const String&, const String& suggestedFilename)
{
    ASSERT_UNUSED(streamID, streamID == pdfDocumentRequestID);


    m_data.clear();
}

void PDFPlugin::manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength,  uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFilename)
{
    m_suggestedFilename = suggestedFilename;




    virtual void frameDidFinishLoading(uint64_t requestID);
    virtual void frameDidFail(uint64_t requestID, bool wasCancelled);
    virtual void didEvaluateJavaScript(uint64_t requestID, const String& result);
    virtual void streamDidReceiveResponse(uint64_t streamID, const WebCore::URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName);
    virtual void streamDidReceiveData(uint64_t streamID, const char* bytes, int length);
    virtual void streamDidFinishLoading(uint64_t streamID);
    virtual void streamDidFail(uint64_t streamID, bool wasCancelled);
    virtual void manualStreamDidReceiveResponse(const WebCore::URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& suggestedFileName);
    virtual void manualStreamDidReceiveData(const char* bytes, int length);
    virtual void manualStreamDidFinishLoading();
    virtual void manualStreamDidFail(bool wasCancelled);


    WebCore::IntSize m_size;

    WebCore::URL m_sourceURL;

    String m_suggestedFilename;
    RetainPtr<CFMutableDataRef> m_data;



    m_data = convertPostScriptDataToPDF(m_data);
}

void SimplePDFPlugin::streamDidReceiveResponse(uint64_t streamID, const URL&, uint32_t, uint32_t, const String& mimeType, const String&, const String& suggestedFilename)
{
    ASSERT_UNUSED(streamID, streamID == pdfDocumentRequestID);


    m_data.clear();
}

void SimplePDFPlugin::manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength,  uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFilename)
{
    m_suggestedFilename = suggestedFilename;


Lines 52-58 bool Plugin::Parameters::decode(CoreIPC::ArgumentDecoder& decoder, Parameters& p a/Source/WebKit2/WebProcess/Plugins/Plugin.cpp_sec1
- a/Source/WebKit2/WebProcess/Plugins/Plugin.cpp -1 / +1 lines
52	if (!decoder.decode(urlString))	52	if (!decoder.decode(urlString))
53	return false;	53	return false;
54	// FIXME: We can't assume that the url passed in here is valid.	54	// FIXME: We can't assume that the url passed in here is valid.
55	parameters.url = KURL(ParsedURLString, urlString);	55	parameters.url = URL(ParsedURLString, urlString);
56		56
57	if (!decoder.decode(parameters.names))	57	if (!decoder.decode(parameters.names))
58	return false;	58	return false;




#include <WebCore/FindOptions.h>
#include <WebCore/GraphicsLayer.h>
#include <WebCore/URL.h>
#include <WebCore/ScrollTypes.h>
#include <WebCore/SecurityOrigin.h>
#include <wtf/RefCounted.h>

class Plugin : public ThreadSafeRefCounted<Plugin> {
public:
    struct Parameters {
        WebCore::URL url;
        Vector<String> names;
        Vector<String> values;
        String mimeType;

    virtual void didEvaluateJavaScript(uint64_t requestID, const String& result) = 0;

    // Tells the plug-in that a stream has received its HTTP response.
    virtual void streamDidReceiveResponse(uint64_t streamID, const WebCore::URL& responseURL, uint32_t streamLength, 
                                          uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) = 0;

    // Tells the plug-in that a stream did receive data.

    virtual void streamDidFail(uint64_t streamID, bool wasCancelled) = 0;

    // Tells the plug-in that the manual stream has received its HTTP response.
    virtual void manualStreamDidReceiveResponse(const WebCore::URL& responseURL, uint32_t streamLength, 
                                                uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) = 0;

    // Tells the plug-in that the manual stream did receive data.

Lines 39-45 typedef void* NPIdentifier; a/Source/WebKit2/WebProcess/Plugins/PluginController.h_sec1
- a/Source/WebKit2/WebProcess/Plugins/PluginController.h -1 / +1 lines
39	namespace WebCore {	39	namespace WebCore {
40	class HTTPHeaderMap;	40	class HTTPHeaderMap;
41	class IntRect;	41	class IntRect;
42	class KURL;	42	class URL;
43	class ProtectionSpace;	43	class ProtectionSpace;
44	}	44	}
45		45



    m_connection->connection()->send(Messages::PluginControllerProxy::DidEvaluateJavaScript(requestID, result), m_pluginInstanceID);
}

void PluginProxy::streamDidReceiveResponse(uint64_t streamID, const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& /* suggestedFileName */)
{
    m_connection->connection()->send(Messages::PluginControllerProxy::StreamDidReceiveResponse(streamID, responseURL.string(), streamLength, lastModifiedTime, mimeType, headers), m_pluginInstanceID);
}

    m_connection->connection()->send(Messages::PluginControllerProxy::StreamDidFail(streamID, wasCancelled), m_pluginInstanceID);
}

void PluginProxy::manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength,  uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& /* suggestedFileName */)
{
    m_connection->connection()->send(Messages::PluginControllerProxy::ManualStreamDidReceiveResponse(responseURL.string(), streamLength, lastModifiedTime, mimeType, headers), m_pluginInstanceID);
}



    virtual void frameDidFinishLoading(uint64_t requestID);
    virtual void frameDidFail(uint64_t requestID, bool wasCancelled);
    virtual void didEvaluateJavaScript(uint64_t requestID, const String& result);
    virtual void streamDidReceiveResponse(uint64_t streamID, const WebCore::URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName);
    virtual void streamDidReceiveData(uint64_t streamID, const char* bytes, int length);
    virtual void streamDidFinishLoading(uint64_t streamID);
    virtual void streamDidFail(uint64_t streamID, bool wasCancelled);
    virtual void manualStreamDidReceiveResponse(const WebCore::URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& suggestedFileName);
    virtual void manualStreamDidReceiveData(const char* bytes, int length);
    virtual void manualStreamDidFinishLoading();
    virtual void manualStreamDidFail(bool wasCancelled);



void PluginView::Stream::didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse& response)
{
    // Compute the stream related data from the resource response.
    const URL& responseURL = response.url();
    const String& mimeType = response.mimeType();
    long long expectedContentLength = response.expectedContentLength();
    

    }

    // Compute the stream related data from the resource response.
    const URL& responseURL = response.url();
    const String& mimeType = response.mimeType();
    long long expectedContentLength = response.expectedContentLength();
    

    if (!frame)
        return String();
    
    return frame->loader().client().userAgent(URL());
}

void PluginView::loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, 

{
    const FrameLoader* frameLoader = frame() ? &frame()->loader() : 0;
    const NetworkingContext* context = frameLoader ? frameLoader->networkingContext() : 0;
    Vector<ProxyServer> proxyServers = proxyServersForURL(URL(URL(), urlString), context);
    return toString(proxyServers);
}

String PluginView::cookiesForURL(const String& urlString)
{
    return cookies(&m_pluginElement->document(), URL(URL(), urlString));
}

void PluginView::setCookiesForURL(const String& urlString, const String& cookieString)
{
    setCookies(&m_pluginElement->document(), URL(URL(), urlString), cookieString);
}

bool PluginView::getAuthenticationInfo(const ProtectionSpace& protectionSpace, String& username, String& password)



    String frameURLString = pluginElement->document().frame()->loader().documentLoader()->responseURL().string();
    String pageURLString = m_page->mainFrame()->loader().documentLoader()->responseURL().string();
    String pluginURLString = pluginElement->document().completeURL(pluginElement->url()).string();
    URL pluginspageAttributeURL = element->document().completeURL(stripLeadingAndTrailingHTMLSpaces(pluginElement->getAttribute(pluginspageAttr)));
    if (!pluginspageAttributeURL.protocolIsInHTTPFamily())
        pluginspageAttributeURL = URL();
    m_page->send(Messages::WebPageProxy::UnavailablePluginButtonClicked(pluginUnavailabilityReason, pluginElement->serviceType(), pluginURLString, pluginspageAttributeURL.string(), frameURLString, pageURLString));
}




    notImplemented();
}

void WebContextMenuClient::downloadURL(const URL&)
{
    // This is handled in the UI process.
    ASSERT_NOT_REACHED();


    if (Page* page = frame->page()) {
        UserGestureIndicator indicator(DefinitelyProcessingUserGesture);
        page->mainFrame().loader().urlSelected(URL(ParsedURLString, url), String(), 0, false, false, MaybeSendReferrer);
    }
}
#endif

Lines 51-57 private: a/Source/WebKit2/WebProcess/WebCoreSupport/WebContextMenuClient.h_sec1
- a/Source/WebKit2/WebProcess/WebCoreSupport/WebContextMenuClient.h -1 / +1 lines
51	#endif	51	#endif
52	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu) OVERRIDE;	52	virtual void contextMenuItemSelected(WebCore::ContextMenuItem, const WebCore::ContextMenu) OVERRIDE;
53		53
54	virtual void downloadURL(const WebCore::KURL&) OVERRIDE;	54	virtual void downloadURL(const WebCore::URL&) OVERRIDE;
55	virtual void searchWithGoogle(const WebCore::Frame*) OVERRIDE;	55	virtual void searchWithGoogle(const WebCore::Frame*) OVERRIDE;
56	virtual void lookUpInDictionary(WebCore::Frame*) OVERRIDE;	56	virtual void lookUpInDictionary(WebCore::Frame*) OVERRIDE;
57	virtual bool isSpeaking() OVERRIDE;	57	virtual bool isSpeaking() OVERRIDE;



#define WebErrors_h

namespace WebCore {
class URL;
class ResourceError;
class ResourceRequest;
class ResourceResponse;
}

namespace WebKit {

WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&);
WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&);
WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&);
WebCore::ResourceError internalError(const WebCore::URL&);

} // namespace WebKit




    webPage->injectedBundleLoaderClient().didCancelClientRedirectForFrame(webPage, m_frame);
}

void WebFrameLoaderClient::dispatchWillPerformClientRedirect(const URL& url, double interval, double fireDate)
{
    WebPage* webPage = m_frame->page();
    if (!webPage)

    webPage->send(Messages::WebPageProxy::DidDisplayInsecureContentForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
}

void WebFrameLoaderClient::didRunInsecureContent(SecurityOrigin*, const URL&)
{
    WebPage* webPage = m_frame->page();
    if (!webPage)

    webPage->send(Messages::WebPageProxy::DidRunInsecureContentForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
}

void WebFrameLoaderClient::didDetectXSS(const URL&, bool)
{
    WebPage* webPage = m_frame->page();
    if (!webPage)

    return DocumentLoader::create(request, data);
}

void WebFrameLoaderClient::setTitle(const StringWithDirection& title, const URL& url)
{
    WebPage* webPage = m_frame->page();
    if (!webPage || !webPage->pageGroup()->isVisibleToHistoryClient())

        title.string(), url.string(), m_frame->frameID()), 0);
}

String WebFrameLoaderClient::userAgent(const URL&)
{
    WebPage* webPage = m_frame->page();
    if (!webPage)

    m_frame->convertMainResourceLoadToDownload(documentLoader, request, response);
}

PassRefPtr<Frame> WebFrameLoaderClient::createFrame(const URL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
                                                    const String& referrer, bool /*allowsScrolling*/, int /*marginWidth*/, int /*marginHeight*/)
{
    WebPage* webPage = m_frame->page();

    return coreSubframe;
}

PassRefPtr<Widget> WebFrameLoaderClient::createPlugin(const IntSize&, HTMLPlugInElement* pluginElement, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
    ASSERT(paramNames.size() == paramValues.size());
    ASSERT(m_frame->page());

        m_pluginView = static_cast<PluginView*>(pluginWidget);
}

PassRefPtr<Widget> WebFrameLoaderClient::createJavaAppletWidget(const IntSize& pluginSize, HTMLAppletElement* appletElement, const URL&, const Vector<String>& paramNames, const Vector<String>& paramValues)
{
    RefPtr<Widget> plugin = createPlugin(pluginSize, appletElement, URL(), paramNames, paramValues, appletElement->serviceType(), false);
    if (!plugin) {
        if (WebPage* webPage = m_frame->page()) {
            String frameURLString = m_frame->coreFrame()->loader().documentLoader()->responseURL().string();

}

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
PassRefPtr<Widget> WebFrameLoaderClient::createMediaPlayerProxyPlugin(const IntSize&, HTMLMediaElement*, const URL&, const Vector<String>&, const Vector<String>&, const String&)
{
    notImplemented();
    return 0;

    return false;
}

ObjectContentType WebFrameLoaderClient::objectContentType(const URL& url, const String& mimeTypeIn, bool shouldPreferPlugInsForImages)
{
    // FIXME: This should be merged with WebCore::FrameLoader::defaultObjectContentType when the plugin code
    // is consolidated.

    return true;
}

bool WebFrameLoaderClient::shouldForceUniversalAccessFromLocalURL(const WebCore::URL& url)
{
    WebPage* webPage = m_frame->page();
    if (!webPage)



    virtual void dispatchDidHandleOnloadEvents() OVERRIDE;
    virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() OVERRIDE;
    virtual void dispatchDidCancelClientRedirect() OVERRIDE;
    virtual void dispatchWillPerformClientRedirect(const WebCore::URL&, double interval, double fireDate) OVERRIDE;
    virtual void dispatchDidChangeLocationWithinPage() OVERRIDE;
    virtual void dispatchDidPushStateWithinPage() OVERRIDE;
    virtual void dispatchDidReplaceStateWithinPage() OVERRIDE;

    virtual bool shouldStopLoadingForHistoryItem(WebCore::HistoryItem*) const OVERRIDE;

    virtual void didDisplayInsecureContent() OVERRIDE;
    virtual void didRunInsecureContent(WebCore::SecurityOrigin*, const WebCore::URL&) OVERRIDE;
    virtual void didDetectXSS(const WebCore::URL&, bool didBlockEntirePage) OVERRIDE;

    virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) OVERRIDE;
    virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) OVERRIDE;

    virtual void prepareForDataSourceReplacement() OVERRIDE;
    
    virtual PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&);
    virtual void setTitle(const WebCore::StringWithDirection&, const WebCore::URL&) OVERRIDE;
    
    virtual String userAgent(const WebCore::URL&) OVERRIDE;
    
    virtual void savePlatformDataToCachedFrame(WebCore::CachedFrame*) OVERRIDE;
    virtual void transitionToCommittedFromCachedFrame(WebCore::CachedFrame*) OVERRIDE;

    virtual bool canCachePage() const OVERRIDE { return true; }
    virtual void convertMainResourceLoadToDownload(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&) OVERRIDE;
    
    virtual PassRefPtr<WebCore::Frame> createFrame(const WebCore::URL& url, const String& name, WebCore::HTMLFrameOwnerElement* ownerElement,
                                          const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight) OVERRIDE;
    
    virtual PassRefPtr<WebCore::Widget> createPlugin(const WebCore::IntSize&, WebCore::HTMLPlugInElement*, const WebCore::URL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually) OVERRIDE;
    virtual void recreatePlugin(WebCore::Widget*) OVERRIDE;
    virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget) OVERRIDE;
    
    virtual PassRefPtr<WebCore::Widget> createJavaAppletWidget(const WebCore::IntSize&, WebCore::HTMLAppletElement*, const WebCore::URL& baseURL, const Vector<String>& paramNames, const Vector<String>& paramValues) OVERRIDE;
    
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
    virtual PassRefPtr<WebCore::Widget> createMediaPlayerProxyPlugin(const WebCore::IntSize&, WebCore::HTMLMediaElement*, const WebCore::URL&, const Vector<String>&, const Vector<String>&, const String&) OVERRIDE;
    virtual void hideMediaPlayerProxyPlugin(WebCore::Widget*) OVERRIDE;
    virtual void showMediaPlayerProxyPlugin(WebCore::Widget*) OVERRIDE;
#endif

    virtual WebCore::ObjectContentType objectContentType(const WebCore::URL&, const String& mimeType, bool shouldPreferPlugInsForImages) OVERRIDE;
    virtual String overrideMediaType() const OVERRIDE;

    virtual void dispatchDidClearWindowObjectInWorld(WebCore::DOMWrapperWorld*) OVERRIDE;


    virtual bool allowScript(bool enabledPerSettings) OVERRIDE;

    virtual bool shouldForceUniversalAccessFromLocalURL(const WebCore::URL&) OVERRIDE;

    virtual PassRefPtr<WebCore::FrameNetworkingContext> createNetworkingContext() OVERRIDE;




#include "WebProcessProxyMessages.h"
#include <WebCore/Color.h>
#include <WebCore/Frame.h>
#include <WebCore/URL.h>
#include <WebCore/LoaderStrategy.h>
#include <WebCore/NetworkStorageSession.h>
#include <WebCore/NetworkingContext.h>


// CookiesStrategy

String WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
#if ENABLE(NETWORK_PROCESS)
    if (WebProcess::shared().usesNetworkProcess()) {

    return WebCore::cookiesForDOM(session, firstParty, url);
}

void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
{
#if ENABLE(NETWORK_PROCESS)
    if (WebProcess::shared().usesNetworkProcess()) {

    WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
}

bool WebPlatformStrategies::cookiesEnabled(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
#if ENABLE(NETWORK_PROCESS)
    if (WebProcess::shared().usesNetworkProcess()) {

    return WebCore::cookiesEnabled(session, firstParty, url);
}

String WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
{
#if ENABLE(NETWORK_PROCESS)
    if (WebProcess::shared().usesNetworkProcess()) {

    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url);
}

bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
{
#if ENABLE(NETWORK_PROCESS)
    if (WebProcess::shared().usesNetworkProcess()) {

    return WebCore::getRawCookies(session, firstParty, url, rawCookies);
}

void WebPlatformStrategies::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
{
#if ENABLE(NETWORK_PROCESS)
    if (WebProcess::shared().usesNetworkProcess()) {


// VisitedLinkStrategy

bool WebPlatformStrategies::isLinkVisited(Page*, LinkHash linkHash, const URL&, const AtomicString&)
{
    return WebProcess::shared().isLinkVisited(linkHash);
}

    return color;
}

URL WebPlatformStrategies::url(const String& pasteboardName)
{
    String urlString;
    WebProcess::shared().parentProcessConnection()->sendSync(Messages::WebContext::GetPasteboardURL(pasteboardName),
                                                Messages::WebContext::GetPasteboardURL::Reply(urlString), 0);
    return URL(ParsedURLString, urlString);
}

long WebPlatformStrategies::addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName)



    virtual WebCore::VisitedLinkStrategy* createVisitedLinkStrategy() OVERRIDE;

    // WebCore::CookiesStrategy
    virtual String cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&) OVERRIDE;
    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&) OVERRIDE;
    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&) OVERRIDE;
    virtual String cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&) OVERRIDE;
    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&) OVERRIDE;
    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&) OVERRIDE;

    // WebCore::DatabaseStrategy
#if ENABLE(SQL_DATABASE)

    virtual PassRefPtr<WebCore::StorageNamespace> sessionStorageNamespace(WebCore::Page*) OVERRIDE;

    // WebCore::VisitedLinkStrategy
    virtual bool isLinkVisited(WebCore::Page*, WebCore::LinkHash, const WebCore::URL& baseURL, const WTF::AtomicString& attributeURL) OVERRIDE;
    virtual void addVisitedLink(WebCore::Page*, WebCore::LinkHash) OVERRIDE;

#if PLATFORM(MAC)

    virtual long changeCount(const String& pasteboardName) OVERRIDE;
    virtual String uniqueName() OVERRIDE;
    virtual WebCore::Color color(const String& pasteboardName) OVERRIDE;
    virtual WebCore::URL url(const String& pasteboardName) OVERRIDE;

    virtual long addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) OVERRIDE;
    virtual long setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName) OVERRIDE;

Lines 72-78 ResourceError pluginWillHandleLoadError(const ResourceResponse& response) a/Source/WebKit2/WebProcess/WebCoreSupport/efl/WebErrorsEfl.cpp_sec1
- a/Source/WebKit2/WebProcess/WebCoreSupport/efl/WebErrorsEfl.cpp -1 / +1 lines
72	return WebCore::pluginWillHandleLoadError(response);	72	return WebCore::pluginWillHandleLoadError(response);
73	}	73	}
74		74
75	WebCore::ResourceError internalError(const WebCore::KURL& url)	75	WebCore::ResourceError internalError(const WebCore::URL& url)
76	{	76	{
77	return ResourceError(WebError::webKitErrorDomain(), kWKErrorInternal, url.string(), ASCIILiteral("Internal error"));	77	return ResourceError(WebError::webKitErrorDomain(), kWKErrorInternal, url.string(), ASCIILiteral("Internal error"));
78	}	78	}

Lines 75-81 ResourceError pluginWillHandleLoadError(const ResourceResponse& response) a/Source/WebKit2/WebProcess/WebCoreSupport/gtk/WebErrorsGtk.cpp_sec1
- a/Source/WebKit2/WebProcess/WebCoreSupport/gtk/WebErrorsGtk.cpp -1 / +1 lines
75	return WebCore::pluginWillHandleLoadError(response);	75	return WebCore::pluginWillHandleLoadError(response);
76	}	76	}
77		77
78	WebCore::ResourceError internalError(const WebCore::KURL& url)	78	WebCore::ResourceError internalError(const WebCore::URL& url)
79	{	79	{
80	return ResourceError(WebError::webKitErrorDomain(), kWKErrorInternal, url.string(), _("Internal error"));	80	return ResourceError(WebError::webKitErrorDomain(), kWKErrorInternal, url.string(), _("Internal error"));
81	}	81	}

Lines 87-93 ResourceError pluginWillHandleLoadError(const ResourceResponse& response) a/Source/WebKit2/WebProcess/WebCoreSupport/mac/WebErrorsMac.mm_sec1
- a/Source/WebKit2/WebProcess/WebCoreSupport/mac/WebErrorsMac.mm -1 / +1 lines
87	return ResourceError(WebError::webKitErrorDomain(), kWKErrorCodePlugInWillHandleLoad, response.url(), WEB_UI_STRING("Plug-in handled load", "WebKitErrorPlugInWillHandleLoad description"));	87	return ResourceError(WebError::webKitErrorDomain(), kWKErrorCodePlugInWillHandleLoad, response.url(), WEB_UI_STRING("Plug-in handled load", "WebKitErrorPlugInWillHandleLoad description"));
88	}	88	}
89		89
90	ResourceError internalError(const KURL& url)	90	ResourceError internalError(const URL& url)
91	{	91	{
92	return ResourceError(WebError::webKitErrorDomain(), kWKErrorInternal, url, WEB_UI_STRING("WebKit encountered an internal error", "WebKitErrorInternal description"));	92	return ResourceError(WebError::webKitErrorDomain(), kWKErrorInternal, url, WEB_UI_STRING("WebKit encountered an internal error", "WebKitErrorInternal description"));
93	}	93	}



    return m_coreFrame->document()->domWindow()->pendingUnloadEventListeners();
}

bool WebFrame::allowsFollowingLink(const WebCore::URL& url) const
{
    if (!m_coreFrame)
        return true;

    return provisionalDocumentLoader->url().string();
}

String WebFrame::suggestedFilenameForResourceWithURL(const URL& url) const
{
    if (!m_coreFrame)
        return String();

    return page()->cachedSuggestedFilenameForURL(url);
}

String WebFrame::mimeTypeForResourceWithURL(const URL& url) const
{
    if (!m_coreFrame)
        return String();



class HTMLFrameOwnerElement;
class IntPoint;
class IntRect;
class URL;
}

namespace WebKit {

    
    unsigned pendingUnloadCount() const;
    
    bool allowsFollowingLink(const WebCore::URL&) const;

    String provisionalURL() const;
    String suggestedFilenameForResourceWithURL(const WebCore::URL&) const;
    String mimeTypeForResourceWithURL(const WebCore::URL&) const;

    void setTextDirection(const String&);





void WebPage::loadURL(const String& url, const SandboxExtension::Handle& sandboxExtensionHandle, CoreIPC::MessageDecoder& decoder)
{
    loadURLRequest(ResourceRequest(URL(URL(), url)), sandboxExtensionHandle, decoder);
}

void WebPage::loadURLRequest(const ResourceRequest& request, const SandboxExtension::Handle& sandboxExtensionHandle, CoreIPC::MessageDecoder& decoder)

    m_mainFrame->coreFrame()->loader().load(FrameLoadRequest(m_mainFrame->coreFrame(), request));
}

void WebPage::loadDataImpl(PassRefPtr<SharedBuffer> sharedBuffer, const String& MIMEType, const String& encodingName, const URL& baseURL, const URL& unreachableURL, CoreIPC::MessageDecoder& decoder)
{
    SendStopResponsivenessTimer stopper(this);


void WebPage::loadData(const CoreIPC::DataReference& data, const String& MIMEType, const String& encodingName, const String& baseURLString, CoreIPC::MessageDecoder& decoder)
{
    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(data.data()), data.size());
    URL baseURL = baseURLString.isEmpty() ? blankURL() : URL(URL(), baseURLString);
    loadDataImpl(sharedBuffer, MIMEType, encodingName, baseURL, URL(), decoder);
}

void WebPage::loadHTMLString(const String& htmlString, const String& baseURLString, CoreIPC::MessageDecoder& decoder)
{
    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(htmlString.characters()), htmlString.length() * sizeof(UChar));
    URL baseURL = baseURLString.isEmpty() ? blankURL() : URL(URL(), baseURLString);
    loadDataImpl(sharedBuffer, "text/html", "utf-16", baseURL, URL(), decoder);
}

void WebPage::loadAlternateHTMLString(const String& htmlString, const String& baseURLString, const String& unreachableURLString, CoreIPC::MessageDecoder& decoder)
{
    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(htmlString.characters()), htmlString.length() * sizeof(UChar));
    URL baseURL = baseURLString.isEmpty() ? blankURL() : URL(URL(), baseURLString);
    URL unreachableURL = unreachableURLString.isEmpty() ? URL() : URL(URL(), unreachableURLString);
    loadDataImpl(sharedBuffer, "text/html", "utf-16", baseURL, unreachableURL, decoder);
}

void WebPage::loadPlainTextString(const String& string, CoreIPC::MessageDecoder& decoder)
{
    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(string.characters()), string.length() * sizeof(UChar));
    loadDataImpl(sharedBuffer, "text/plain", "utf-16", blankURL(), URL(), decoder);
}

void WebPage::loadWebArchiveData(const CoreIPC::DataReference& webArchiveData, CoreIPC::MessageDecoder& decoder)
{
    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(webArchiveData.data()), webArchiveData.size() * sizeof(uint8_t));
    loadDataImpl(sharedBuffer, "application/x-webarchive", "utf-16", blankURL(), URL(), decoder);
}

void WebPage::linkClicked(const String& url, const WebMouseEvent& event)

    send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
}

static PassRefPtr<SharedBuffer> resourceDataForFrame(Frame* frame, const URL& resourceURL)
{
    DocumentLoader* loader = frame->loader().documentLoader();
    if (!loader)

void WebPage::getResourceDataFromFrame(uint64_t frameID, const String& resourceURLString, uint64_t callbackID)
{
    CoreIPC::DataReference dataReference;
    URL resourceURL(URL(), resourceURLString);

    RefPtr<SharedBuffer> buffer;
    if (WebFrame* frame = WebProcess::shared().webFrame(frameID)) {

    // because it does not pertain to the failed load, and will be needed.
}

bool WebPage::hasLocalDataForURL(const URL& url)
{
    if (url.isLocalFile())
        return true;



    WebContextMenu* contextMenuAtPointInWindow(const WebCore::IntPoint&);
#endif
    
    bool hasLocalDataForURL(const WebCore::URL&);
    String cachedResponseMIMETypeForURL(const WebCore::URL&);
    String cachedSuggestedFilenameForURL(const WebCore::URL&);
    PassRefPtr<WebCore::SharedBuffer> cachedResponseDataForURL(const WebCore::URL&);

    static bool canHandleRequest(const WebCore::ResourceRequest&);



    String sourceForFrame(WebFrame*);

    void loadDataImpl(PassRefPtr<WebCore::SharedBuffer>, const String& MIMEType, const String& encodingName, const WebCore::URL& baseURL, const WebCore::URL& failingURL, CoreIPC::MessageDecoder&);

    bool platformHasLocalDataForURL(const WebCore::URL&);

    // Actions
    void tryClose();



    return true;
}

bool WebPage::platformHasLocalDataForURL(const URL&)
{
    notImplemented();
    return false;
}

String WebPage::cachedResponseMIMETypeForURL(const URL&)
{
    notImplemented();
    return String();

    return true;
}

String WebPage::cachedSuggestedFilenameForURL(const URL&)
{
    notImplemented();
    return String();
}

PassRefPtr<SharedBuffer> WebPage::cachedResponseDataForURL(const URL&)
{
    notImplemented();
    return 0;



    return true;
}

bool WebPage::platformHasLocalDataForURL(const URL&)
{
    notImplemented();
    return false;
}

String WebPage::cachedResponseMIMETypeForURL(const URL&)
{
    notImplemented();
    return String();

    return true;
}

String WebPage::cachedSuggestedFilenameForURL(const URL&)
{
    notImplemented();
    return String();
}

PassRefPtr<SharedBuffer> WebPage::cachedResponseDataForURL(const URL&)
{
    notImplemented();
    return 0;



    return m_mockAccessibilityElement.get();
}
         
bool WebPage::platformHasLocalDataForURL(const WebCore::URL& url)
{
    NSMutableURLRequest* request = [[NSMutableURLRequest alloc] initWithURL:url];
    [request setValue:(NSString*)userAgent() forHTTPHeaderField:@"User-Agent"];

    return cachedResponse;
}

static NSCachedURLResponse *cachedResponseForURL(WebPage* webPage, const URL& url)
{
    RetainPtr<NSMutableURLRequest> request = adoptNS([[NSMutableURLRequest alloc] initWithURL:url]);
    [request.get() setValue:(NSString *)webPage->userAgent() forHTTPHeaderField:@"User-Agent"];

    return [[NSURLCache sharedURLCache] cachedResponseForRequest:request.get()];
}

String WebPage::cachedSuggestedFilenameForURL(const URL& url)
{
    return [[cachedResponseForURL(this, url) response] suggestedFilename];
}

String WebPage::cachedResponseMIMETypeForURL(const URL& url)
{
    return [[cachedResponseForURL(this, url) response] MIMEType];
}

PassRefPtr<SharedBuffer> WebPage::cachedResponseDataForURL(const URL& url)
{
    return SharedBuffer::wrapNSData([cachedResponseForURL(this, url) data]);
}



    return true;
}

bool WebPage::platformHasLocalDataForURL(const URL&)
{
    notImplemented();
    return false;
}

String WebPage::cachedResponseMIMETypeForURL(const URL&)
{
    notImplemented();
    return String();

    return true;
}

String WebPage::cachedSuggestedFilenameForURL(const URL&)
{
    notImplemented();
    return String();
}

PassRefPtr<SharedBuffer> WebPage::cachedResponseDataForURL(const URL&)
{
    notImplemented();
    return 0;

Lines 240-246 void WebProcess::updateActivePages() a/Source/WebKit2/WebProcess/mac/WebProcessMac.mm_sec1
- a/Source/WebKit2/WebProcess/mac/WebProcessMac.mm -1 / +1 lines
240	if (!mainFrameOrigin->isUnique())	240	if (!mainFrameOrigin->isUnique())
241	mainFrameOriginString = mainFrameOrigin->toRawString();	241	mainFrameOriginString = mainFrameOrigin->toRawString();
242	else	242	else
243	mainFrameOriginString = KURL(KURL(), mainFrame->url()).protocol() + ':'; // toRawString() is not supposed to work with unique origins, and would just return "://".	243	mainFrameOriginString = URL(URL(), mainFrame->url()).protocol() + ':'; // toRawString() is not supposed to work with unique origins, and would just return "://".
244		244
245	NSURL *originAsNSURL = [NSURL URLWithString:mainFrameOriginString];	245	NSURL *originAsNSURL = [NSURL URLWithString:mainFrameOriginString];
246	// +[NSURL URLWithString:] returns nil when its argument is malformed. It's unclear how we can possibly have a malformed URL here,	246	// +[NSURL URLWithString:] returns nil when its argument is malformed. It's unclear how we can possibly have a malformed URL here,



2013-09-26  Darin Adler  <darin@apple.com>

        rename KURL to URL
        https://bugs.webkit.org/show_bug.cgi?id=16214

        Reviewed by Andreas Kling.

        * many files: Renamed, using script.

2013-09-27  Patrick Gansterer  <paroga@webkit.org>

        Add general CMakeLists.txt for DRT



#include "Frame.h"
#include "HTMLInputElement.h"
#include "JSElement.h"
#include "URL.h"
#include "NotImplemented.h"
#include "Page.h"
#include "RenderTreeAsText.h"

    OwnArrayPtr<char> urlArr = adoptArrayPtr(new char[urlArrSize]);
    JSStringGetUTF8CString(url, urlArr.get(), urlArrSize);

    WebCore::URL base = mainFrame->loader()->documentLoader()->response().url();
    WebCore::URL absolute(base, urlArr.get());

    JSRetainPtr<JSStringRef> absoluteURL(Adopt, JSStringCreateWithUTF8CString(absolute.string().utf8().data()));
    WorkQueue::shared()->queue(new LoadItem(absoluteURL.get(), target));



#include "DumpRenderTreeBlackBerry.h"
#include "Frame.h"
#include "FrameLoadRequest.h"
#include "URL.h"
#include "WebPage.h"
#include <wtf/OwnArrayPtr.h>


    if (!frame)
        return false;

    URL kurl = URL(URL(), url.get());
    frame->loader()->load(FrameLoadRequest(frame, ResourceRequest(kurl)));
    return true;
}



#include "EditingCallbacks.h"
#include "EventSender.h"
#include "GCController.h"
#include "URL.h"
#include "NotImplemented.h"
#include "TestRunner.h"
#include "TextInputController.h"


static String pathSuitableForTestResult(const char* uriString)
{
    URL uri = URL(ParsedURLString, uriString);
    if (uri.isEmpty())
        return "(null)";

    if (!uri.isLocalFile())
        return uri.string();

    URL mainFrameURL = URL(ParsedURLString, ewk_frame_uri_get(browser->mainFrame()));
    if (mainFrameURL.isEmpty())
        mainFrameURL = DumpRenderTreeSupportEfl::provisionalURL(browser->mainFrame());


        return;
    }

    URL url = URL(ParsedURLString, messages->request->url);

    if (url.isValid()
        && url.protocolIsInHTTPFamily()


    if (!done && gTestRunner->dumpResourceResponseMIMETypes()) {
        printf("%s has MIME type %s\n",
               URL(ParsedURLString, response->url).lastPathComponent().utf8().data(),
               response->mime_type);
    }
}



#include <JavaScriptCore/JSRetainPtr.h>
#include <JavaScriptCore/JSStringRef.h>
#include <JavaScriptCore/OpaqueJSString.h>
#include <URL.h>
#include <editing/FindOptions.h>
#include <stdio.h>
#include <wtf/text/WTFString.h>


void TestRunner::queueLoad(JSStringRef url, JSStringRef target)
{
    WebCore::URL baseURL(WebCore::URL(), String::fromUTF8(ewk_frame_uri_get(browser->mainFrame())));
    WebCore::URL absoluteURL(baseURL, url->string());

    JSRetainPtr<JSStringRef> jsAbsoluteURL(
        Adopt, JSStringCreateWithUTF8CString(absoluteURL.string().utf8().data()));


void TestRunner::addOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef protocol, JSStringRef host, bool includeSubdomains)
{
    WebCore::URL kurl;
    kurl.setProtocol(String(protocol->characters(), protocol->length()));
    kurl.setHost(String(host->characters(), host->length()));



void TestRunner::removeOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef protocol, JSStringRef host, bool includeSubdomains)
{
    WebCore::URL kurl;
    kurl.setProtocol(String(protocol->characters(), protocol->length()));
    kurl.setHost(String(host->characters(), host->length()));


Lines 74-79 find(\&wanted, "Source/WebCore"); a/Tools/Scripts/do-webcore-rename_sec1
- a/Tools/Scripts/do-webcore-rename -9 / +8 lines
74	find(\&wanted, "Source/WebKit");	74	find(\&wanted, "Source/WebKit");
75	find(\&wanted, "Source/WebKit2");	75	find(\&wanted, "Source/WebKit2");
76	find(\&wanted, "Tools/DumpRenderTree");	76	find(\&wanted, "Tools/DumpRenderTree");
		77	find(\&wanted, "Tools/TestWebKitAPI");
77		78
78	sub wanted	79	sub wanted
79	{	80	{
Lines 93-103 sub wanted a/Tools/Scripts/do-webcore-rename_sec2
93		94
94	# Setting isDOMTypeRename to 1 rather than 0 expands the regexps used	95	# Setting isDOMTypeRename to 1 rather than 0 expands the regexps used
95	# below to handle custom JavaScript bindings.	96	# below to handle custom JavaScript bindings.
96	my $isDOMTypeRename = 1;	97	my $isDOMTypeRename = 0;
97	my %renames = (	98	my %renames = (
98	# Renames go here in the form of:	99	# Renames go here in the form of:
99	"isTransformInvertible" => "hasInvertibleTransform",	100	"WKURL" => "WKURL",
100	"m_invertibleCTM" => "m_hasInvertibleTransform",	101	"KURL" => "URL",
		102	"KURLCFNet" => "URLCF",
		103	"KURLHash" => "URLHash",
		104	"KURLMac" => "URLMac",
		105	"KURL_h" => "URL_h",
101	);	106	);
102		107
103	my %renamesContemplatedForTheFuture = (	108	my %renamesContemplatedForTheFuture = (
Lines 108-119 my %renamesContemplatedForTheFuture = ( a/Tools/Scripts/do-webcore-rename_sec3
108	"DateInstance" => "JSDate",	113	"DateInstance" => "JSDate",
109	"ErrorInstance" => "JSError",	114	"ErrorInstance" => "JSError",
110		115
111	"KURL" => "URL",
112	"KURLCFNet" => "URLCF",
113	"KURLHash" => "URLHash",
114	"KURLMac" => "URLMac",
115	"KURL_h" => "URL_h",
116
117	"TreeShared" => "TreeRefCounted",	116	"TreeShared" => "TreeRefCounted",
118		117
119	"StringImpl" => "SharedString",	118	"StringImpl" => "SharedString",

Lines 166-172 Programs_TestWebKitAPI_TestWebCore_LDFLAGS = \ a/Tools/TestWebKitAPI/GNUmakefile.am_sec1
- a/Tools/TestWebKitAPI/GNUmakefile.am -1 / +1 lines
166	-no-fast-install	166	-no-fast-install
167		167
168	Programs_TestWebKitAPI_TestWebCore_SOURCES = \	168	Programs_TestWebKitAPI_TestWebCore_SOURCES = \
169	Tools/TestWebKitAPI/Tests/WebCore/KURL.cpp \	169	Tools/TestWebKitAPI/Tests/WebCore/URL.cpp \
170	Tools/TestWebKitAPI/Tests/WebCore/LayoutUnit.cpp	170	Tools/TestWebKitAPI/Tests/WebCore/LayoutUnit.cpp
171		171
172	Programs_TestWebKitAPI_TestGtk_CPPFLAGS = \	172	Programs_TestWebKitAPI_TestGtk_CPPFLAGS = \

Lines 49-55 set(webkit2_api_harness_SOURCES a/Tools/TestWebKitAPI/PlatformEfl.cmake_sec1
- a/Tools/TestWebKitAPI/PlatformEfl.cmake -1 / +1 lines
49		49
50	set(test_webcore_BINARIES	50	set(test_webcore_BINARIES
51	LayoutUnit	51	LayoutUnit
52	KURL	52	URL
53	)	53	)
54		54
55	# In here we list the bundles that are used by our specific WK2 API Tests	55	# In here we list the bundles that are used by our specific WK2 API Tests

Lines 64-70 list(APPEND test_webcore_LIBRARIES a/Tools/TestWebKitAPI/PlatformGTK.cmake_sec1
- a/Tools/TestWebKitAPI/PlatformGTK.cmake -1 / +1 lines
64		64
65	set(test_webcore_BINARIES	65	set(test_webcore_BINARIES
66	LayoutUnit	66	LayoutUnit
67	KURL	67	URL
68	)	68	)
69		69
70	set(test_webkit2_api_BINARIES	70	set(test_webkit2_api_BINARIES



		37E1064C1697681800B78BD0 /* DOMHTMLTableCellElementCellAbove.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 37E1064B169767F700B78BD0 /* DOMHTMLTableCellElementCellAbove.html */; };
		37E1064D16976C8500B78BD0 /* DOMHTMLTableCellCellAbove.mm in Sources */ = {isa = PBXBuildFile; fileRef = 37E1064A1697676400B78BD0 /* DOMHTMLTableCellCellAbove.mm */; };
		37E38C34169B7D010084C28C /* WebViewDidRemoveFrameFromHierarchy.mm in Sources */ = {isa = PBXBuildFile; fileRef = 37E38C33169B7D010084C28C /* WebViewDidRemoveFrameFromHierarchy.mm */; };
		440A1D3914A0103A008A66F2 /* URL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 440A1D3814A0103A008A66F2 /* URL.cpp */; };
		4BB4160216815B2600824238 /* JSWrapperForNodeInWebFrame.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BB4160116815B2600824238 /* JSWrapperForNodeInWebFrame.mm */; };
		4BB4160416815F9100824238 /* ElementAtPointInWebFrame.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BB4160316815F9100824238 /* ElementAtPointInWebFrame.mm */; };
		4BFDFFA71314776C0061F24B /* HitTestResultNodeHandle_Bundle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFDFFA61314776C0061F24B /* HitTestResultNodeHandle_Bundle.cpp */; };

		37E1064A1697676400B78BD0 /* DOMHTMLTableCellCellAbove.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DOMHTMLTableCellCellAbove.mm; sourceTree = "<group>"; };
		37E1064B169767F700B78BD0 /* DOMHTMLTableCellElementCellAbove.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = DOMHTMLTableCellElementCellAbove.html; sourceTree = "<group>"; };
		37E38C33169B7D010084C28C /* WebViewDidRemoveFrameFromHierarchy.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebViewDidRemoveFrameFromHierarchy.mm; sourceTree = "<group>"; };
		440A1D3814A0103A008A66F2 /* URL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = URL.cpp; sourceTree = "<group>"; };
		44A622C114A0E2B60048515B /* WTFStringUtilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WTFStringUtilities.h; sourceTree = "<group>"; };
		4BB4160116815B2600824238 /* JSWrapperForNodeInWebFrame.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = JSWrapperForNodeInWebFrame.mm; sourceTree = "<group>"; };
		4BB4160316815F9100824238 /* ElementAtPointInWebFrame.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ElementAtPointInWebFrame.mm; sourceTree = "<group>"; };

		440A1D3614A01000008A66F2 /* WebCore */ = {
			isa = PBXGroup;
			children = (
				440A1D3814A0103A008A66F2 /* URL.cpp */,
				14464012167A8305000BD218 /* LayoutUnit.cpp */,
			);
			path = WebCore;

				C0ADBE7C12FCA4D000D2C129 /* JavaScriptTest.cpp in Sources */,
				C081224213FC172400DC39AE /* JavaScriptTestMac.mm in Sources */,
				4BB4160216815B2600824238 /* JSWrapperForNodeInWebFrame.mm in Sources */,
				440A1D3914A0103A008A66F2 /* URL.cpp in Sources */,
				14464013167A8305000BD218 /* LayoutUnit.cpp in Sources */,
				2D640B5517875DFF00BFAF99 /* ScrollPinningBehaviors.cpp in Sources */,
				26300B1816755CD90066886D /* ListHashSet.cpp in Sources */,



/*
 * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "WTFStringUtilities.h"
#include <WebCore/KURL.h>
#include <wtf/MainThread.h>

using namespace WebCore;

namespace TestWebKitAPI {

class KURLTest : public testing::Test {
public:
    virtual void SetUp()
    {
        WTF::initializeMainThread();
    }
};

TEST_F(KURLTest, KURLConstructorDefault)
{
    KURL kurl;

    EXPECT_TRUE(kurl.isEmpty());
    EXPECT_TRUE(kurl.isNull());
    EXPECT_FALSE(kurl.isValid());
}

TEST_F(KURLTest, KURLConstructorConstChar)
{
    KURL kurl(ParsedURLString, "http://username:password@www.example.com:8080/index.html?var=val#fragment");

    EXPECT_FALSE(kurl.isEmpty());
    EXPECT_FALSE(kurl.isNull());
    EXPECT_TRUE(kurl.isValid());

    EXPECT_EQ(String("http"), kurl.protocol());
    EXPECT_EQ(String("www.example.com"), kurl.host());
    EXPECT_TRUE(kurl.hasPort());
    EXPECT_EQ(8080, kurl.port());
    EXPECT_EQ(String("username"), kurl.user());
    EXPECT_EQ(String("password"), kurl.pass());
    EXPECT_EQ(String("/index.html"), kurl.path());
    EXPECT_EQ(String("index.html"), kurl.lastPathComponent());
    EXPECT_EQ(String("var=val"), kurl.query());
    EXPECT_TRUE(kurl.hasFragmentIdentifier());
    EXPECT_EQ(String("fragment"), kurl.fragmentIdentifier());
}

TEST_F(KURLTest, KURLDataURIStringSharing)
{
    KURL baseURL(ParsedURLString, "http://www.webkit.org/");
    String threeApples = "data:text/plain;charset=utf-8;base64,76O/76O/76O/";

    KURL url(baseURL, threeApples);
    EXPECT_EQ(threeApples.impl(), url.string().impl());
}

} // namespace TestWebKitAPI

Return to Bug 16214

Lines 6057-6065 platform_sources += \ a/Source/WebCore/GNUmakefile.list.am_sec1
- a/Source/WebCore/GNUmakefile.list.am -3 / +3 lines
6057	Source/WebCore/platform/HistogramSupport.cpp \	6057	Source/WebCore/platform/HistogramSupport.cpp \
6058	Source/WebCore/platform/HistogramSupport.h \	6058	Source/WebCore/platform/HistogramSupport.h \
6059	Source/WebCore/platform/HostWindow.h \	6059	Source/WebCore/platform/HostWindow.h \
6060	Source/WebCore/platform/KURL.cpp \	6060	Source/WebCore/platform/URL.cpp \
6061	Source/WebCore/platform/KURL.h \	6061	Source/WebCore/platform/URL.h \
6062	Source/WebCore/platform/KURLHash.h \	6062	Source/WebCore/platform/URLHash.h \
6063	Source/WebCore/platform/KillRing.h \	6063	Source/WebCore/platform/KillRing.h \
6064	Source/WebCore/platform/KillRingNone.cpp \	6064	Source/WebCore/platform/KillRingNone.cpp \
6065	Source/WebCore/platform/Language.cpp \	6065	Source/WebCore/platform/Language.cpp \

Lines 1026-1032 SOURCES += \ a/Source/WebCore/Target.pri_sec1
- a/Source/WebCore/Target.pri -3 / +3 lines
1026	platform/image-decoders/gif/GIFImageDecoder.cpp \	1026	platform/image-decoders/gif/GIFImageDecoder.cpp \
1027	platform/image-decoders/gif/GIFImageReader.cpp\	1027	platform/image-decoders/gif/GIFImageReader.cpp\
1028	platform/KillRingNone.cpp \	1028	platform/KillRingNone.cpp \
1029	platform/KURL.cpp \	1029	platform/URL.cpp \
1030	platform/Language.cpp \	1030	platform/Language.cpp \
1031	platform/Length.cpp \	1031	platform/Length.cpp \
1032	platform/LengthBox.cpp \	1032	platform/LengthBox.cpp \
Lines 2243-2249 HEADERS += \ a/Source/WebCore/Target.pri_sec2
2243	platform/image-decoders/gif/GIFImageReader.h \	2243	platform/image-decoders/gif/GIFImageReader.h \
2244	platform/image-decoders/png/PNGImageDecoder.h \	2244	platform/image-decoders/png/PNGImageDecoder.h \
2245	platform/KillRing.h \	2245	platform/KillRing.h \
2246	platform/KURL.h \	2246	platform/URL.h \
2247	platform/Length.h \	2247	platform/Length.h \
2248	platform/LengthBox.h \	2248	platform/LengthBox.h \
2249	platform/leveldb/LevelDBComparator.h \	2249	platform/leveldb/LevelDBComparator.h \
Lines 2904-2910 SOURCES += \ a/Source/WebCore/Target.pri_sec3
2904	platform/graphics/qt/GlyphPageTreeNodeQt.cpp \	2904	platform/graphics/qt/GlyphPageTreeNodeQt.cpp \
2905	platform/graphics/qt/SimpleFontDataQt.cpp \	2905	platform/graphics/qt/SimpleFontDataQt.cpp \
2906	platform/graphics/qt/TileQt.cpp \	2906	platform/graphics/qt/TileQt.cpp \
2907	platform/qt/KURLQt.cpp \	2907	platform/qt/URLQt.cpp \
2908	platform/qt/MIMETypeRegistryQt.cpp \	2908	platform/qt/MIMETypeRegistryQt.cpp \
2909	platform/qt/PasteboardQt.cpp \	2909	platform/qt/PasteboardQt.cpp \
2910	platform/qt/PlatformKeyboardEventQt.cpp \	2910	platform/qt/PlatformKeyboardEventQt.cpp \

Lines 1125-1131 a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters_sec1
- a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters -4 / +4 lines
1125	<ClCompile Include="..\platform\KillRingNone.cpp">	1125	<ClCompile Include="..\platform\KillRingNone.cpp">
1126	<Filter>platform</Filter>	1126	<Filter>platform</Filter>
1127	</ClCompile>	1127	</ClCompile>
1128	<ClCompile Include="..\platform\KURL.cpp">	1128	<ClCompile Include="..\platform\URL.cpp">
1129	<Filter>platform</Filter>	1129	<Filter>platform</Filter>
1130	</ClCompile>	1130	</ClCompile>
1131	<ClCompile Include="..\platform\Language.cpp">	1131	<ClCompile Include="..\platform\Language.cpp">
Lines 5109-5115 a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters_sec2
5109	<ClCompile Include="..\platform\cf\FileSystemCF.cpp">	5109	<ClCompile Include="..\platform\cf\FileSystemCF.cpp">
5110	<Filter>platform\cf</Filter>	5110	<Filter>platform\cf</Filter>
5111	</ClCompile>	5111	</ClCompile>
5112	<ClCompile Include="..\platform\cf\KURLCFNet.cpp">	5112	<ClCompile Include="..\platform\cf\URLCF.cpp">
5113	<Filter>platform\cf</Filter>	5113	<Filter>platform\cf</Filter>
5114	</ClCompile>	5114	</ClCompile>
5115	<ClCompile Include="..\platform\cf\win\CertificateCFWin.cpp">	5115	<ClCompile Include="..\platform\cf\win\CertificateCFWin.cpp">
Lines 8115-8124 a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters_sec3
8115	<ClInclude Include="..\platform\KillRing.h">	8115	<ClInclude Include="..\platform\KillRing.h">
8116	<Filter>platform</Filter>	8116	<Filter>platform</Filter>
8117	</ClInclude>	8117	</ClInclude>
8118	<ClInclude Include="..\platform\KURL.h">	8118	<ClInclude Include="..\platform\URL.h">
8119	<Filter>platform</Filter>	8119	<Filter>platform</Filter>
8120	</ClInclude>	8120	</ClInclude>
8121	<ClInclude Include="..\platform\KURLHash.h">	8121	<ClInclude Include="..\platform\URLHash.h">
8122	<Filter>platform</Filter>	8122	<Filter>platform</Filter>
8123	</ClInclude>	8123	</ClInclude>
8124	<ClInclude Include="..\platform\Language.h">	8124	<ClInclude Include="..\platform\Language.h">

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +9 lines
		1	2013-09-26 Darin Adler <darin@apple.com>
		2
		3	rename KURL to URL
		4	https://bugs.webkit.org/show_bug.cgi?id=16214
		5
		6	Reviewed by Andreas Kling.
		7
		8	* many files: Renamed, using script.
		9
1	2013-09-27 Zalan Bujtas <zalan@apple.com>	10	2013-09-27 Zalan Bujtas <zalan@apple.com>
2		11
3	Unexpected word wrapping for wrapped content then raw content.	12	Unexpected word wrapping for wrapped content then raw content.

Lines 47-53 class FileWriterCallback; a/Source/WebCore/Modules/filesystem/DOMFileSystem.h_sec1
- a/Source/WebCore/Modules/filesystem/DOMFileSystem.h -2 / +2 lines
47		47
48	class DOMFileSystem : public DOMFileSystemBase, public ActiveDOMObject {	48	class DOMFileSystem : public DOMFileSystemBase, public ActiveDOMObject {
49	public:	49	public:
50	static PassRefPtr<DOMFileSystem> create(ScriptExecutionContext*, const String& name, FileSystemType, const KURL& rootURL, PassOwnPtr<AsyncFileSystem>);	50	static PassRefPtr<DOMFileSystem> create(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
51		51
52	// Creates a new isolated file system for the given filesystemId.	52	// Creates a new isolated file system for the given filesystemId.
53	static PassRefPtr<DOMFileSystem> createIsolatedFileSystem(ScriptExecutionContext*, const String& filesystemId);	53	static PassRefPtr<DOMFileSystem> createIsolatedFileSystem(ScriptExecutionContext*, const String& filesystemId);
Lines 72-78 public: a/Source/WebCore/Modules/filesystem/DOMFileSystem.h_sec2
72	}	72	}
73		73
74	private:	74	private:
75	DOMFileSystem(ScriptExecutionContext*, const String& name, FileSystemType, const KURL& rootURL, PassOwnPtr<AsyncFileSystem>);	75	DOMFileSystem(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
76		76
77	// ActiveDOMObject methods.	77	// ActiveDOMObject methods.
78	virtual void stop() OVERRIDE;	78	virtual void stop() OVERRIDE;

Lines 57-63 const size_t DOMFileSystemBase::temporaryPathPrefixLength = sizeof(DOMFileSystem a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.cpp_sec1
- a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.cpp -5 / +5 lines
57	const char DOMFileSystemBase::isolatedPathPrefix[] = "isolated";	57	const char DOMFileSystemBase::isolatedPathPrefix[] = "isolated";
58	const size_t DOMFileSystemBase::isolatedPathPrefixLength = sizeof(DOMFileSystemBase::isolatedPathPrefix) - 1;	58	const size_t DOMFileSystemBase::isolatedPathPrefixLength = sizeof(DOMFileSystemBase::isolatedPathPrefix) - 1;
59		59
60	DOMFileSystemBase::DOMFileSystemBase(ScriptExecutionContext* context, const String& name, FileSystemType type, const KURL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)	60	DOMFileSystemBase::DOMFileSystemBase(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
61	: m_context(context)	61	: m_context(context)
62	, m_name(name)	62	, m_name(name)
63	, m_type(type)	63	, m_type(type)
Lines 79-85 bool DOMFileSystemBase::isValidType(FileSystemType type) a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.cpp_sec2
79	}	79	}
80		80
81	// static	81	// static
82	bool DOMFileSystemBase::crackFileSystemURL(const KURL& url, FileSystemType& type, String& filePath)	82	bool DOMFileSystemBase::crackFileSystemURL(const URL& url, FileSystemType& type, String& filePath)
83	{	83	{
84	if (!url.protocolIs("filesystem"))	84	if (!url.protocolIs("filesystem"))
85	return false;	85	return false;
Lines 105-114 bool DOMFileSystemBase::supportsToURL() const a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.cpp_sec3
105	return true;	105	return true;
106	}	106	}
107		107
108	KURL DOMFileSystemBase::createFileSystemURL(const String& fullPath) const	108	URL DOMFileSystemBase::createFileSystemURL(const String& fullPath) const
109	{	109	{
110	ASSERT(DOMFilePath::isAbsolute(fullPath));	110	ASSERT(DOMFilePath::isAbsolute(fullPath));
111	KURL url = m_filesystemRootURL;	111	URL url = m_filesystemRootURL;
112	// Remove the extra leading slash.	112	// Remove the extra leading slash.
113	url.setPath(url.path() + encodeWithURLEscapeSequences(fullPath.substring(1)));	113	url.setPath(url.path() + encodeWithURLEscapeSequences(fullPath.substring(1)));
114	return url;	114	return url;
Lines 120-126 SecurityOrigin* DOMFileSystemBase::securityOrigin() const a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.cpp_sec4
120	return m_context->securityOrigin();	120	return m_context->securityOrigin();
121	}	121	}
122		122
123	KURL DOMFileSystemBase::createFileSystemURL(const EntryBase* entry) const	123	URL DOMFileSystemBase::createFileSystemURL(const EntryBase* entry) const
124	{	124	{
125	return createFileSystemURL(entry->fullPath());	125	return createFileSystemURL(entry->fullPath());
126	}	126	}

Lines 36-42 a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.h_sec1
- a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.h -8 / +8 lines
36	#include "AsyncFileSystem.h"	36	#include "AsyncFileSystem.h"
37	#include "FileSystemFlags.h"	37	#include "FileSystemFlags.h"
38	#include "FileSystemType.h"	38	#include "FileSystemType.h"
39	#include "KURL.h"	39	#include "URL.h"
40	#include <wtf/PassRefPtr.h>	40	#include <wtf/PassRefPtr.h>
41	#include <wtf/RefCounted.h>	41	#include <wtf/RefCounted.h>
42	#include <wtf/text/WTFString.h>	42	#include <wtf/text/WTFString.h>
Lines 66-72 public: a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.h_sec2
66	static const char isolatedPathPrefix[];	66	static const char isolatedPathPrefix[];
67	static const size_t isolatedPathPrefixLength;	67	static const size_t isolatedPathPrefixLength;
68		68
69	static PassRefPtr<DOMFileSystemBase> create(ScriptExecutionContext* context, const String& name, FileSystemType type, const KURL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)	69	static PassRefPtr<DOMFileSystemBase> create(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
70	{	70	{
71	return adoptRef(new DOMFileSystemBase(context, name, type, rootURL, asyncFileSystem));	71	return adoptRef(new DOMFileSystemBase(context, name, type, rootURL, asyncFileSystem));
72	}	72	}
Lines 74-80 public: a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.h_sec3
74		74
75	const String& name() const { return m_name; }	75	const String& name() const { return m_name; }
76	FileSystemType type() const { return m_type; }	76	FileSystemType type() const { return m_type; }
77	KURL rootURL() const { return m_filesystemRootURL; }	77	URL rootURL() const { return m_filesystemRootURL; }
78	AsyncFileSystem* asyncFileSystem() const { return m_asyncFileSystem.get(); }	78	AsyncFileSystem* asyncFileSystem() const { return m_asyncFileSystem.get(); }
79	SecurityOrigin* securityOrigin() const;	79	SecurityOrigin* securityOrigin() const;
80		80
Lines 85-94 public: a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.h_sec4
85	bool clonable() const { return m_clonable; }	85	bool clonable() const { return m_clonable; }
86		86
87	static bool isValidType(FileSystemType);	87	static bool isValidType(FileSystemType);
88	static bool crackFileSystemURL(const KURL&, FileSystemType&, String& filePath);	88	static bool crackFileSystemURL(const URL&, FileSystemType&, String& filePath);
89	bool supportsToURL() const;	89	bool supportsToURL() const;
90	KURL createFileSystemURL(const EntryBase*) const;	90	URL createFileSystemURL(const EntryBase*) const;
91	KURL createFileSystemURL(const String& fullPath) const;	91	URL createFileSystemURL(const String& fullPath) const;
92		92
93	// Actual FileSystem API implementations. All the validity checks on virtual paths are done at this level.	93	// Actual FileSystem API implementations. All the validity checks on virtual paths are done at this level.
94	// They return false for immediate errors that don't involve lower AsyncFileSystem layer (e.g. for name validation errors). Otherwise they return true (but later may call back with an runtime error).	94	// They return false for immediate errors that don't involve lower AsyncFileSystem layer (e.g. for name validation errors). Otherwise they return true (but later may call back with an runtime error).
Lines 103-115 public: a/Source/WebCore/Modules/filesystem/DOMFileSystemBase.h_sec5
103	bool readDirectory(PassRefPtr<DirectoryReaderBase>, const String& path, PassRefPtr<EntriesCallback>, PassRefPtr<ErrorCallback>);	103	bool readDirectory(PassRefPtr<DirectoryReaderBase>, const String& path, PassRefPtr<EntriesCallback>, PassRefPtr<ErrorCallback>);
104		104
105	protected:	105	protected:
106	DOMFileSystemBase(ScriptExecutionContext*, const String& name, FileSystemType, const KURL& rootURL, PassOwnPtr<AsyncFileSystem>);	106	DOMFileSystemBase(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
107	friend class DOMFileSystemSync;	107	friend class DOMFileSystemSync;
108		108
109	ScriptExecutionContext* m_context;	109	ScriptExecutionContext* m_context;
110	String m_name;	110	String m_name;
111	FileSystemType m_type;	111	FileSystemType m_type;
112	KURL m_filesystemRootURL;	112	URL m_filesystemRootURL;
113	bool m_clonable;	113	bool m_clonable;
114		114
115	mutable OwnPtr<AsyncFileSystem> m_asyncFileSystem;	115	mutable OwnPtr<AsyncFileSystem> m_asyncFileSystem;

Lines 56-62 PassRefPtr<DOMFileSystemSync> DOMFileSystemSync::create(DOMFileSystemBase* fileS a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.cpp_sec1
- a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.cpp -5 / +5 lines
56	return adoptRef(new DOMFileSystemSync(fileSystem->m_context, fileSystem->name(), fileSystem->type(), fileSystem->rootURL(), fileSystem->m_asyncFileSystem.release()));	56	return adoptRef(new DOMFileSystemSync(fileSystem->m_context, fileSystem->name(), fileSystem->type(), fileSystem->rootURL(), fileSystem->m_asyncFileSystem.release()));
57	}	57	}
58		58
59	DOMFileSystemSync::DOMFileSystemSync(ScriptExecutionContext* context, const String& name, FileSystemType type, const KURL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)	59	DOMFileSystemSync::DOMFileSystemSync(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
60	: DOMFileSystemBase(context, name, type, rootURL, asyncFileSystem)	60	: DOMFileSystemBase(context, name, type, rootURL, asyncFileSystem)
61	{	61	{
62	}	62	}
Lines 98-104 public: a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.cpp_sec2
98	friend class WTF::RefCounted<CreateFileResult>;	98	friend class WTF::RefCounted<CreateFileResult>;
99	};	99	};
100		100
101	static PassOwnPtr<CreateFileHelper> create(PassRefPtr<CreateFileResult> result, const String& name, const KURL& url, FileSystemType type)	101	static PassOwnPtr<CreateFileHelper> create(PassRefPtr<CreateFileResult> result, const String& name, const URL& url, FileSystemType type)
102	{	102	{
103	return adoptPtr(new CreateFileHelper(result, name, url, type));	103	return adoptPtr(new CreateFileHelper(result, name, url, type));
104	}	104	}
Lines 136-142 public: a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.cpp_sec3
136	}	136	}
137	}	137	}
138	private:	138	private:
139	CreateFileHelper(PassRefPtr<CreateFileResult> result, const String& name, const KURL& url, FileSystemType type)	139	CreateFileHelper(PassRefPtr<CreateFileResult> result, const String& name, const URL& url, FileSystemType type)
140	: m_result(result)	140	: m_result(result)
141	, m_name(name)	141	, m_name(name)
142	, m_url(url)	142	, m_url(url)
Lines 146-152 private: a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.cpp_sec4
146		146
147	RefPtr<CreateFileResult> m_result;	147	RefPtr<CreateFileResult> m_result;
148	String m_name;	148	String m_name;
149	KURL m_url;	149	URL m_url;
150	FileSystemType m_type;	150	FileSystemType m_type;
151	};	151	};
152		152
Lines 155-161 private: a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.cpp_sec5
155	PassRefPtr<File> DOMFileSystemSync::createFile(const FileEntrySync* fileEntry, ExceptionCode& ec)	155	PassRefPtr<File> DOMFileSystemSync::createFile(const FileEntrySync* fileEntry, ExceptionCode& ec)
156	{	156	{
157	ec = 0;	157	ec = 0;
158	KURL fileSystemURL = createFileSystemURL(fileEntry);	158	URL fileSystemURL = createFileSystemURL(fileEntry);
159	RefPtr<CreateFileHelper::CreateFileResult> result(CreateFileHelper::CreateFileResult::create());	159	RefPtr<CreateFileHelper::CreateFileResult> result(CreateFileHelper::CreateFileResult::create());
160	m_asyncFileSystem->createSnapshotFileAndReadMetadata(fileSystemURL, CreateFileHelper::create(result, fileEntry->name(), fileSystemURL, type()));	160	m_asyncFileSystem->createSnapshotFileAndReadMetadata(fileSystemURL, CreateFileHelper::create(result, fileEntry->name(), fileSystemURL, type()));
161	if (!m_asyncFileSystem->waitForOperationToComplete()) {	161	if (!m_asyncFileSystem->waitForOperationToComplete()) {

Lines 46-52 typedef int ExceptionCode; a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.h_sec1
- a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.h -2 / +2 lines
46		46
47	class DOMFileSystemSync : public DOMFileSystemBase {	47	class DOMFileSystemSync : public DOMFileSystemBase {
48	public:	48	public:
49	static PassRefPtr<DOMFileSystemSync> create(ScriptExecutionContext* context, const String& name, FileSystemType type, const KURL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)	49	static PassRefPtr<DOMFileSystemSync> create(ScriptExecutionContext* context, const String& name, FileSystemType type, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
50	{	50	{
51	return adoptRef(new DOMFileSystemSync(context, name, type, rootURL, asyncFileSystem));	51	return adoptRef(new DOMFileSystemSync(context, name, type, rootURL, asyncFileSystem));
52	}	52	}
Lines 61-67 public: a/Source/WebCore/Modules/filesystem/DOMFileSystemSync.h_sec2
61	PassRefPtr<FileWriterSync> createWriter(const FileEntrySync*, ExceptionCode&);	61	PassRefPtr<FileWriterSync> createWriter(const FileEntrySync*, ExceptionCode&);
62		62
63	private:	63	private:
64	DOMFileSystemSync(ScriptExecutionContext*, const String& name, FileSystemType, const KURL& rootURL, PassOwnPtr<AsyncFileSystem>);	64	DOMFileSystemSync(ScriptExecutionContext*, const String& name, FileSystemType, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
65	};	65	};
66		66
67	}	67	}

Lines 147-153 FileSystemCallbacks::FileSystemCallbacks(PassRefPtr<FileSystemCallback> successC a/Source/WebCore/Modules/filesystem/FileSystemCallbacks.cpp_sec1
- a/Source/WebCore/Modules/filesystem/FileSystemCallbacks.cpp -2 / +2 lines
147	{	147	{
148	}	148	}
149		149
150	void FileSystemCallbacks::didOpenFileSystem(const String& name, const KURL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)	150	void FileSystemCallbacks::didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
151	{	151	{
152	if (m_successCallback) {	152	if (m_successCallback) {
153	ASSERT(asyncFileSystem);	153	ASSERT(asyncFileSystem);
Lines 211-217 ResolveURICallbacks::ResolveURICallbacks(PassRefPtr<EntryCallback> successCallba a/Source/WebCore/Modules/filesystem/FileSystemCallbacks.cpp_sec2
211	{	211	{
212	}	212	}
213		213
214	void ResolveURICallbacks::didOpenFileSystem(const String& name, const KURL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)	214	void ResolveURICallbacks::didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem> asyncFileSystem)
215	{	215	{
216	ASSERT(asyncFileSystem);	216	ASSERT(asyncFileSystem);
217	RefPtr<DirectoryEntry> root = DOMFileSystem::create(m_scriptExecutionContext.get(), name, m_type, rootURL, asyncFileSystem)->root();	217	RefPtr<DirectoryEntry> root = DOMFileSystem::create(m_scriptExecutionContext.get(), name, m_type, rootURL, asyncFileSystem)->root();

Lines 102-108 private: a/Source/WebCore/Modules/filesystem/FileSystemCallbacks.h_sec1
- a/Source/WebCore/Modules/filesystem/FileSystemCallbacks.h -2 / +2 lines
102	class FileSystemCallbacks : public FileSystemCallbacksBase {	102	class FileSystemCallbacks : public FileSystemCallbacksBase {
103	public:	103	public:
104	static PassOwnPtr<FileSystemCallbacks> create(PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType);	104	static PassOwnPtr<FileSystemCallbacks> create(PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType);
105	virtual void didOpenFileSystem(const String& name, const KURL& rootURL, PassOwnPtr<AsyncFileSystem>);	105	virtual void didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
106		106
107	private:	107	private:
108	FileSystemCallbacks(PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType);	108	FileSystemCallbacks(PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType);
Lines 114-120 private: a/Source/WebCore/Modules/filesystem/FileSystemCallbacks.h_sec2
114	class ResolveURICallbacks : public FileSystemCallbacksBase {	114	class ResolveURICallbacks : public FileSystemCallbacksBase {
115	public:	115	public:
116	static PassOwnPtr<ResolveURICallbacks> create(PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType, const String& filePath);	116	static PassOwnPtr<ResolveURICallbacks> create(PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType, const String& filePath);
117	virtual void didOpenFileSystem(const String& name, const KURL& rootURL, PassOwnPtr<AsyncFileSystem>);	117	virtual void didOpenFileSystem(const String& name, const URL& rootURL, PassOwnPtr<AsyncFileSystem>);
118		118
119	private:	119	private:
120	ResolveURICallbacks(PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType, const String& filePath);	120	ResolveURICallbacks(PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>, ScriptExecutionContext*, FileSystemType, const String& filePath);

Lines 87-93 PassRefPtr<DOMFileSystemSync> WorkerGlobalScopeFileSystem::webkitRequestFileSyst a/Source/WebCore/Modules/filesystem/WorkerGlobalScopeFileSystem.cpp_sec1
- a/Source/WebCore/Modules/filesystem/WorkerGlobalScopeFileSystem.cpp -2 / +2 lines
87		87
88	void WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemURL(WorkerGlobalScope* worker, const String& url, PassRefPtr<EntryCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)	88	void WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemURL(WorkerGlobalScope* worker, const String& url, PassRefPtr<EntryCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
89	{	89	{
90	KURL completedURL = worker->completeURL(url);	90	URL completedURL = worker->completeURL(url);
91	ScriptExecutionContext* secureContext = worker->scriptExecutionContext();	91	ScriptExecutionContext* secureContext = worker->scriptExecutionContext();
92	if (!AsyncFileSystem::isAvailable() \|\| !secureContext->securityOrigin()->canAccessFileSystem() \|\| !secureContext->securityOrigin()->canRequest(completedURL)) {	92	if (!AsyncFileSystem::isAvailable() \|\| !secureContext->securityOrigin()->canAccessFileSystem() \|\| !secureContext->securityOrigin()->canRequest(completedURL)) {
93	DOMFileSystem::scheduleCallback(worker, errorCallback, FileError::create(FileError::SECURITY_ERR));	93	DOMFileSystem::scheduleCallback(worker, errorCallback, FileError::create(FileError::SECURITY_ERR));
Lines 107-113 void WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemURL(WorkerGlobalSc a/Source/WebCore/Modules/filesystem/WorkerGlobalScopeFileSystem.cpp_sec2
107	PassRefPtr<EntrySync> WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemSyncURL(WorkerGlobalScope* worker, const String& url, ExceptionCode& ec)	107	PassRefPtr<EntrySync> WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemSyncURL(WorkerGlobalScope* worker, const String& url, ExceptionCode& ec)
108	{	108	{
109	ec = 0;	109	ec = 0;
110	KURL completedURL = worker->completeURL(url);	110	URL completedURL = worker->completeURL(url);
111	ScriptExecutionContext* secureContext = worker->scriptExecutionContext();	111	ScriptExecutionContext* secureContext = worker->scriptExecutionContext();
112	if (!AsyncFileSystem::isAvailable() \|\| !secureContext->securityOrigin()->canAccessFileSystem() \|\| !secureContext->securityOrigin()->canRequest(completedURL)) {	112	if (!AsyncFileSystem::isAvailable() \|\| !secureContext->securityOrigin()->canAccessFileSystem() \|\| !secureContext->securityOrigin()->canRequest(completedURL)) {
113	ec = FileException::SECURITY_ERR;	113	ec = FileException::SECURITY_ERR;

Lines 33-40 a/Source/WebCore/Modules/mediasource/MediaSourceRegistry.cpp_sec1
- a/Source/WebCore/Modules/mediasource/MediaSourceRegistry.cpp -3 / +3 lines
33		33
34	#if ENABLE(MEDIA_SOURCE)	34	#if ENABLE(MEDIA_SOURCE)
35		35
36	#include "KURL.h"
37	#include "MediaSourceBase.h"	36	#include "MediaSourceBase.h"
		37	#include "URL.h"
38	#include <wtf/MainThread.h>	38	#include <wtf/MainThread.h>
39		39
40	namespace WebCore {	40	namespace WebCore {
Lines 46-52 MediaSourceRegistry& MediaSourceRegistry::registry() a/Source/WebCore/Modules/mediasource/MediaSourceRegistry.cpp_sec2
46	return instance;	46	return instance;
47	}	47	}
48		48
49	void MediaSourceRegistry::registerURL(SecurityOrigin, const KURL& url, URLRegistrable registrable)	49	void MediaSourceRegistry::registerURL(SecurityOrigin, const URL& url, URLRegistrable registrable)
50	{	50	{
51	ASSERT(&registrable->registry() == this);	51	ASSERT(&registrable->registry() == this);
52	ASSERT(isMainThread());	52	ASSERT(isMainThread());
Lines 56-62 void MediaSourceRegistry::registerURL(SecurityOrigin*, const KURL& url, URLRegis a/Source/WebCore/Modules/mediasource/MediaSourceRegistry.cpp_sec3
56	m_mediaSources.set(url.string(), source);	56	m_mediaSources.set(url.string(), source);
57	}	57	}
58		58
59	void MediaSourceRegistry::unregisterURL(const KURL& url)	59	void MediaSourceRegistry::unregisterURL(const URL& url)
60	{	60	{
61	ASSERT(isMainThread());	61	ASSERT(isMainThread());
62	HashMap<String, RefPtr<MediaSourceBase> >::iterator iter = m_mediaSources.find(url.string());	62	HashMap<String, RefPtr<MediaSourceBase> >::iterator iter = m_mediaSources.find(url.string());

Lines 27-33 a/Source/WebCore/Modules/mediastream/MediaStreamRegistry.cpp_sec1
- a/Source/WebCore/Modules/mediastream/MediaStreamRegistry.cpp -3 / +3 lines
27		27
28	#if ENABLE(MEDIA_STREAM)	28	#if ENABLE(MEDIA_STREAM)
29		29
30	#include "KURL.h"	30	#include "URL.h"
31	#include "MediaStream.h"	31	#include "MediaStream.h"
32	#include <wtf/MainThread.h>	32	#include <wtf/MainThread.h>
33		33
Lines 41-54 MediaStreamRegistry& MediaStreamRegistry::registry() a/Source/WebCore/Modules/mediastream/MediaStreamRegistry.cpp_sec2
41	return instance;	41	return instance;
42	}	42	}
43		43
44	void MediaStreamRegistry::registerURL(SecurityOrigin, const KURL& url, URLRegistrable stream)	44	void MediaStreamRegistry::registerURL(SecurityOrigin, const URL& url, URLRegistrable stream)
45	{	45	{
46	ASSERT(&stream->registry() == this);	46	ASSERT(&stream->registry() == this);
47	ASSERT(isMainThread());	47	ASSERT(isMainThread());
48	m_streamDescriptors.set(url.string(), static_cast<MediaStream*>(stream)->descriptor());	48	m_streamDescriptors.set(url.string(), static_cast<MediaStream*>(stream)->descriptor());
49	}	49	}
50		50
51	void MediaStreamRegistry::unregisterURL(const KURL& url)	51	void MediaStreamRegistry::unregisterURL(const URL& url)
52	{	52	{
53	ASSERT(isMainThread());	53	ASSERT(isMainThread());
54	m_streamDescriptors.remove(url.string());	54	m_streamDescriptors.remove(url.string());

Lines 86-93 static bool verifyCustomHandlerURL(const String& baseURL, const String& url, Exc a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.cpp_sec1
- a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.cpp -2 / +2 lines
86	String newURL = url;	86	String newURL = url;
87	newURL.remove(index, WTF_ARRAY_LENGTH(token) - 1);	87	newURL.remove(index, WTF_ARRAY_LENGTH(token) - 1);
88		88
89	KURL base(ParsedURLString, baseURL);	89	URL base(ParsedURLString, baseURL);
90	KURL kurl(base, newURL);	90	URL kurl(base, newURL);
91		91
92	if (kurl.isEmpty() \|\| !kurl.isValid()) {	92	if (kurl.isEmpty() \|\| !kurl.isValid()) {
93	ec = SYNTAX_ERR;	93	ec = SYNTAX_ERR;

Lines 35-41 a/Source/WebCore/Modules/notifications/Notification.h_sec1
- a/Source/WebCore/Modules/notifications/Notification.h -4 / +4 lines
35	#include "ActiveDOMObject.h"	35	#include "ActiveDOMObject.h"
36	#include "EventNames.h"	36	#include "EventNames.h"
37	#include "EventTarget.h"	37	#include "EventTarget.h"
38	#include "KURL.h"	38	#include "URL.h"
39	#include "NotificationClient.h"	39	#include "NotificationClient.h"
40	#include "SharedBuffer.h"	40	#include "SharedBuffer.h"
41	#include "TextDirection.h"	41	#include "TextDirection.h"
Lines 83-90 public: a/Source/WebCore/Modules/notifications/Notification.h_sec2
83	#endif	83	#endif
84	void close();	84	void close();
85		85
86	KURL iconURL() const { return m_icon; }	86	URL iconURL() const { return m_icon; }
87	void setIconURL(const KURL& url) { m_icon = url; }	87	void setIconURL(const URL& url) { m_icon = url; }
88		88
89	String title() const { return m_title; }	89	String title() const { return m_title; }
90	String body() const { return m_body; }	90	String body() const { return m_body; }
Lines 164-170 private: a/Source/WebCore/Modules/notifications/Notification.h_sec3
164	#endif	164	#endif
165		165
166	// Text notifications.	166	// Text notifications.
167	KURL m_icon;	167	URL m_icon;
168	String m_title;	168	String m_title;
169	String m_body;	169	String m_body;
170	String m_direction;	170	String m_direction;

Lines 38-44 PassRefPtr<SpeechGrammar> SpeechGrammar::create() a/Source/WebCore/Modules/speech/SpeechGrammar.cpp_sec1
- a/Source/WebCore/Modules/speech/SpeechGrammar.cpp -2 / +2 lines
38	return adoptRef(new SpeechGrammar);	38	return adoptRef(new SpeechGrammar);
39	}	39	}
40		40
41	PassRefPtr<SpeechGrammar> SpeechGrammar::create(const KURL& src, double weight)	41	PassRefPtr<SpeechGrammar> SpeechGrammar::create(const URL& src, double weight)
42	{	42	{
43	return adoptRef(new SpeechGrammar(src, weight));	43	return adoptRef(new SpeechGrammar(src, weight));
44	}	44	}
Lines 54-60 SpeechGrammar::SpeechGrammar() a/Source/WebCore/Modules/speech/SpeechGrammar.cpp_sec2
54	{	54	{
55	}	55	}
56		56
57	SpeechGrammar::SpeechGrammar(const KURL& src, double weight)	57	SpeechGrammar::SpeechGrammar(const URL& src, double weight)
58	: m_src(src)	58	: m_src(src)
59	, m_weight(weight)	59	, m_weight(weight)
60	{	60	{

Lines 28-34 a/Source/WebCore/Modules/speech/SpeechGrammar.h_sec1
- a/Source/WebCore/Modules/speech/SpeechGrammar.h -6 / +6 lines
28		28
29	#if ENABLE(SCRIPTED_SPEECH)	29	#if ENABLE(SCRIPTED_SPEECH)
30		30
31	#include "KURL.h"	31	#include "URL.h"
32	#include <wtf/RefCounted.h>	32	#include <wtf/RefCounted.h>
33	#include <wtf/text/WTFString.h>	33	#include <wtf/text/WTFString.h>
34		34
Lines 39-48 class ScriptExecutionContext; a/Source/WebCore/Modules/speech/SpeechGrammar.h_sec2
39	class SpeechGrammar : public RefCounted<SpeechGrammar> {	39	class SpeechGrammar : public RefCounted<SpeechGrammar> {
40	public:	40	public:
41	static PassRefPtr<SpeechGrammar> create(); // FIXME: The spec is not clear on what the constructor should look like.	41	static PassRefPtr<SpeechGrammar> create(); // FIXME: The spec is not clear on what the constructor should look like.
42	static PassRefPtr<SpeechGrammar> create(const KURL& src, double weight);	42	static PassRefPtr<SpeechGrammar> create(const URL& src, double weight);
43		43
44	const KURL& src(ScriptExecutionContext*) const { return m_src; }	44	const URL& src(ScriptExecutionContext*) const { return m_src; }
45	const KURL& src() const { return m_src; }	45	const URL& src() const { return m_src; }
46	void setSrc(ScriptExecutionContext*, const String& src);	46	void setSrc(ScriptExecutionContext*, const String& src);
47		47
48	double weight() const { return m_weight; }	48	double weight() const { return m_weight; }
Lines 50-58 public: a/Source/WebCore/Modules/speech/SpeechGrammar.h_sec3
50		50
51	private:	51	private:
52	SpeechGrammar();	52	SpeechGrammar();
53	SpeechGrammar(const KURL& src, double weight);	53	SpeechGrammar(const URL& src, double weight);
54		54
55	KURL m_src;	55	URL m_src;
56	double m_weight;	56	double m_weight;
57	};	57	};
58		58

Lines 45-51 class ArrayBufferView; a/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.h_sec1
- a/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.h -2 / +2 lines
45	namespace WebCore {	45	namespace WebCore {
46		46
47	class Blob;	47	class Blob;
48	class KURL;	48	class URL;
49	class ScriptExecutionContext;	49	class ScriptExecutionContext;
50	class WebSocketChannelClient;	50	class WebSocketChannelClient;
51		51
Lines 61-67 public: a/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.h_sec2
61	InvalidMessage	61	InvalidMessage
62	};	62	};
63		63
64	virtual void connect(const KURL&, const String& protocol) = 0;	64	virtual void connect(const URL&, const String& protocol) = 0;
65	virtual String subprotocol() = 0; // Will be available after didConnect() callback is invoked.	65	virtual String subprotocol() = 0; // Will be available after didConnect() callback is invoked.
66	virtual String extensions() = 0; // Will be available after didConnect() callback is invoked.	66	virtual String extensions() = 0; // Will be available after didConnect() callback is invoked.
67	virtual SendResult send(const String& message) = 0;	67	virtual SendResult send(const String& message) = 0;

Lines 213-219 void WebSocket::connect(const String& url, const String& protocol, ExceptionCode a/Source/WebCore/Modules/websockets/WebSocket.cpp_sec1
- a/Source/WebCore/Modules/websockets/WebSocket.cpp -2 / +2 lines
213	void WebSocket::connect(const String& url, const Vector<String>& protocols, ExceptionCode& ec)	213	void WebSocket::connect(const String& url, const Vector<String>& protocols, ExceptionCode& ec)
214	{	214	{
215	LOG(Network, "WebSocket %p connect() url='%s'", this, url.utf8().data());	215	LOG(Network, "WebSocket %p connect() url='%s'", this, url.utf8().data());
216	m_url = KURL(KURL(), url);	216	m_url = URL(URL(), url);
217		217
218	if (!m_url.isValid()) {	218	if (!m_url.isValid()) {
219	scriptExecutionContext()->addConsoleMessage(JSMessageSource, ErrorMessageLevel, "Invalid url for WebSocket " + m_url.stringCenterEllipsizedToLength());	219	scriptExecutionContext()->addConsoleMessage(JSMessageSource, ErrorMessageLevel, "Invalid url for WebSocket " + m_url.stringCenterEllipsizedToLength());
Lines 398-404 void WebSocket::close(int code, const String& reason, ExceptionCode& ec) a/Source/WebCore/Modules/websockets/WebSocket.cpp_sec2
398	m_channel->close(code, reason);	398	m_channel->close(code, reason);
399	}	399	}
400		400
401	const KURL& WebSocket::url() const	401	const URL& WebSocket::url() const
402	{	402	{
403	return m_url;	403	return m_url;
404	}	404	}

Lines 37-43 a/Source/WebCore/Modules/websockets/WebSocket.h_sec1
- a/Source/WebCore/Modules/websockets/WebSocket.h -3 / +3 lines
37	#include "EventListener.h"	37	#include "EventListener.h"
38	#include "EventNames.h"	38	#include "EventNames.h"
39	#include "EventTarget.h"	39	#include "EventTarget.h"
40	#include "KURL.h"	40	#include "URL.h"
41	#include "WebSocketChannel.h"	41	#include "WebSocketChannel.h"
42	#include "WebSocketChannelClient.h"	42	#include "WebSocketChannelClient.h"
43	#include <wtf/Forward.h>	43	#include <wtf/Forward.h>
Lines 82-88 public: a/Source/WebCore/Modules/websockets/WebSocket.h_sec2
82	void close(ExceptionCode& ec) { close(WebSocketChannel::CloseEventCodeNotSpecified, String(), ec); }	82	void close(ExceptionCode& ec) { close(WebSocketChannel::CloseEventCodeNotSpecified, String(), ec); }
83	void close(int code, ExceptionCode& ec) { close(code, String(), ec); }	83	void close(int code, ExceptionCode& ec) { close(code, String(), ec); }
84		84
85	const KURL& url() const;	85	const URL& url() const;
86	State readyState() const;	86	State readyState() const;
87	unsigned long bufferedAmount() const;	87	unsigned long bufferedAmount() const;
88		88
Lines 136-142 private: a/Source/WebCore/Modules/websockets/WebSocket.h_sec3
136	RefPtr<ThreadableWebSocketChannel> m_channel;	136	RefPtr<ThreadableWebSocketChannel> m_channel;
137		137
138	State m_state;	138	State m_state;
139	KURL m_url;	139	URL m_url;
140	unsigned long m_bufferedAmount;	140	unsigned long m_bufferedAmount;
141	unsigned long m_bufferedAmountAfterClose;	141	unsigned long m_bufferedAmountAfterClose;
142	BinaryType m_binaryType;	142	BinaryType m_binaryType;

Lines 66-72 WorkerThreadableWebSocketChannel::~WorkerThreadableWebSocketChannel() a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp_sec1
- a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp -5 / +5 lines
66	m_bridge->disconnect();	66	m_bridge->disconnect();
67	}	67	}
68		68
69	void WorkerThreadableWebSocketChannel::connect(const KURL& url, const String& protocol)	69	void WorkerThreadableWebSocketChannel::connect(const URL& url, const String& protocol)
70	{	70	{
71	if (m_bridge)	71	if (m_bridge)
72	m_bridge->connect(url, protocol);	72	m_bridge->connect(url, protocol);
Lines 160-166 WorkerThreadableWebSocketChannel::Peer::~Peer() a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp_sec2
160	m_mainWebSocketChannel->disconnect();	160	m_mainWebSocketChannel->disconnect();
161	}	161	}
162		162
163	void WorkerThreadableWebSocketChannel::Peer::connect(const KURL& url, const String& protocol)	163	void WorkerThreadableWebSocketChannel::Peer::connect(const URL& url, const String& protocol)
164	{	164	{
165	ASSERT(isMainThread());	165	ASSERT(isMainThread());
166	if (!m_mainWebSocketChannel)	166	if (!m_mainWebSocketChannel)
Lines 428-434 void WorkerThreadableWebSocketChannel::Bridge::initialize() a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp_sec3
428	m_workerClientWrapper->setFailedWebSocketChannelCreation();	428	m_workerClientWrapper->setFailedWebSocketChannelCreation();
429	}	429	}
430		430
431	void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* context, Peer* peer, const KURL& url, const String& protocol)	431	void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* context, Peer* peer, const URL& url, const String& protocol)
432	{	432	{
433	ASSERT(isMainThread());	433	ASSERT(isMainThread());
434	ASSERT_UNUSED(context, context->isDocument());	434	ASSERT_UNUSED(context, context->isDocument());
Lines 437-443 void WorkerThreadableWebSocketChannel::mainThreadConnect(ScriptExecutionContext* a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp_sec4
437	peer->connect(url, protocol);	437	peer->connect(url, protocol);
438	}	438	}
439		439
440	void WorkerThreadableWebSocketChannel::Bridge::connect(const KURL& url, const String& protocol)	440	void WorkerThreadableWebSocketChannel::Bridge::connect(const URL& url, const String& protocol)
441	{	441	{
442	ASSERT(m_workerClientWrapper);	442	ASSERT(m_workerClientWrapper);
443	if (!m_peer)	443	if (!m_peer)
Lines 464-470 void WorkerThreadableWebSocketChannel::mainThreadSendArrayBuffer(ScriptExecution a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp_sec5
464	peer->send(*arrayBuffer);	464	peer->send(*arrayBuffer);
465	}	465	}
466		466
467	void WorkerThreadableWebSocketChannel::mainThreadSendBlob(ScriptExecutionContext* context, Peer* peer, const KURL& url, const String& type, long long size)	467	void WorkerThreadableWebSocketChannel::mainThreadSendBlob(ScriptExecutionContext* context, Peer* peer, const URL& url, const String& type, long long size)
468	{	468	{
469	ASSERT(isMainThread());	469	ASSERT(isMainThread());
470	ASSERT_UNUSED(context, context->isDocument());	470	ASSERT_UNUSED(context, context->isDocument());

Lines 7420-7426 a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj_sec1
- a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj -4 / +4 lines
7420	</ClCompile>	7420	</ClCompile>
7421	<ClCompile Include="..\platform\HistogramSupport.cpp" />	7421	<ClCompile Include="..\platform\HistogramSupport.cpp" />
7422	<ClCompile Include="..\platform\KillRingNone.cpp" />	7422	<ClCompile Include="..\platform\KillRingNone.cpp" />
7423	<ClCompile Include="..\platform\KURL.cpp" />	7423	<ClCompile Include="..\platform\URL.cpp" />
7424	<ClCompile Include="..\platform\Language.cpp" />	7424	<ClCompile Include="..\platform\Language.cpp" />
7425	<ClCompile Include="..\platform\Length.cpp" />	7425	<ClCompile Include="..\platform\Length.cpp" />
7426	<ClCompile Include="..\platform\LengthBox.cpp" />	7426	<ClCompile Include="..\platform\LengthBox.cpp" />
Lines 7604-7610 a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj_sec2
7604	<ClCompile Include="..\platform\win\WindowMessageBroadcaster.cpp" />	7604	<ClCompile Include="..\platform\win\WindowMessageBroadcaster.cpp" />
7605	<ClCompile Include="..\platform\cf\CFURLExtras.cpp" />	7605	<ClCompile Include="..\platform\cf\CFURLExtras.cpp" />
7606	<ClCompile Include="..\platform\cf\FileSystemCF.cpp" />	7606	<ClCompile Include="..\platform\cf\FileSystemCF.cpp" />
7607	<ClCompile Include="..\platform\cf\KURLCFNet.cpp" />	7607	<ClCompile Include="..\platform\cf\URLCF.cpp" />
7608	<ClCompile Include="..\platform\cf\SharedBufferCF.cpp" />	7608	<ClCompile Include="..\platform\cf\SharedBufferCF.cpp" />
7609	<ClCompile Include="..\platform\cf\win\CertificateCFWin.cpp" />	7609	<ClCompile Include="..\platform\cf\win\CertificateCFWin.cpp" />
7610	<ClCompile Include="..\platform\graphics\BitmapImage.cpp" />	7610	<ClCompile Include="..\platform\graphics\BitmapImage.cpp" />
Lines 19015-19022 a/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj_sec3
19015	<ClInclude Include="..\platform\HistogramSupport.h" />	19015	<ClInclude Include="..\platform\HistogramSupport.h" />
19016	<ClInclude Include="..\platform\HostWindow.h" />	19016	<ClInclude Include="..\platform\HostWindow.h" />
19017	<ClInclude Include="..\platform\KillRing.h" />	19017	<ClInclude Include="..\platform\KillRing.h" />
19018	<ClInclude Include="..\platform\KURL.h" />	19018	<ClInclude Include="..\platform\URL.h" />
19019	<ClInclude Include="..\platform\KURLHash.h" />	19019	<ClInclude Include="..\platform\URLHash.h" />
19020	<ClInclude Include="..\platform\Language.h" />	19020	<ClInclude Include="..\platform\Language.h" />
19021	<ClInclude Include="..\platform\LayoutUnit.h" />	19021	<ClInclude Include="..\platform\LayoutUnit.h" />
19022	<ClInclude Include="..\platform\Length.h" />	19022	<ClInclude Include="..\platform\Length.h" />

Lines 87-96 Element* AccessibilityImageMapLink::anchorElement() const a/Source/WebCore/accessibility/AccessibilityImageMapLink.cpp_sec1
- a/Source/WebCore/accessibility/AccessibilityImageMapLink.cpp -2 / +2 lines
87	return m_areaElement.get();	87	return m_areaElement.get();
88	}	88	}
89		89
90	KURL AccessibilityImageMapLink::url() const	90	URL AccessibilityImageMapLink::url() const
91	{	91	{
92	if (!m_areaElement.get())	92	if (!m_areaElement.get())
93	return KURL();	93	return URL();
94		94
95	return m_areaElement->href();	95	return m_areaElement->href();
96	}	96	}

Lines 21-27 a/Source/WebCore/bindings/gobject/ConvertToUTF8String.cpp_sec1
- a/Source/WebCore/bindings/gobject/ConvertToUTF8String.cpp -2 / +2 lines
21	#include "config.h"	21	#include "config.h"
22	#include "ConvertToUTF8String.h"	22	#include "ConvertToUTF8String.h"
23		23
24	#include "KURL.h"	24	#include "URL.h"
25	#include <wtf/text/CString.h>	25	#include <wtf/text/CString.h>
26	#include <wtf/text/WTFString.h>	26	#include <wtf/text/WTFString.h>
27		27
Lines 32-38 gchar* convertToUTF8String(WTF::String const& s) a/Source/WebCore/bindings/gobject/ConvertToUTF8String.cpp_sec2
32	return g_strdup(s.utf8().data());	32	return g_strdup(s.utf8().data());
33	}	33	}
34		34
35	gchar* convertToUTF8String(WebCore::KURL const& s)	35	gchar* convertToUTF8String(WebCore::URL const& s)
36	{	36	{
37	return g_strdup(s.string().utf8().data());	37	return g_strdup(s.string().utf8().data());
38	}	38	}

Lines 75-93 JSValue jsStringOrUndefined(ExecState* exec, const String& s) a/Source/WebCore/bindings/js/JSDOMBinding.cpp_sec1
- a/Source/WebCore/bindings/js/JSDOMBinding.cpp -3 / +3 lines
75	return jsStringWithCache(exec, s);	75	return jsStringWithCache(exec, s);
76	}	76	}
77		77
78	JSValue jsString(ExecState* exec, const KURL& url)	78	JSValue jsString(ExecState* exec, const URL& url)
79	{	79	{
80	return jsStringWithCache(exec, url.string());	80	return jsStringWithCache(exec, url.string());
81	}	81	}
82		82
83	JSValue jsStringOrNull(ExecState* exec, const KURL& url)	83	JSValue jsStringOrNull(ExecState* exec, const URL& url)
84	{	84	{
85	if (url.isNull())	85	if (url.isNull())
86	return jsNull();	86	return jsNull();
87	return jsStringWithCache(exec, url.string());	87	return jsStringWithCache(exec, url.string());
88	}	88	}
89		89
90	JSValue jsStringOrUndefined(ExecState* exec, const KURL& url)	90	JSValue jsStringOrUndefined(ExecState* exec, const URL& url)
91	{	91	{
92	if (url.isNull())	92	if (url.isNull())
93	return jsUndefined();	93	return jsUndefined();

Lines 34-40 a/Source/WebCore/bindings/js/ScriptSourceCode.h_sec1
- a/Source/WebCore/bindings/js/ScriptSourceCode.h -4 / +4 lines
34	#include "CachedResourceHandle.h"	34	#include "CachedResourceHandle.h"
35	#include "CachedScript.h"	35	#include "CachedScript.h"
36	#include "CachedScriptSourceProvider.h"	36	#include "CachedScriptSourceProvider.h"
37	#include "KURL.h"	37	#include "URL.h"
38	#include <parser/SourceProvider.h>	38	#include <parser/SourceProvider.h>
39	#include <wtf/text/TextPosition.h>	39	#include <wtf/text/TextPosition.h>
40	#include <wtf/RefPtr.h>	40	#include <wtf/RefPtr.h>
Lines 43-49 namespace WebCore { a/Source/WebCore/bindings/js/ScriptSourceCode.h_sec2
43		43
44	class ScriptSourceCode {	44	class ScriptSourceCode {
45	public:	45	public:
46	ScriptSourceCode(const String& source, const KURL& url = KURL(), const TextPosition& startPosition = TextPosition::minimumPosition())	46	ScriptSourceCode(const String& source, const URL& url = URL(), const TextPosition& startPosition = TextPosition::minimumPosition())
47	: m_provider(JSC::StringSourceProvider::create(source, url.isNull() ? String() : url.string(), startPosition))	47	: m_provider(JSC::StringSourceProvider::create(source, url.isNull() ? String() : url.string(), startPosition))
48	, m_code(m_provider, startPosition.m_line.oneBasedInt(), startPosition.m_column.oneBasedInt())	48	, m_code(m_provider, startPosition.m_line.oneBasedInt(), startPosition.m_column.oneBasedInt())
49	, m_url(url)	49	, m_url(url)
Lines 67-73 public: a/Source/WebCore/bindings/js/ScriptSourceCode.h_sec3
67		67
68	CachedScript* cachedScript() const { return m_cachedScript.get(); }	68	CachedScript* cachedScript() const { return m_cachedScript.get(); }
69		69
70	const KURL& url() const { return m_url; }	70	const URL& url() const { return m_url; }
71		71
72	private:	72	private:
73	RefPtr<JSC::SourceProvider> m_provider;	73	RefPtr<JSC::SourceProvider> m_provider;
Lines 76-82 private: a/Source/WebCore/bindings/js/ScriptSourceCode.h_sec4
76		76
77	CachedResourceHandle<CachedScript> m_cachedScript;	77	CachedResourceHandle<CachedScript> m_cachedScript;
78		78
79	KURL m_url;	79	URL m_url;
80		80
81	};	81	};
82		82

Lines 1383-1389 private: a/Source/WebCore/bindings/js/SerializedScriptValue.cpp_sec1
- a/Source/WebCore/bindings/js/SerializedScriptValue.cpp -2 / +2 lines
1383	if (!readStringData(type))	1383	if (!readStringData(type))
1384	return 0;	1384	return 0;
1385	if (m_isDOMGlobalObject)	1385	if (m_isDOMGlobalObject)
1386	file = File::create(path->string(), KURL(KURL(), url->string()), type->string());	1386	file = File::create(path->string(), URL(URL(), url->string()), type->string());
1387	return true;	1387	return true;
1388	}	1388	}
1389		1389
Lines 1577-1583 private: a/Source/WebCore/bindings/js/SerializedScriptValue.cpp_sec2
1577	return JSValue();	1577	return JSValue();
1578	if (!m_isDOMGlobalObject)	1578	if (!m_isDOMGlobalObject)
1579	return jsNull();	1579	return jsNull();
1580	return getJSValue(Blob::create(KURL(KURL(), url->string()), type->string(), size).get());	1580	return getJSValue(Blob::create(URL(URL(), url->string()), type->string(), size).get());
1581	}	1581	}
1582	case StringTag: {	1582	case StringTag: {
1583	CachedStringRef cachedString;	1583	CachedStringRef cachedString;

Lines 2501-2507 sub GenerateImplementation a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm_sec1
- a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm -2 / +2 lines
2501	push(@implContent, " ${className}* thisObj = jsCast<$className*>(asObject(slotBase));\n");	2501	push(@implContent, " ${className}* thisObj = jsCast<$className*>(asObject(slotBase));\n");
2502	push(@implContent, " ASSERT_GC_OBJECT_INHERITS(thisObj, info());\n");	2502	push(@implContent, " ASSERT_GC_OBJECT_INHERITS(thisObj, info());\n");
2503	if ($indexedGetterFunction->signature->type eq "DOMString") {	2503	if ($indexedGetterFunction->signature->type eq "DOMString") {
2504	$implIncludes{"KURL.h"} = 1;	2504	$implIncludes{"URL.h"} = 1;
2505	push(@implContent, " return jsStringOrUndefined(exec, thisObj->impl()->item(index));\n");	2505	push(@implContent, " return jsStringOrUndefined(exec, thisObj->impl()->item(index));\n");
2506	} else {	2506	} else {
2507	push(@implContent, " return toJS(exec, thisObj->globalObject(), thisObj->impl()->item(index));\n");	2507	push(@implContent, " return toJS(exec, thisObj->globalObject(), thisObj->impl()->item(index));\n");
Lines 3436-3442 sub NativeToJSValue a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm_sec2
3436	}	3436	}
3437		3437
3438	if ($codeGenerator->IsStringType($type)) {	3438	if ($codeGenerator->IsStringType($type)) {
3439	AddToImplIncludes("KURL.h", $conditional);	3439	AddToImplIncludes("URL.h", $conditional);
3440	my $conv = $signature->extendedAttributes->{"TreatReturnedNullStringAs"};	3440	my $conv = $signature->extendedAttributes->{"TreatReturnedNullStringAs"};
3441	if (defined $conv) {	3441	if (defined $conv) {
3442	return "jsStringOrNull(exec, $value)" if $conv eq "Null";	3442	return "jsStringOrNull(exec, $value)" if $conv eq "Null";

Lines 26-35 a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.cpp_sec1
- a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestCallback.cpp -1 / +1 lines
26		26
27	#include "DOMStringList.h"	27	#include "DOMStringList.h"
28	#include "Float32Array.h"	28	#include "Float32Array.h"
29	#include "KURL.h"
30	#include "SerializedScriptValue.h"	29	#include "SerializedScriptValue.h"
31	#include "TestCallback.h"	30	#include "TestCallback.h"
32	#include "TestNode.h"	31	#include "TestNode.h"
		32	#include "URL.h"
33	#include "WebDOMDOMStringList.h"	33	#include "WebDOMDOMStringList.h"
34	#include "WebDOMFloat32Array.h"	34	#include "WebDOMFloat32Array.h"
35	#include "WebDOMString.h"	35	#include "WebDOMString.h"

Lines 22-30 a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestEventTarget.cpp_sec1
- a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestEventTarget.cpp -1 / +1 lines
22	#include "WebDOMTestEventTarget.h"	22	#include "WebDOMTestEventTarget.h"
23		23
24	#include "Event.h"	24	#include "Event.h"
25	#include "KURL.h"
26	#include "Node.h"	25	#include "Node.h"
27	#include "TestEventTarget.h"	26	#include "TestEventTarget.h"
		27	#include "URL.h"
28	#include "WebDOMEvent.h"	28	#include "WebDOMEvent.h"
29	#include "WebDOMNode.h"	29	#include "WebDOMNode.h"
30	#include "WebDOMString.h"	30	#include "WebDOMString.h"

Lines 24-33 a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.cpp_sec1
- a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestInterface.cpp -1 / +1 lines
24		24
25	#include "WebDOMTestInterface.h"	25	#include "WebDOMTestInterface.h"
26		26
27	#include "KURL.h"
28	#include "Node.h"	27	#include "Node.h"
29	#include "TestInterface.h"	28	#include "TestInterface.h"
30	#include "TestSupplemental.h"	29	#include "TestSupplemental.h"
		30	#include "URL.h"
31	#include "WebDOMNode.h"	31	#include "WebDOMNode.h"
32	#include "WebDOMString.h"	32	#include "WebDOMString.h"
33	#include "WebExceptionHandler.h"	33	#include "WebExceptionHandler.h"

Lines 24-36 a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp_sec1
- a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp -1 / +1 lines
24	#include "Dictionary.h"	24	#include "Dictionary.h"
25	#include "Document.h"	25	#include "Document.h"
26	#include "HTMLNames.h"	26	#include "HTMLNames.h"
27	#include "KURL.h"
28	#include "Node.h"	27	#include "Node.h"
29	#include "SVGPoint.h"	28	#include "SVGPoint.h"
30	#include "SerializedScriptValue.h"	29	#include "SerializedScriptValue.h"
31	#include "TestEnumType.h"	30	#include "TestEnumType.h"
32	#include "TestNode.h"	31	#include "TestNode.h"
33	#include "TestObj.h"	32	#include "TestObj.h"
		33	#include "URL.h"
34	#include "WebDOMDictionary.h"	34	#include "WebDOMDictionary.h"
35	#include "WebDOMDocument.h"	35	#include "WebDOMDocument.h"
36	#include "WebDOMNode.h"	36	#include "WebDOMNode.h"