[ABANDONED] Get content of resources from Blob when the downloadToFile option is enabled

Source/core/inspector/InspectorResourceAgent.cpp

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 23 matching lines @@
 #include "FetchInitiatorTypeNames.h"
 #include "InspectorFrontend.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "bindings/v8/ScriptCallStackFactory.h"
 #include "core/dom/Document.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/fetch/FetchInitiatorInfo.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceLoader.h"
+#include "core/fetch/TextResourceDecoder.h"
+#include "core/fileapi/Blob.h"
+#include "core/fileapi/FileReaderLoader.h"
+#include "core/fileapi/FileReaderLoaderClient.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectorClient.h"
 #include "core/inspector/InspectorOverlay.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/NetworkResourcesData.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/page/Frame.h"
 #include "core/page/Page.h"
 #include "core/platform/JSONValues.h"
 #include "core/platform/network/HTTPHeaderMap.h"
 #include "core/platform/network/ResourceError.h"
 #include "core/platform/network/ResourceRequest.h"
 #include "core/platform/network/ResourceResponse.h"
 #include "core/xml/XMLHttpRequest.h"
 #include "modules/websockets/WebSocketFrame.h"
 #include "modules/websockets/WebSocketHandshakeRequest.h"
 #include "modules/websockets/WebSocketHandshakeResponse.h"
 #include "weborigin/KURL.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/RefPtr.h"
 
 typedef WebCore::InspectorBackendDispatcher::NetworkCommandHandler::LoadResourceForFrontendCallback LoadResourceForFrontendCallback;
+typedef WebCore::InspectorBackendDispatcher::NetworkCommandHandler::GetResponseBodyCallback GetResponseBodyCallback;
 
 namespace WebCore {
 
 namespace ResourceAgentState {
 static const char resourceAgentEnabled[] = "resourceAgentEnabled";
 static const char extraRequestHeaders[] = "extraRequestHeaders";
 static const char cacheDisabled[] = "cacheDisabled";
 static const char userAgentOverride[] = "userAgentOverride";
 }
 
@@ skipping 80 matching lines @@
     }
 
     RefPtr<LoadResourceForFrontendCallback> m_callback;
     RefPtr<ThreadableLoader> m_loader;
     RefPtr<TextResourceDecoder> m_decoder;
     ScriptString m_responseText;
     int m_statusCode;
     HTTPHeaderMap m_responseHeaders;
 };
 
+
+class InspectorResourceFileReaderLoaderClient : public FileReaderLoaderClient {
+    WTF_MAKE_NONCOPYABLE(InspectorResourceFileReaderLoaderClient);
+public:
+    InspectorResourceFileReaderLoaderClient(PassRefPtr<GetResponseBodyCallback> callback)
+        : m_callback(callback) { }
+
+    void didStartLoading()
+    {
+        ASSERT(m_loader);
+    }
+
+    void didReceiveData()
+    {
+        ASSERT(m_loader);
+    }
+
+    void didFinishLoading()
+    {
+        ASSERT(m_loader);
+        if (!m_decoder) {
+            m_callback->sendSuccess(String(""), false);
+        } else {
+            RefPtr<ArrayBuffer> buffer = m_loader->arrayBufferResult();
+            String content = m_decoder->decode(static_cast<const char*>(buffer->data()), buffer->byteLength());
+            m_callback->sendSuccess(content + m_decoder->flush(), false);
+        }
+        dispose();
+    }
+
+    void didFail(FileError::ErrorCode errorCode)
+    {
+        m_callback->sendFailure("Failed to load Blob: error code = " + String::number(errorCode)); // FIXME: Generate human-friendly reason message.
+        dispose();
+    }
+
+    void setLoader(PassOwnPtr<FileReaderLoader> loader)
+    {
+        m_loader = loader;
+    }
+
+    void start(Document* document, PassRefPtr<Blob> prpBlob, const String& textEncodingName)
+    {
+        ASSERT(m_loader);
+        RefPtr<Blob> blob = prpBlob;
+        m_decoder = InspectorPageAgent::createXHRTextDecoder(blob->type(), textEncodingName);
+        m_loader->start(document, *blob);
+    }
+
+private:
+    void dispose()
+    {
+        m_loader.clear();
+        delete this;
+    }
+
+    OwnPtr<FileReaderLoader> m_loader;
+    RefPtr<GetResponseBodyCallback> m_callback;
+    RefPtr<TextResourceDecoder> m_decoder;
+};
+
 KURL urlWithoutFragment(const KURL& url)
 {
     KURL result = url;
     result.removeFragmentIdentifier();
     return result;
 }
 
 } // namespace
 
 void InspectorResourceAgent::setFrontend(InspectorFrontend* frontend)
@@ skipping 292 matching lines @@
 }
 
 void InspectorResourceAgent::willDestroyResource(Resource* cachedResource)
 {
     Vector<String> requestIds = m_resourcesData->removeResource(cachedResource);
     if (!requestIds.size())
         return;
 
     String content;
     bool base64Encoded;
-    if (!InspectorPageAgent::cachedResourceContent(cachedResource, &content, &base64Encoded))
+    RefPtr<Blob> blob;
+    String textEncodingName;
+    if (!InspectorPageAgent::cachedResourceContentOrBlob(cachedResource, &content, &base64Encoded, &blob, &textEncodingName))
         return;
     Vector<String>::iterator end = requestIds.end();
-    for (Vector<String>::iterator it = requestIds.begin(); it != end; ++it)
-        m_resourcesData->setResourceContent(*it, content, base64Encoded);
+    for (Vector<String>::iterator it = requestIds.begin(); it != end; ++it) {
+        if (!blob)
+            m_resourcesData->setResourceContent(*it, content, base64Encoded);
+        else
+            m_resourcesData->setResourceBlob(*it, blob, textEncodingName);
+    }
 }
 
 void InspectorResourceAgent::applyUserAgentOverride(String* userAgent)
 {
     String userAgentOverride = m_state->getString(ResourceAgentState::userAgentOverride);
     if (!userAgentOverride.isEmpty())
         *userAgent = userAgentOverride;
 }
 
 void InspectorResourceAgent::willRecalculateStyle(Document*)
@@ skipping 122 matching lines @@
 {
     m_state->setString(ResourceAgentState::userAgentOverride, userAgent);
     m_overlay->setOverride(InspectorOverlay::UserAgentOverride, !userAgent.isEmpty());
 }
 
 void InspectorResourceAgent::setExtraHTTPHeaders(ErrorString*, const RefPtr<JSONObject>& headers)
 {
     m_state->setObject(ResourceAgentState::extraRequestHeaders, headers);
 }
 
-void InspectorResourceAgent::getResponseBody(ErrorString* errorString, const String& requestId, String* content, bool* base64Encoded)
+void InspectorResourceAgent::getResponseBody(ErrorString* errorString, const String& requestId, PassRefPtr<GetResponseBodyCallback> prpCallback)
 {
+    RefPtr<GetResponseBodyCallback> callback = prpCallback;
+    if (!callback->isActive())
+        return;
+
+    Document* document = m_pageAgent->mainFrame()->document();
+    if (!document) {
+        *errorString = "No Document instance for the specified frame";
+        return;
+    }
+
     NetworkResourcesData::ResourceData const* resourceData = m_resourcesData->data(requestId);
     if (!resourceData) {
         *errorString = "No resource with given identifier found";
         return;
     }
 
     if (resourceData->hasContent()) {
-        *base64Encoded = resourceData->base64Encoded();
-        *content = resourceData->content();
+        callback->sendSuccess(resourceData->content(), resourceData->base64Encoded());
         return;
     }
 
+    if (resourceData->hasBlob()) {
+        InspectorResourceFileReaderLoaderClient* client = new InspectorResourceFileReaderLoaderClient(callback);
+        OwnPtr<FileReaderLoader> loader = adoptPtr(new FileReaderLoader(FileReaderLoader::ReadAsArrayBuffer, client));
+        client->setLoader(loader.release());
+        client->start(document, resourceData->blob(), resourceData->blobTextEncodingName());
+        return;
+    }
+
     if (resourceData->isContentEvicted()) {
         *errorString = "Request content was evicted from inspector cache";
         return;
     }
 
     if (resourceData->buffer() && !resourceData->textEncodingName().isNull()) {
-        *base64Encoded = false;
-        if (InspectorPageAgent::sharedBufferContent(resourceData->buffer(), resourceData->textEncodingName(), *base64Encoded, content))
+        String content;
+        bool base64Encoded = false;
+        if (InspectorPageAgent::sharedBufferContent(resourceData->buffer(), resourceData->textEncodingName(), base64Encoded, &content)) {
+            callback->sendSuccess(content, base64Encoded);
             return;
+        }
     }
 
     if (resourceData->cachedResource()) {
-        if (InspectorPageAgent::cachedResourceContent(resourceData->cachedResource(), content, base64Encoded))
+        String content;
+        bool base64Encoded;
+        RefPtr<Blob> blob;
+        String textEncodingName;
+        if (InspectorPageAgent::cachedResourceContentOrBlob(resourceData->cachedResource(), &content, &base64Encoded, &blob, &textEncodingName)) {
+            if (blob) {
+                InspectorResourceFileReaderLoaderClient* client = new InspectorResourceFileReaderLoaderClient(callback);
+                OwnPtr<FileReaderLoader> loader = adoptPtr(new FileReaderLoader(FileReaderLoader::ReadAsArrayBuffer, client));
+                client->setLoader(loader.release());
+                client->start(document, blob.release(), textEncodingName);
+            } else {
+                callback->sendSuccess(content, base64Encoded);
+            }
             return;
+        }
     }
 
     *errorString = "No data found for resource with given identifier";
 }
 
 void InspectorResourceAgent::replayXHR(ErrorString*, const String& requestId)
 {
     RefPtr<XMLHttpRequest> xhr = XMLHttpRequest::create(m_pageAgent->mainFrame()->document());
     String actualRequestId = requestId;
 
@@ skipping 113 matching lines @@
     , m_overlay(overlay)
     , m_frontend(0)
     , m_resourcesData(adoptPtr(new NetworkResourcesData()))
     , m_loadingXHRSynchronously(false)
     , m_isRecalculatingStyle(false)
 {
 }
 
 } // namespace WebCore