WebCore/ChangeLog

2009-10-07  Brian Weinstein  <bweinstein@apple.com>

        Reviewed by NOBODY (OOPS!).

        Fixes <http://webkit.org/b/30104>.

        Inspector should show cookies of sub-resources on the page.

        This function implements showing cookies for all sub-resources of a page.

        When the page is loaded, it populates the Storage Panel with a list of all

        domains that were loaded as part of the full page load (iframes, ads, etc).

        When the user selects one of the domains, the inspector calls back into the

        controller, and the controller combines all of the cookies from that domain

        into a list, and sends that list is sent back to the controller to render.

        A domain now needs to be passed into CookieItemsView, and CookieSidebarTreeElement.

        As a result of a previous patch, we now have detailed cookie information for

        both Windows on CFNetwork and Mac.

        * bindings/js/ScriptObject.cpp:

        (WebCore::ScriptObject::set):

        * bindings/js/ScriptObject.h:

        * inspector/InspectorBackend.cpp:

        (WebCore::InspectorBackend::getCookies):

        (WebCore::InspectorBackend::deleteCookie):

        * inspector/InspectorBackend.h:

        * inspector/InspectorBackend.idl:

        * inspector/InspectorController.cpp:

        (WebCore::InspectorController::populateScriptObjects):

        (WebCore::InspectorController::didFinishLoading):

        (WebCore::InspectorController::getCookies):

        (WebCore::InspectorController::buildArrayForCookies):

        (WebCore::InspectorController::buildObjectForCookie):

        (WebCore::InspectorController::deleteCookie):

        * inspector/InspectorController.h:

        * inspector/InspectorDOMAgent.cpp:

        * inspector/InspectorDOMAgent.h:

        * inspector/InspectorFrontend.cpp:

        (WebCore::InspectorFrontend::addCookieDomainForDocument):

        * inspector/InspectorFrontend.h:

        * inspector/front-end/CookieItemsView.js:

        (WebInspector.CookieItemsView):

        (WebInspector.CookieItemsView.prototype.update):

        (WebInspector.CookieItemsView.prototype._deleteButtonClicked):

        * inspector/front-end/DOMAgent.js:

        (WebInspector.Cookies.getCookiesAsync):

        * inspector/front-end/StoragePanel.js:

        (WebInspector.StoragePanel):

        (WebInspector.StoragePanel.prototype.reset):

        (WebInspector.StoragePanel.prototype.addCookieDomain):

        (WebInspector.StoragePanel.prototype.showCookies):

        (WebInspector.CookieSidebarTreeElement):

        (WebInspector.CookieSidebarTreeElement.prototype.onselect):

        * inspector/front-end/inspector.js:

        (WebInspector.addCookieDomain):

        * platform/Cookie.h:

        (WebCore::CookieHash::hash):

        (WebCore::CookieHash::equal):

        (WTF::):

2009-10-07  Dave Hyatt  <hyatt@apple.com>

        Reviewed by Adam Roben.

49258

WebCore/bindings/js/ScriptObject.cpp

@@bool ScriptObject::set(const char* name,

    return handleException(m_scriptState);

}

bool ScriptObject::set(const char* name, unsigned value)

{

    JSLock lock(SilenceAssertionsOnly);

    PutPropertySlot slot;

    jsObject()->put(m_scriptState, Identifier(m_scriptState, name), jsNumber(m_scriptState, value), slot);

    return handleException(m_scriptState);

}

bool ScriptObject::set(const char* name, bool value)

{

    JSLock lock(SilenceAssertionsOnly);

49210

WebCore/bindings/js/ScriptObject.h

@@namespace WebCore {

        bool set(const char* name, double);

        bool set(const char* name, long long);

        bool set(const char* name, int);

55 bool set(const char* name, unsigned);

        bool set(const char* name, bool);

        static ScriptObject createNew(ScriptState*);

49210

WebCore/inspector/InspectorBackend.cpp

@@void InspectorBackend::copyNode(long nod

    Pasteboard::generalPasteboard()->writePlainText(markup);

}

454 void InspectorBackend::getCookies(long callId)

454void InspectorBackend::getCookies(long callId, const String& domain)

455455{

456 if (InspectorDOMAgent* domAgent = inspectorDOMAgent())

457 domAgent->getCookies(callId);

    if (!m_inspectorController)

        return;

    m_inspectorController->getCookies(callId, domain);

458459}

459460

460 void InspectorBackend::deleteCookie(const String& cookieName)

461void InspectorBackend::deleteCookie(const String& cookieName, const String& domain)

{

    if (!m_inspectorController)

        return;

464 m_inspectorController->deleteCookie(cookieName);

465 m_inspectorController->deleteCookie(cookieName, domain);

}

void InspectorBackend::highlight(long nodeId)

49210

WebCore/inspector/InspectorBackend.h

@@public:

    void getEventListenersForNode(long callId, long nodeId);

    void copyNode(long nodeId);

141 void getCookies(long callId);

142 void deleteCookie(const String& cookieName);

141 void getCookies(long callId, const String& domain);

142 void deleteCookie(const String& cookieName, const String& domain);

    // Generic code called from custom implementations.

    void highlight(long nodeId);

49210

WebCore/inspector/InspectorBackend.idl

@@module core {

        void getEventListenersForNode(in long callId, in long nodeId);

        void copyNode(in long nodeId);

112 void getCookies(in long callId);

113 void deleteCookie(in DOMString cookieName);

112 void getCookies(in long callId, in DOMString domain);

113 void deleteCookie(in DOMString cookieName, in DOMString domain);

        // Called from InjectedScript.

        [Custom] DOMObject nodeForId(in long nodeId);

49210

WebCore/inspector/InspectorController.cpp

#include "CachedResource.h"

#include "Console.h"

#include "ConsoleMessage.h"

39#include "Cookie.h"

#include "CookieJar.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "TextEncoding.h"

#include "TextIterator.h"

#include <wtf/CurrentTime.h>

80#include <wtf/ListHashSet.h>

#include <wtf/RefCounted.h>

#include <wtf/StdLibExtras.h>

@@void InspectorController::populateScript

    m_domAgent->setDocument(m_inspectedPage->mainFrame()->document());

    ResourcesMap::iterator resourcesEnd = m_resources.end();

655 for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it)

657 for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it) {

656658 it->second->createScriptObject(m_frontend.get());

657

        m_frontend->addCookieDomainForDocument(it->second->frame()->document());

    }

    unsigned messageCount = m_consoleMessages.size();

    for (unsigned i = 0; i < messageCount; ++i)

        m_consoleMessages[i]->addToConsole(m_frontend.get());

@@void InspectorController::didFinishLoadi

    addResource(resource.get());

975 if (m_frontend)

979 if (m_frontend) {

976980 resource->updateScriptObject(m_frontend.get());

981 m_frontend->addCookieDomainForDocument(resource->frame()->document());

982 }

}

void InspectorController::didFailLoading(DocumentLoader*, unsigned long identifier, const ResourceError& /*error*/)

@@void InspectorController::didOpenDatabas

}

#endif

void InspectorController::getCookies(long callId, const String& host)

{

    if (!m_frontend)

        return;

    // If we can get raw cookies.

    ListHashSet<Cookie> rawCookiesList;

    // If we can't get raw cookies - fall back to String representation

    String stringCookiesList;

    // Return value to getRawCookies should be the same for every call because

    // the return value is platform/network backend specific, and the call will

    // always return the same true/false value.

    bool rawCookiesImplemented = false;

    ResourcesMap::iterator resourcesEnd = m_resources.end();

    for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it) {

        Document* document = it->second->frame()->document();

        if (document->url().host() == host) {

            Vector<Cookie> docCookiesList;

            rawCookiesImplemented = getRawCookies(document, document->cookieURL(), docCookiesList);

            if (!rawCookiesImplemented)

                // FIXME: We need duplication checking for the String representation of cookies.

                stringCookiesList += document->cookie();

            else {

                int cookiesSize = docCookiesList.size();

                for (int i = 0; i < cookiesSize; i++) {

                    if (!rawCookiesList.contains(docCookiesList[i]))

                        rawCookiesList.add(docCookiesList[i]);

                }

            }

        }

    }

    if (!rawCookiesImplemented)

        m_frontend->didGetCookies(callId, m_frontend->newScriptArray(), stringCookiesList);

    else

        m_frontend->didGetCookies(callId, buildArrayForCookies(rawCookiesList), String());

}

ScriptArray InspectorController::buildArrayForCookies(ListHashSet<Cookie>& cookiesList)

{

    ScriptArray cookies = m_frontend->newScriptArray();

    ListHashSet<Cookie>::iterator end = cookiesList.end();

    ListHashSet<Cookie>::iterator it = cookiesList.begin();

    for (int i = 0; it != end; ++it, i++) {

        cookies.set(i, buildObjectForCookie(*it));

    }

    return cookies;

}

ScriptObject InspectorController::buildObjectForCookie(const Cookie& cookie)

{

    ScriptObject value = m_frontend->newScriptObject();

    value.set("name", cookie.name);

    value.set("value", cookie.value);

    value.set("domain", cookie.domain);

    value.set("path", cookie.path);

    value.set("expires", cookie.expires);

    value.set("size", (cookie.name.length() + cookie.value.length()));

    value.set("httpOnly", cookie.httpOnly);

    value.set("secure", cookie.secure);

    value.set("session", cookie.session);

    return value;

}

#if ENABLE(DOM_STORAGE)

void InspectorController::didUseDOMStorage(StorageArea* storageArea, bool isLocalStorage, Frame* frame)

{

@@void InspectorController::resetInjectedS

    function.call();

}

1712 void InspectorController::deleteCookie(const String& cookieName)

1787void InspectorController::deleteCookie(const String& cookieName, const String& domain)

17131788{

1714 Document* document = m_inspectedPage->mainFrame()->document();

1715 WebCore::deleteCookie(document, document->cookieURL(), cookieName);

    ResourcesMap::iterator resourcesEnd = m_resources.end();

    for (ResourcesMap::iterator it = m_resources.begin(); it != resourcesEnd; ++it) {

        Document* document = it->second->frame()->document();

        if (document->url().host() == domain)

            WebCore::deleteCookie(document, document->cookieURL(), cookieName);

    }

}

} // namespace WebCore

49210

WebCore/inspector/InspectorController.h

#define InspectorController_h

#include "Console.h"

33#include "Cookie.h"

3334#include "PlatformString.h"

35#include "ScriptArray.h"

#include "ScriptObject.h"

#include "ScriptState.h"

#include "ScriptValue.h"

#include <wtf/HashMap.h>

#include <wtf/HashSet.h>

44#include <wtf/ListHashSet.h>

#include <wtf/RefCounted.h>

#include <wtf/Vector.h>

@@public:

    void mainResourceFiredLoadEvent(DocumentLoader*, const KURL&);

    void mainResourceFiredDOMContentEvent(DocumentLoader*, const KURL&);

238

239 void getCookies(long callId, const String& url);

#if ENABLE(DATABASE)

    void didOpenDatabase(Database*, const String& domain, const String& name, const String& version);

@@private:

    

    void resetInjectedScript();

310 void deleteCookie(const String& cookieName);

315 void deleteCookie(const String& cookieName, const String& domain);

#if ENABLE(JAVASCRIPT_DEBUGGER)

    void startUserInitiatedProfilingSoon();

@@private:

#if ENABLE(DOM_STORAGE)

    InspectorDOMStorageResource* getDOMStorageResourceForId(int storageId);

#endif

                                                        
    ScriptObject buildObjectForCookie(const Cookie&);

    ScriptArray buildArrayForCookies(ListHashSet<Cookie>&);

    void focusNode();

49210

WebCore/inspector/InspectorDOMAgent.cpp

@@void InspectorDOMAgent::getEventListener

    m_frontend->didGetEventListenersForNode(callId, nodeId, listenersArray);

}

void InspectorDOMAgent::getCookies(long callId)

{

    Document* doc = mainFrameDocument();

    Vector<Cookie> cookiesList;

    bool isImplemented = getRawCookies(doc, doc->cookieURL(), cookiesList);

    if (!isImplemented)

        m_frontend->didGetCookies(callId, m_frontend->newScriptArray(), doc->cookie());

    else

        m_frontend->didGetCookies(callId, buildArrayForCookies(cookiesList), String());

}

ScriptObject InspectorDOMAgent::buildObjectForNode(Node* node, int depth, NodeToIdMap* nodesMap)

{

    ScriptObject value = m_frontend->newScriptObject();

@@ScriptObject InspectorDOMAgent::buildObj

    return value;

}

ScriptObject InspectorDOMAgent::buildObjectForCookie(const Cookie& cookie)

{

    ScriptObject value = m_frontend->newScriptObject();

    value.set("name", cookie.name);

    value.set("value", cookie.value);

    value.set("domain", cookie.domain);

    value.set("path", cookie.path);

    value.set("expires", cookie.expires);

    value.set("size", static_cast<int>(cookie.name.length() + cookie.value.length()));

    value.set("httpOnly", cookie.httpOnly);

    value.set("secure", cookie.secure);

    value.set("session", cookie.session);

    return value;

}

ScriptArray InspectorDOMAgent::buildArrayForCookies(const Vector<Cookie>& cookiesList)

{

    ScriptArray cookies = m_frontend->newScriptArray();

    unsigned length = cookiesList.size();

    for (unsigned i = 0; i < length; ++i) {

        const Cookie& cookie = cookiesList[i];

        cookies.set(i, buildObjectForCookie(cookie));

    }

    return cookies;

}

Node* InspectorDOMAgent::innerFirstChild(Node* node)

{

    if (node->isFrameOwnerElement()) {

49210

WebCore/inspector/InspectorDOMAgent.h

@@namespace WebCore {

    class Node;

    class Page;

56 struct Cookie;

57

    struct EventListenerInfo {

        EventListenerInfo(Node* node, const AtomicString& eventType, const EventListenerVector& eventListenerVector)

            : node(node)

@@namespace WebCore {

        void removeAttribute(long callId, long elementId, const String& name);

        void setTextNodeValue(long callId, long nodeId, const String& value);

        void getEventListenersForNode(long callId, long nodeId);

91 void getCookies(long callId);

        // Methods called from the InspectorController.

        void setDocument(Document* document);

@@namespace WebCore {

        ScriptObject buildObjectForEventListener(const RegisteredEventListener& registeredEventListener, const AtomicString& eventType, Node* node);

        ScriptObject buildObjectForCookie(const Cookie& cookie);

        ScriptArray buildArrayForCookies(const Vector<Cookie>& cookiesList);

        // We represent embedded doms as a part of the same hierarchy. Hence we treat children of frame owners differently.

        // We also skip whitespace text nodes conditionally. Following methods encapsulate these specifics.

        Node* innerFirstChild(Node* node);

49210

WebCore/inspector/InspectorFrontend.cpp

@@void InspectorFrontend::removeResource(l

    function->call();

}

void InspectorFrontend::addCookieDomainForDocument(Document* document)

{

    OwnPtr<ScriptFunctionCall> function(newFunctionCall("addCookieDomain"));

    function->appendArgument(document->url().host());

    function->call();

}

void InspectorFrontend::updateFocusedNode(long long nodeId)

{

    OwnPtr<ScriptFunctionCall> function(newFunctionCall("updateFocusedNode"));

49210

WebCore/inspector/InspectorFrontend.h

@@namespace WebCore {

        bool updateResource(long long identifier, const ScriptObject& resourceObj);

        void removeResource(long long identifier);

73 void addCookieDomainForDocument(Document*);

74

        void updateFocusedNode(long long nodeId);

        void setAttachedWindow(bool attached);

        void showPanel(int panel);

49210

WebCore/inspector/front-end/CookieItemsView.js

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

30 WebInspector.CookieItemsView = function()

30WebInspector.CookieItemsView = function(cookieDomain)

{

    WebInspector.View.call(this);

@@WebInspector.CookieItemsView = function(

    this.refreshButton = new WebInspector.StatusBarButton(WebInspector.UIString("Refresh"), "refresh-storage-status-bar-item");

    this.refreshButton.addEventListener("click", this._refreshButtonClicked.bind(this), false);

43

44 this._cookieDomain = cookieDomain;

}

WebInspector.CookieItemsView.prototype = {

@@WebInspector.CookieItemsView.prototype =

            }

        }

86 WebInspector.Cookies.getCookiesAsync(callback);

88 WebInspector.Cookies.getCookiesAsync(callback, this._cookieDomain);

    },

    dataGridForCookies: function(cookies)

@@WebInspector.CookieItemsView.prototype =

            return;

        var cookie = this._dataGrid.selectedNode.cookie;

263 InspectorController.deleteCookie(cookie.name);

265 InspectorController.deleteCookie(cookie.name, this._cookieDomain);

        this.update();

    },

49210

WebCore/inspector/front-end/DOMAgent.js

@@WebInspector.DOMAgent.prototype = {

WebInspector.Cookies = {}

440 WebInspector.Cookies.getCookiesAsync = function(callback)

440WebInspector.Cookies.getCookiesAsync = function(callback, cookieDomain)

{

    function mycallback(cookies, cookiesString) {

        if (cookiesString)

@@WebInspector.Cookies.getCookiesAsync = f

            callback(cookies, true);

    }

    var callId = WebInspector.Callback.wrap(mycallback);

449 InspectorController.getCookies(callId);

449 InspectorController.getCookies(callId, cookieDomain);

}

WebInspector.Cookies.buildCookiesFromString = function(rawCookieString)

49210

WebCore/inspector/front-end/StoragePanel.js

@@WebInspector.StoragePanel = function(dat

    this.sidebarTree.appendChild(this.cookieListTreeElement);

    this.cookieListTreeElement.expand();

    this.cookieTreeElement = new WebInspector.CookieSidebarTreeElement();

    this.cookieListTreeElement.appendChild(this.cookieTreeElement);

    this.storageViews = document.createElement("div");

    this.storageViews.id = "storage-views";

    this.element.appendChild(this.storageViews);

@@WebInspector.StoragePanel.prototype = {

        this._domStorage = [];

123 delete this._cookieView;

120 this._cookieDomains = {};

121 this._cookieView = {};

        this.databasesListTreeElement.removeChildren();

        this.localStorageListTreeElement.removeChildren();

        this.sessionStorageListTreeElement.removeChildren();

126 this.cookieListTreeElement.removeChildren();

127

        this.storageViews.removeChildren();        

        this.storageViewStatusBarItemsContainer.removeChildren();

@@WebInspector.StoragePanel.prototype = {

        database._databasesTreeElement = databaseTreeElement;

        this.databasesListTreeElement.appendChild(databaseTreeElement);

    },

    
    addCookieDomain: function(domain)

    {

        // Eliminate duplicate domains from the list.

        if (this._cookieDomains[domain] !== undefined)

            return;

        var cookieDomainTreeElement = new WebInspector.CookieSidebarTreeElement(domain);

        this.cookieListTreeElement.appendChild(cookieDomainTreeElement);

        this._cookieDomains[domain] = domain;

    },

    addDOMStorage: function(domStorage)

    {

@@WebInspector.StoragePanel.prototype = {

            this.storageViewStatusBarItemsContainer.appendChild(statusBarItems[i]);

    },

243 showCookies: function()

254 showCookies: function(cookieDomain)

    {

        if (this.visibleView)

            this.visibleView.hide();

248 var view = this._cookieView;

259 var view = this._cookieView[cookieDomain];

249260 if (!view) {

250 view = new WebInspector.CookieItemsView();

251 this._cookieView = view;

261 view = new WebInspector.CookieItemsView(cookieDomain);

262 this._cookieView[cookieDomain] = view;

        }

        view.show(this.storageViews);

@@WebInspector.DOMStorageSidebarTreeElemen

WebInspector.DOMStorageSidebarTreeElement.prototype.__proto__ = WebInspector.SidebarTreeElement.prototype;

575 WebInspector.CookieSidebarTreeElement = function()

586WebInspector.CookieSidebarTreeElement = function(cookieDomain)

576587{

577 WebInspector.SidebarTreeElement.call(this, "cookie-sidebar-tree-item", null, "", null, false);

588 WebInspector.SidebarTreeElement.call(this, "cookie-sidebar-tree-item", cookieDomain, "", null, false);

589 this._cookieDomain = cookieDomain;

    this.refreshTitles();

}

@@WebInspector.CookieSidebarTreeElement =

WebInspector.CookieSidebarTreeElement.prototype = {

    onselect: function()

    {

        WebInspector.panels.storage.showCookies();

    },

    get mainTitle()

    {

        return WebInspector.UIString("Cookies");

    },

    set mainTitle(x)

    {

        // Do nothing.

597 WebInspector.panels.storage.showCookies(this._cookieDomain);

    },

    get subtitle()

49210

WebCore/inspector/front-end/inspector.js

@@WebInspector.addDatabase = function(payl

    this.panels.storage.addDatabase(database);

}

WebInspector.addCookieDomain = function(domain)

{

    this.panels.storage.addCookieDomain(domain);

}

WebInspector.addDOMStorage = function(payload)

{

    var domStorage = new WebInspector.DOMStorage(

49210

WebCore/platform/Cookie.h

#define Cookie_h

#include "PlatformString.h"

30#include "StringHash.h"

namespace WebCore {

@@namespace WebCore {

        bool session;

    };

    struct CookieHash {

        static unsigned hash(Cookie key)

        { 

            return StringHash::hash(key.name) + StringHash::hash(key.domain) + StringHash::hash(key.path) + key.secure;

        }

        static bool equal(Cookie a, Cookie b)

        {

            return a.name == b.name && a.domain == b.domain && a.path == b.path && a.secure == b.secure;

        }

    };

}

namespace WTF {

    template<typename T> struct DefaultHash;

    template<> struct DefaultHash<WebCore::Cookie> {

        typedef WebCore::CookieHash Hash;

    };

}

#endif

49210