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

Source/core/inspector/InspectorResourceAgent.cpp

Index: Source/core/inspector/InspectorResourceAgent.cpp
diff --git a/Source/core/inspector/InspectorResourceAgent.cpp b/Source/core/inspector/InspectorResourceAgent.cpp
index fad8d679ef7917c242a1f7e2e8dd53a9cfe4a852..acc15c3627afdf804bde97fe43f43f49632513e7 100644
--- a/Source/core/inspector/InspectorResourceAgent.cpp
+++ b/Source/core/inspector/InspectorResourceAgent.cpp
@@ -41,6 +41,10 @@
 #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"
@@ -70,6 +74,7 @@
 #include "wtf/RefPtr.h"
 
 typedef WebCore::InspectorBackendDispatcher::NetworkCommandHandler::LoadResourceForFrontendCallback LoadResourceForFrontendCallback;
+typedef WebCore::InspectorBackendDispatcher::NetworkCommandHandler::GetResponseBodyCallback GetResponseBodyCallback;
 
 namespace WebCore {
 
@@ -170,6 +175,67 @@ private:
     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;
@@ -482,11 +548,17 @@ void InspectorResourceAgent::willDestroyResource(Resource* cachedResource)
 
     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)
@@ -629,8 +701,18 @@ void InspectorResourceAgent::setExtraHTTPHeaders(ErrorString*, const RefPtr<JSON
     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";
@@ -638,8 +720,15 @@ void InspectorResourceAgent::getResponseBody(ErrorString* errorString, const Str
     }
 
     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;
     }
 
@@ -649,14 +738,30 @@ void InspectorResourceAgent::getResponseBody(ErrorString* errorString, const Str
     }
 
     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";