DevTools: Support asynchronous loading of resources without cross origin checks through backend for…

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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/inspector/InspectorResourceAgent.h"
 
 #include "InspectorFrontend.h"
 #include "bindings/v8/ScriptCallStackFactory.h"
 #include "core/dom/Document.h"
+#include "core/dom/Event.h"
+#include "core/dom/EventListener.h"
+#include "core/dom/EventTarget.h"
+#include "core/dom/ExceptionCode.h"
 #include "core/dom/ExceptionCodePlaceholder.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectorClient.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InspectorValues.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/NetworkResourcesData.h"
 #include "core/inspector/ScriptCallStack.h"
@@ skipping 16 matching lines @@
 #include "modules/websockets/WebSocketFrame.h"
 #include "modules/websockets/WebSocketHandshakeRequest.h"
 #include "modules/websockets/WebSocketHandshakeResponse.h"
 #include <wtf/CurrentTime.h>
 #include <wtf/HexNumber.h>
 #include <wtf/ListHashSet.h>
 #include <wtf/MemoryInstrumentationHashMap.h>
 #include <wtf/RefPtr.h>
 #include <wtf/text/StringBuilder.h>
 
+typedef WebCore::InspectorBackendDispatcher::NetworkCommandHandler::LoadResourceForFrontendCallback LoadResourceForFrontendCallback;
+
 namespace WebCore {
 
 namespace ResourceAgentState {
 static const char resourceAgentEnabled[] = "resourceAgentEnabled";
 static const char extraRequestHeaders[] = "extraRequestHeaders";
 static const char cacheDisabled[] = "cacheDisabled";
 static const char userAgentOverride[] = "userAgentOverride";
 }
 
+namespace {
+
+class SendXHRCallback : public EventListener {
+    WTF_MAKE_NONCOPYABLE(SendXHRCallback);
+public:
+    static PassRefPtr<SendXHRCallback> create(PassRefPtr<LoadResourceForFrontendCallback> callback)
+    {
+        return adoptRef(new SendXHRCallback(callback));
+    }
+
+    virtual ~SendXHRCallback() { }
+
+    virtual bool operator==(const EventListener& other) OVERRIDE
+    {
+        return this == &other;
+    }
+
+    virtual void handleEvent(ScriptExecutionContext*, Event* event) OVERRIDE
+    {
+        if (!m_callback->isActive())
+            return;
+        if (event->type() == eventNames().errorEvent) {
+            m_callback->sendFailure("Error loading resource.");
+            return;
+        }
+        if (event->type() != eventNames().readystatechangeEvent) {
+            m_callback->sendFailure("Unexpected event type.");
+            return;
+        }
+
+        XMLHttpRequest* xhr = static_cast<XMLHttpRequest*>(event->target());
+        if (xhr->readyState() != XMLHttpRequest::DONE)
+            return;
+
+        String responseText = xhr->responseText(IGNORE_EXCEPTION);
+        m_callback->sendSuccess(responseText);
+    }
+
+private:
+    SendXHRCallback(PassRefPtr<LoadResourceForFrontendCallback> callback)
+        : EventListener(EventListener::CPPEventListenerType)
+        , m_callback(callback) { }
+    RefPtr<LoadResourceForFrontendCallback> m_callback;
+};
+
+} // namespace
+
 void InspectorResourceAgent::setFrontend(InspectorFrontend* frontend)
 {
     m_frontend = frontend->network();
 }
 
 void InspectorResourceAgent::clearFrontend()
 {
     m_frontend = 0;
     ErrorString error;
     disable(&error);
@@ skipping 514 matching lines @@
         return;
 
     CachedResource* cachedResource = memoryCache()->resourceForURL(xhrReplayData->url());
     if (cachedResource)
         memoryCache()->remove(cachedResource);
 
     xhr->open(xhrReplayData->method(), xhrReplayData->url(), xhrReplayData->async(), IGNORE_EXCEPTION);
     HTTPHeaderMap::const_iterator end = xhrReplayData->headers().end();
     for (HTTPHeaderMap::const_iterator it = xhrReplayData->headers().begin(); it!= end; ++it)
         xhr->setRequestHeader(it->key, it->value, IGNORE_EXCEPTION);
-    xhr->sendFromInspector(xhrReplayData->formData(), IGNORE_EXCEPTION);
+    xhr->sendForInspectorXHRReplay(xhrReplayData->formData(), IGNORE_EXCEPTION);
 }
 
 void InspectorResourceAgent::canClearBrowserCache(ErrorString*, bool* result)
 {
     *result = true;
 }
 
 void InspectorResourceAgent::clearBrowserCache(ErrorString*)
 {
     m_client->clearBrowserCache();
 }
 
 void InspectorResourceAgent::canClearBrowserCookies(ErrorString*, bool* result)
 {
     *result = true;
 }
 
 void InspectorResourceAgent::clearBrowserCookies(ErrorString*)
 {
     m_client->clearBrowserCookies();
 }
 
 void InspectorResourceAgent::setCacheDisabled(ErrorString*, bool cacheDisabled)
 {
     m_state->setBoolean(ResourceAgentState::cacheDisabled, cacheDisabled);
     if (cacheDisabled)
         memoryCache()->evictResources();
 }
 
+void InspectorResourceAgent::loadResourceForFrontend(ErrorString* errorString, const String& frameId, const String& url, PassRefPtr<LoadResourceForFrontendCallback> callback)
+{
+    Frame* frame = m_pageAgent->assertFrame(errorString, frameId);
+    if (!frame)
+        return;
+
+    Document* document = frame->document();
+    if (!document) {
+        *errorString = "No Document instance for the specified frame";
+        return;
+    }
+
+    RefPtr<XMLHttpRequest> xhr = XMLHttpRequest::create(document);
+
+    KURL kurl = KURL(ParsedURLString, url);
+    if (kurl.isLocalFile()) {
+        *errorString = "Can not load local file";
+        return;
+    }
+
+    ExceptionCode ec = 0;
+    xhr->open(ASCIILiteral("GET"), kurl, ec);
+    if (ec) {
+        *errorString = "Error opening an XMLHttpRequest";
+        return;
+    }
+
+    RefPtr<SendXHRCallback> sendXHRCallback = SendXHRCallback::create(callback);
+    xhr->addEventListener(eventNames().abortEvent, sendXHRCallback, false);
+    xhr->addEventListener(eventNames().errorEvent, sendXHRCallback, false);
+    xhr->addEventListener(eventNames().readystatechangeEvent, sendXHRCallback, false);
+    xhr->sendForInspector(ec);
+    if (ec) {
+        *errorString = "Error sending an XMLHttpRequest";
+        return;
+    }
+}
+
 void InspectorResourceAgent::didCommitLoad(Frame* frame, DocumentLoader* loader)
 {
     if (loader->frame() != frame->page()->mainFrame())
         return;
 
     if (m_state->getBoolean(ResourceAgentState::cacheDisabled))
         memoryCache()->evictResources();
 
     m_resourcesData->clear(m_pageAgent->loaderId(loader));
 }
@@ skipping 17 matching lines @@
     , m_client(client)
     , m_frontend(0)
     , m_resourcesData(adoptPtr(new NetworkResourcesData()))
     , m_loadingXHRSynchronously(false)
     , m_isRecalculatingStyle(false)
 {
 }
 
 } // namespace WebCore