Get WebKit r44544.

1 files changed, 208 insertions, 64 deletions

diff --git a/WebCore/inspector/InspectorResource.cpp b/WebCore/inspector/InspectorResource.cpp
index 7db6cd1..6184119 100644
--- a/WebCore/inspector/InspectorResource.cpp
+++ b/WebCore/inspector/InspectorResource.cpp
@@ -35,66 +35,195 @@
 #include "DocLoader.h"
 #include "DocumentLoader.h"
 #include "Frame.h"
+#include "InspectorFrontend.h"
+#include "JSONObject.h"
+#include "ResourceRequest.h"
+#include "ResourceResponse.h"
 #include "TextEncoding.h"
 
-#include <runtime/JSLock.h>
-
 namespace WebCore {
 
-// XMLHttpRequestResource Class
+InspectorResource::InspectorResource(long long identifier, DocumentLoader* loader)
+    : m_identifier(identifier)
+    , m_loader(loader)
+    , m_frame(loader->frame())
+    , m_scriptObjectCreated(false)
+    , m_expectedContentLength(0)
+    , m_cached(false)
+    , m_finished(false)
+    , m_failed(false)
+    , m_length(0)
+    , m_responseStatusCode(0)
+    , m_startTime(-1.0)
+    , m_responseReceivedTime(-1.0)
+    , m_endTime(-1.0)
+    , m_isMainResource(false)
+{
+}
+
+InspectorResource::~InspectorResource()
+{
+}
+
+PassRefPtr<InspectorResource> InspectorResource::createCached(long long identifier, DocumentLoader* loader, const CachedResource* cachedResource)
+{
+    PassRefPtr<InspectorResource> resource = create(identifier, loader);
+
+    resource->m_finished = true;
+
+    resource->m_requestURL = KURL(cachedResource->url());
+    resource->updateResponse(cachedResource->response());
+
+    resource->m_length = cachedResource->encodedSize();
+    resource->m_cached = true;
+    resource->m_startTime = currentTime();
+    resource->m_responseReceivedTime = resource->m_startTime;
+    resource->m_endTime = resource->m_startTime;
+
+    resource->m_changes.setAll();
+
+    return resource;
+}
+
+void InspectorResource::updateRequest(const ResourceRequest& request)
+{
+    m_requestHeaderFields = request.httpHeaderFields();
+    m_requestURL = request.url();
+
+    m_changes.set(RequestChange);
+}
 
-struct XMLHttpRequestResource {
-    XMLHttpRequestResource(const JSC::UString& sourceString)
-    {
-        JSC::JSLock lock(false);
-        this->sourceString = sourceString.rep();
+void InspectorResource::updateResponse(const ResourceResponse& response)
+{
+    m_expectedContentLength = response.expectedContentLength();
+    m_mimeType = response.mimeType();
+    m_responseHeaderFields = response.httpHeaderFields();
+    m_responseStatusCode = response.httpStatusCode();
+    m_suggestedFilename = response.suggestedFilename();
+
+    m_changes.set(ResponseChange);
+    m_changes.set(TypeChange);
+}
+
+static void populateHeadersObject(JSONObject* object, const HTTPHeaderMap& headers)
+{
+    HTTPHeaderMap::const_iterator end = headers.end();
+    for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) {
+        object->set(it->first.string(), it->second);
     }
+}
 
-    ~XMLHttpRequestResource()
-    {
-        JSC::JSLock lock(false);
-        sourceString.clear();
+void InspectorResource::createScriptObject(InspectorFrontend* frontend)
+{
+    if (!m_scriptObjectCreated) {
+        JSONObject jsonObject = frontend->newJSONObject();
+        JSONObject requestHeaders = frontend->newJSONObject();
+        populateHeadersObject(&requestHeaders, m_requestHeaderFields);
+        jsonObject.set("requestHeaders", requestHeaders);
+        jsonObject.set("requestURL", requestURL());
+        jsonObject.set("host", m_requestURL.host());
+        jsonObject.set("path", m_requestURL.path());
+        jsonObject.set("lastPathComponent", m_requestURL.lastPathComponent());
+        jsonObject.set("isMainResource", m_isMainResource);
+        jsonObject.set("cached", m_cached);
+        if (!frontend->addResource(m_identifier, jsonObject))
+            return;
+
+        m_scriptObjectCreated = true;
+        m_changes.clear(RequestChange);
+    }
+    updateScriptObject(frontend);
+}
+
+void InspectorResource::updateScriptObject(InspectorFrontend* frontend)
+{
+    if (!m_scriptObjectCreated)
+        return;
+
+    if (m_changes.hasChange(NoChange))
+        return;
+
+    JSONObject jsonObject = frontend->newJSONObject();
+    if (m_changes.hasChange(RequestChange)) {
+        jsonObject.set("url", requestURL());
+        jsonObject.set("domain", m_requestURL.host());
+        jsonObject.set("path", m_requestURL.path());
+        jsonObject.set("lastPathComponent", m_requestURL.lastPathComponent());
+        JSONObject requestHeaders = frontend->newJSONObject();
+        populateHeadersObject(&requestHeaders, m_requestHeaderFields);
+        jsonObject.set("requestHeaders", requestHeaders);
+        jsonObject.set("mainResource", m_isMainResource);
+        jsonObject.set("didRequestChange", true);
     }
 
-    RefPtr<JSC::UString::Rep> sourceString;
-};
-
-    InspectorResource::InspectorResource(long long identifier, DocumentLoader* documentLoader, Frame* frame)
-    : identifier(identifier)
-    , loader(documentLoader)
-    , frame(frame)
-    , scriptContext(0)
-    , scriptObject(0)
-    , expectedContentLength(0)
-    , cached(false)
-    , finished(false)
-    , failed(false)
-    , length(0)
-    , responseStatusCode(0)
-    , startTime(-1.0)
-    , responseReceivedTime(-1.0)
-    , endTime(-1.0)
-    , xmlHttpRequestResource(0)
-    {
+    if (m_changes.hasChange(ResponseChange)) {
+        jsonObject.set("mimeType", m_mimeType);
+        jsonObject.set("suggestedFilename", m_suggestedFilename);
+        jsonObject.set("expectedContentLength", m_expectedContentLength);
+        jsonObject.set("statusCode", m_responseStatusCode);
+        jsonObject.set("suggestedFilename", m_suggestedFilename);
+        JSONObject responseHeaders = frontend->newJSONObject();
+        populateHeadersObject(&responseHeaders, m_responseHeaderFields);
+        jsonObject.set("responseHeaders", responseHeaders);
+        jsonObject.set("didResponseChange", true);
     }
 
-InspectorResource::~InspectorResource()
+    if (m_changes.hasChange(TypeChange)) {
+        jsonObject.set("type", static_cast<int>(type()));
+        jsonObject.set("didTypeChange", true);
+    }
+    
+    if (m_changes.hasChange(LengthChange)) {
+        jsonObject.set("contentLength", m_length);
+        jsonObject.set("didLengthChange", true);
+    }
+
+    if (m_changes.hasChange(CompletionChange)) {
+        jsonObject.set("failed", m_failed);
+        jsonObject.set("finished", m_finished);
+        jsonObject.set("didCompletionChange", true);
+    }
+
+    if (m_changes.hasChange(TimingChange)) {
+        if (m_startTime > 0)
+            jsonObject.set("startTime", m_startTime);
+        if (m_responseReceivedTime > 0)
+            jsonObject.set("responseReceivedTime", m_responseReceivedTime);
+        if (m_endTime > 0)
+            jsonObject.set("endTime", m_endTime);
+        jsonObject.set("didTimingChange", true);
+    }
+    if (!frontend->updateResource(m_identifier, jsonObject))
+        return;
+    m_changes.clearAll();
+}
+
+void InspectorResource::releaseScriptObject(InspectorFrontend* frontend, bool callRemoveResource)
 {
-    setScriptObject(0, 0);
+    if (!m_scriptObjectCreated)
+        return;
+
+    m_scriptObjectCreated = false;
+    m_changes.setAll();
+
+    if (!callRemoveResource)
+        return;
+
+    frontend->removeResource(m_identifier);
 }
 
 InspectorResource::Type InspectorResource::type() const
 {
-    if (xmlHttpRequestResource)
+    if (!m_xmlHttpResponseText.isNull())
         return XHR;
 
-    if (requestURL == loader->requestURL())
+    if (m_requestURL == m_loader->requestURL())
         return Doc;
 
-    if (loader->frameLoader() && requestURL == loader->frameLoader()->iconURL())
+    if (m_loader->frameLoader() && m_requestURL == m_loader->frameLoader()->iconURL())
         return Image;
 
-    CachedResource* cachedResource = frame->document()->docLoader()->cachedResource(requestURL.string());
+    CachedResource* cachedResource = m_frame->document()->docLoader()->cachedResource(requestURL());
     if (!cachedResource)
         return Other;
 
@@ -115,42 +244,25 @@ InspectorResource::Type InspectorResource::type() const
     }
 }
 
-void InspectorResource::setScriptObject(JSContextRef context, JSObjectRef newScriptObject)
-{
-    if (scriptContext && scriptObject)
-        JSValueUnprotect(scriptContext, scriptObject);
-
-    scriptObject = newScriptObject;
-    scriptContext = context;
-
-    ASSERT((context && newScriptObject) || (!context && !newScriptObject));
-    if (context && newScriptObject)
-        JSValueProtect(context, newScriptObject);
-}
-
-void InspectorResource::setXMLHttpRequestProperties(const JSC::UString& data)
-{
-    xmlHttpRequestResource.set(new XMLHttpRequestResource(data));
-}
-
-void InspectorResource::setScriptProperties(const JSC::UString& data)
+void InspectorResource::setXMLHttpResponseText(const ScriptString& data)
 {
-    xmlHttpRequestResource.set(new XMLHttpRequestResource(data));
+    m_xmlHttpResponseText = data;
+    m_changes.set(TypeChange);
 }
 
 String InspectorResource::sourceString() const
 {
-    if (xmlHttpRequestResource)
-        return JSC::UString(xmlHttpRequestResource->sourceString);
+    if (!m_xmlHttpResponseText.isNull())
+        return String(m_xmlHttpResponseText);
 
     RefPtr<SharedBuffer> buffer;
     String textEncodingName;
 
-    if (requestURL == loader->requestURL()) {
-        buffer = loader->mainResourceData();
-        textEncodingName = frame->document()->inputEncoding();
+    if (m_requestURL == m_loader->requestURL()) {
+        buffer = m_loader->mainResourceData();
+        textEncodingName = m_frame->document()->inputEncoding();
     } else {
-        CachedResource* cachedResource = frame->document()->docLoader()->cachedResource(requestURL.string());
+        CachedResource* cachedResource = m_frame->document()->docLoader()->cachedResource(requestURL());
         if (!cachedResource)
             return String();
 
@@ -178,4 +290,36 @@ String InspectorResource::sourceString() const
     return encoding.decode(buffer->data(), buffer->size());
 }
 
+void InspectorResource::startTiming()
+{
+    m_startTime = currentTime();
+    m_changes.set(TimingChange);
+}
+
+void InspectorResource::markResponseReceivedTime()
+{
+    m_responseReceivedTime = currentTime();
+    m_changes.set(TimingChange);
+}
+
+void InspectorResource::endTiming()
+{
+    m_endTime = currentTime();
+    m_finished = true;
+    m_changes.set(TimingChange);
+    m_changes.set(CompletionChange);
+}
+
+void InspectorResource::markFailed()
+{
+    m_failed = true;
+    m_changes.set(CompletionChange);
+}
+
+void InspectorResource::addLength(int lengthReceived)
+{
+    m_length += lengthReceived;
+    m_changes.set(LengthChange);
+}
+
 } // namespace WebCore