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

Source/core/inspector/InspectorPageAgent.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 29 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/UserGestureIndicator.h"
 #include "core/fetch/CSSStyleSheetResource.h"
 #include "core/fetch/FontResource.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/fetch/TextResourceDecoder.h"
+#include "core/fileapi/Blob.h"
+#include "core/fileapi/FileReaderLoader.h"
+#include "core/fileapi/FileReaderLoaderClient.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/inspector/ContentSearchUtils.h"
 #include "core/inspector/DOMPatchSupport.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InjectedScriptManager.h"
 #include "core/inspector/InspectorClient.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorOverlay.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
@@ skipping 10 matching lines @@
 #include "core/platform/JSONValues.h"
 #include "core/platform/text/RegularExpression.h"
 #include "modules/geolocation/GeolocationController.h"
 #include "weborigin/SecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/Vector.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/TextEncoding.h"
 
+typedef WebCore::InspectorBackendDispatcher::PageCommandHandler::GetResourceContentCallback GetResourceContentCallback;
+
 namespace WebCore {
 
 namespace PageAgentState {
 static const char pageAgentEnabled[] = "pageAgentEnabled";
 static const char pageAgentScriptExecutionDisabled[] = "pageAgentScriptExecutionDisabled";
 static const char pageAgentScriptsToEvaluateOnLoad[] = "pageAgentScriptsToEvaluateOnLoad";
 static const char pageAgentScreenWidthOverride[] = "pageAgentScreenWidthOverride";
 static const char pageAgentScreenHeightOverride[] = "pageAgentScreenHeightOverride";
 static const char pageAgentFontScaleFactorOverride[] = "pageAgentFontScaleFactorOverride";
 static const char pageAgentFitWindow[] = "pageAgentFitWindow";
 static const char pageAgentShowFPSCounter[] = "pageAgentShowFPSCounter";
 static const char pageAgentContinuousPaintingEnabled[] = "pageAgentContinuousPaintingEnabled";
 static const char pageAgentShowPaintRects[] = "pageAgentShowPaintRects";
 static const char pageAgentShowDebugBorders[] = "pageAgentShowDebugBorders";
 static const char pageAgentShowScrollBottleneckRects[] = "pageAgentShowScrollBottleneckRects";
 static const char touchEventEmulationEnabled[] = "touchEventEmulationEnabled";
 static const char pageAgentEmulatedMedia[] = "pageAgentEmulatedMedia";
 static const char showSizeOnResize[] = "showSizeOnResize";
 static const char showGridOnResize[] = "showGridOnResize";
 static const char forceCompositingMode[] = "forceCompositingMode";
 }
 
 namespace {
 
+class InspectorPageFileReaderLoaderClient : public FileReaderLoaderClient {
+    WTF_MAKE_NONCOPYABLE(InspectorPageFileReaderLoaderClient);
+public:
+    InspectorPageFileReaderLoaderClient(PassRefPtr<GetResourceContentCallback> 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<GetResourceContentCallback> m_callback;
+    RefPtr<TextResourceDecoder> m_decoder;
+};
+
 KURL urlWithoutFragment(const KURL& url)
 {
     KURL result = url;
     result.removeFragmentIdentifier();
     return result;
 }
 
 }
 
 static bool decodeBuffer(const char* buffer, unsigned size, const String& textEncodingName, String* result)
 {
     if (buffer) {
         WTF::TextEncoding encoding(textEncodingName);
         if (!encoding.isValid())
             encoding = WindowsLatin1Encoding();
         *result = encoding.decode(buffer, size);
         return true;
     }
     return false;
 }
 
-static bool prepareResourceBuffer(Resource* cachedResource, bool* hasZeroSize)
+static bool prepareResourceBuffer(Resource* cachedResource, bool* hasZeroSize, bool* hasBlob)
 {
     *hasZeroSize = false;
+    *hasBlob = false;
     if (!cachedResource)
         return false;
 
+    if (!cachedResource->response().downloadedFilePath().isEmpty()) {
+        *hasBlob = true;
+        return true;
+    }
+
     // Zero-sized resources don't have data at all -- so fake the empty buffer, instead of indicating error by returning 0.
     if (!cachedResource->encodedSize()) {
         *hasZeroSize = true;
         return true;
     }
 
     if (cachedResource->isPurgeable()) {
         // If the resource is purgeable then make it unpurgeable to get
         // get its data. This might fail, in which case we return an
         // empty String.
         // FIXME: should we do something else in the case of a purged
         // resource that informs the user why there is no data in the
         // inspector?
         if (!cachedResource->makePurgeable(false))
             return false;
     }
 
     return true;
 }
 
 static bool hasTextContent(Resource* cachedResource)
 {
     InspectorPageAgent::ResourceType type = InspectorPageAgent::cachedResourceType(*cachedResource);
     return type == InspectorPageAgent::DocumentResource || type == InspectorPageAgent::StylesheetResource || type == InspectorPageAgent::ScriptResource || type == InspectorPageAgent::XHRResource;
 }
 
-static PassRefPtr<TextResourceDecoder> createXHRTextDecoder(const String& mimeType, const String& textEncodingName)
+PassRefPtr<TextResourceDecoder> InspectorPageAgent::createXHRTextDecoder(const String& mimeType, const String& textEncodingName)
 {
     RefPtr<TextResourceDecoder> decoder;
     if (!textEncodingName.isEmpty())
         decoder = TextResourceDecoder::create("text/plain", textEncodingName);
     else if (DOMImplementation::isXMLMIMEType(mimeType.lower())) {
         decoder = TextResourceDecoder::create("application/xml");
         decoder->useLenientXMLDecoding();
     } else if (equalIgnoringCase(mimeType, "text/html"))
         decoder = TextResourceDecoder::create("text/html", "UTF-8");
     else
         decoder = TextResourceDecoder::create("text/plain", "UTF-8");
     return decoder;
 }
 
-bool InspectorPageAgent::cachedResourceContent(Resource* cachedResource, String* result, bool* base64Encoded)
+bool InspectorPageAgent::cachedResourceContentOrBlob(Resource* cachedResource, String* result, bool* base64Encoded, RefPtr<Blob>* blob, String* textEncodingName)
 {
     bool hasZeroSize;
-    bool prepared = prepareResourceBuffer(cachedResource, &hasZeroSize);
+    bool hasBlob;
+    bool prepared = prepareResourceBuffer(cachedResource, &hasZeroSize, &hasBlob);
     if (!prepared)
         return false;
 
+    if (hasBlob) {
+        const String& filePath = cachedResource->response().downloadedFilePath();
+        OwnPtr<BlobData> blobData = BlobData::create();
+        blobData->appendFile(filePath);
+        blobData->setContentType(cachedResource->response().mimeType());
+        *blob = Blob::create(blobData.release(), cachedResource->encodedSize());
+        *textEncodingName = cachedResource->response().textEncodingName();
+        return true;
+    }
+
     *base64Encoded = !hasTextContent(cachedResource);
     if (*base64Encoded) {
         RefPtr<SharedBuffer> buffer = hasZeroSize ? SharedBuffer::create() : cachedResource->resourceBuffer();
 
         if (!buffer)
             return false;
 
         *result = base64Encode(buffer->data(), buffer->size());
         return true;
     }
@@ skipping 48 matching lines @@
 
     return decodeBuffer(data, size, textEncodingName, result);
 }
 
 PassOwnPtr<InspectorPageAgent> InspectorPageAgent::create(InstrumentingAgents* instrumentingAgents, Page* page, InspectorCompositeState* state, InjectedScriptManager* injectedScriptManager, InspectorClient* client, InspectorOverlay* overlay)
 {
     return adoptPtr(new InspectorPageAgent(instrumentingAgents, page, state, injectedScriptManager, client, overlay));
 }
 
 // static
-void InspectorPageAgent::resourceContent(ErrorString* errorString, Frame* frame, const KURL& url, String* result, bool* base64Encoded)
+void InspectorPageAgent::resourceContentOrBlob(ErrorString* errorString, Frame* frame, const KURL& url, String* result, bool* base64Encoded, RefPtr<Blob>* blob, String* textEncodingName)
 {
     DocumentLoader* loader = assertDocumentLoader(errorString, frame);
     if (!loader)
         return;
-    if (!cachedResourceContent(cachedResource(frame, url), result, base64Encoded))
+    if (!cachedResourceContentOrBlob(cachedResource(frame, url), result, base64Encoded, blob, textEncodingName))
         *errorString = "No resource with given URL found";
 }
 
 Resource* InspectorPageAgent::cachedResource(Frame* frame, const KURL& url)
 {
     Resource* cachedResource = frame->document()->fetcher()->cachedResource(url);
     if (!cachedResource)
         cachedResource = memoryCache()->resourceForURL(url);
     return cachedResource;
 }
@@ skipping 299 matching lines @@
     KURL parsedURL(ParsedURLString, url);
     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext(m_page->mainFrame()))
         WebCore::deleteCookie(frame->document(), parsedURL, cookieName);
 }
 
 void InspectorPageAgent::getResourceTree(ErrorString*, RefPtr<TypeBuilder::Page::FrameResourceTree>& object)
 {
     object = buildObjectForFrameTree(m_page->mainFrame());
 }
 
-void InspectorPageAgent::getResourceContent(ErrorString* errorString, const String& frameId, const String& url, String* content, bool* base64Encoded)
+void InspectorPageAgent::getResourceContent(ErrorString* errorString, const String& frameId, const String& url, PassRefPtr<GetResourceContentCallback> prpCallback)
 {
+    RefPtr<GetResourceContentCallback> callback = prpCallback;
+    if (!callback->isActive())
+        return;
+
     Frame* frame = assertFrame(errorString, frameId);
     if (!frame)
         return;
-    resourceContent(errorString, frame, KURL(ParsedURLString, url), content, base64Encoded);
+
+    Document* document = frame->document();
+    if (!document) {
+        *errorString = "No Document instance for the specified frame";
+        return;
+    }
+
+    String content;
+    bool base64Encoded;
+    RefPtr<Blob> blob;
+    String textEncodingName;
+    resourceContentOrBlob(errorString, frame, KURL(ParsedURLString, url), &content, &base64Encoded, &blob, &textEncodingName);
+    if (!errorString->isEmpty())
+        return;
+
+    if (blob) {
+        InspectorPageFileReaderLoaderClient* client = new InspectorPageFileReaderLoaderClient(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);
+    }
 }
 
 static bool textContentForResource(Resource* cachedResource, String* result)
 {
     if (hasTextContent(cachedResource)) {
         String content;
         bool base64Encoded;
-        if (InspectorPageAgent::cachedResourceContent(cachedResource, result, &base64Encoded)) {
+        RefPtr<Blob> blob;
+        String textEncodingName;
+        if (InspectorPageAgent::cachedResourceContentOrBlob(cachedResource, result, &base64Encoded, &blob, &textEncodingName)) {
             ASSERT(!base64Encoded);
-            return true;
+            if (!blob)
+                return true;
         }
     }
     return false;
 }
 
 void InspectorPageAgent::searchInResource(ErrorString*, const String& frameId, const String& url, const String& query, const bool* const optionalCaseSensitive, const bool* const optionalIsRegex, RefPtr<TypeBuilder::Array<TypeBuilder::Page::SearchMatch> >& results)
 {
     results = TypeBuilder::Array<TypeBuilder::Page::SearchMatch>::create();
 
     bool isRegex = optionalIsRegex ? *optionalIsRegex : false;
@@ skipping 698 matching lines @@
 }
 
 void InspectorPageAgent::setShowViewportSizeOnResize(ErrorString*, bool show, const bool* showGrid)
 {
     m_state->setBoolean(PageAgentState::showSizeOnResize, show);
     m_state->setBoolean(PageAgentState::showGridOnResize, showGrid && *showGrid);
 }
 
 } // namespace WebCore