Revert of DevTools: remove dependency of most agents on InspectorPageAgent

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 38 matching lines @@
 #include "core/html/imports/HTMLImportLoader.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/inspector/ContentSearchUtils.h"
 #include "core/inspector/DOMPatchSupport.h"
 #include "core/inspector/InspectorCSSAgent.h"
 #include "core/inspector/InspectorDebuggerAgent.h"
 #include "core/inspector/InspectorIdentifiers.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorOverlay.h"
-#include "core/inspector/InspectorResolver.h"
 #include "core/inspector/InspectorResourceContentLoader.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "platform/JSONValues.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/PlatformResourceLoader.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/weborigin/SecurityOrigin.h"
@@ skipping 123 matching lines @@
         return TextResourceDecoder::create("text/html", "UTF-8");
     if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType) || DOMImplementation::isJSONMIMEType(mimeType))
         return TextResourceDecoder::create("text/plain", "UTF-8");
     if (DOMImplementation::isTextMIMEType(mimeType))
         return TextResourceDecoder::create("text/plain", "ISO-8859-1");
     return PassOwnPtr<TextResourceDecoder>();
 }
 
 static void resourceContent(ErrorString* errorString, LocalFrame* frame, const KURL& url, String* result, bool* base64Encoded)
 {
+    DocumentLoader* loader = InspectorPageAgent::assertDocumentLoader(errorString, frame);
+    if (!loader)
+        return;
+
     if (!InspectorPageAgent::cachedResourceContent(InspectorPageAgent::cachedResource(frame, url), result, base64Encoded))
         *errorString = "No resource with given URL found";
 }
 
 static bool encodeCachedResourceContent(Resource* cachedResource, bool hasZeroSize, String* result, bool* base64Encoded)
 {
     *base64Encoded = true;
     RefPtr<SharedBuffer> buffer = hasZeroSize ? SharedBuffer::create() : cachedResource->resourceBuffer();
 
     if (!buffer)
@@ skipping 173 matching lines @@
     }
 }
 
 void InspectorPageAgent::enable(ErrorString*)
 {
     m_enabled = true;
     m_state->setBoolean(PageAgentState::pageAgentEnabled, true);
     m_instrumentingAgents->setInspectorPageAgent(this);
     if (m_inspectorResourceContentLoader)
         m_inspectorResourceContentLoader->dispose();
-    m_inspectorResourceContentLoader = adoptPtrWillBeNoop(new InspectorResourceContentLoader(m_inspectedFrame));
+    m_inspectorResourceContentLoader = adoptPtrWillBeNoop(new InspectorResourceContentLoader(inspectedFrame()));
 }
 
 void InspectorPageAgent::discardAgent()
 {
     if (!m_inspectorResourceContentLoader)
         return;
     m_inspectorResourceContentLoader->dispose();
     m_inspectorResourceContentLoader.clear();
 }
 
@@ skipping 41 matching lines @@
     }
     scripts->remove(identifier);
 }
 
 void InspectorPageAgent::reload(ErrorString*, const bool* const optionalIgnoreCache, const String* optionalScriptToEvaluateOnLoad)
 {
     m_pendingScriptToEvaluateOnLoadOnce = optionalScriptToEvaluateOnLoad ? *optionalScriptToEvaluateOnLoad : "";
     ErrorString unused;
     m_debuggerAgent->setSkipAllPauses(&unused, true);
     m_reloading = true;
-    m_inspectedFrame->reload(asBool(optionalIgnoreCache) ? EndToEndReload : NormalReload, NotClientRedirect);
+    inspectedFrame()->reload(asBool(optionalIgnoreCache) ? EndToEndReload : NormalReload, NotClientRedirect);
 }
 
 void InspectorPageAgent::navigate(ErrorString*, const String& url, String* outFrameId)
 {
-    *outFrameId = frameId(m_inspectedFrame);
+    *outFrameId = frameId(inspectedFrame());
 }
 
 static void cachedResourcesForDocument(Document* document, Vector<Resource*>& result, bool skipXHRs)
 {
     const ResourceFetcher::DocumentResourceMap& allResources = document->fetcher()->allResources();
     for (const auto& resource : allResources) {
         Resource* cachedResource = resource.value.get();
 
         switch (cachedResource->type()) {
         case Resource::Image:
@@ skipping 43 matching lines @@
 
     cachedResourcesForDocument(rootDocument, result, skipXHRs);
     for (size_t i = 0; i < loaders.size(); ++i)
         cachedResourcesForDocument(loaders[i], result, skipXHRs);
 
     return result;
 }
 
 void InspectorPageAgent::getResourceTree(ErrorString*, RefPtr<TypeBuilder::Page::FrameResourceTree>& object)
 {
-    object = buildObjectForFrameTree(m_inspectedFrame);
+    object = buildObjectForFrameTree(inspectedFrame());
 }
 
 void InspectorPageAgent::finishReload()
 {
     if (!m_reloading)
         return;
     m_reloading = false;
     ErrorString unused;
     m_debuggerAgent->setSkipAllPauses(&unused, false);
 }
@@ skipping 40 matching lines @@
             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::Debugger::SearchMatch>>& results)
 {
     results = TypeBuilder::Array<TypeBuilder::Debugger::SearchMatch>::create();
 
-    LocalFrame* frame = InspectorResolver::resolveFrame(m_inspectedFrame, frameId);
+    LocalFrame* frame = frameForId(frameId);
     KURL kurl(ParsedURLString, url);
 
     FrameLoader* frameLoader = frame ? &frame->loader() : nullptr;
     DocumentLoader* loader = frameLoader ? frameLoader->documentLoader() : nullptr;
     if (!loader)
         return;
 
     String content;
     bool success = false;
     Resource* resource = cachedResource(frame, kurl);
@@ skipping 32 matching lines @@
             if (script.value->asString(&scriptText))
                 frame->script().executeScriptInMainWorld(scriptText);
         }
     }
     if (!m_scriptToEvaluateOnLoadOnce.isEmpty())
         frame->script().executeScriptInMainWorld(m_scriptToEvaluateOnLoadOnce);
 }
 
 void InspectorPageAgent::domContentLoadedEventFired(LocalFrame* frame)
 {
-    if (frame != m_inspectedFrame)
+    if (frame != inspectedFrame())
         return;
     frontend()->domContentEventFired(monotonicallyIncreasingTime());
 }
 
 void InspectorPageAgent::loadEventFired(LocalFrame* frame)
 {
-    if (frame != m_inspectedFrame)
+    if (frame != inspectedFrame())
         return;
     frontend()->loadEventFired(monotonicallyIncreasingTime());
 }
 
 void InspectorPageAgent::didCommitLoad(LocalFrame*, DocumentLoader* loader)
 {
-    if (loader->frame() == m_inspectedFrame) {
+    if (loader->frame() == inspectedFrame()) {
         finishReload();
         m_scriptToEvaluateOnLoadOnce = m_pendingScriptToEvaluateOnLoadOnce;
         m_pendingScriptToEvaluateOnLoadOnce = String();
         if (m_inspectorResourceContentLoader)
             m_inspectorResourceContentLoader->stop();
     }
     frontend()->frameNavigated(buildObjectForFrame(loader->frame()));
 }
 
 void InspectorPageAgent::frameAttachedToParent(LocalFrame* frame)
 {
     Frame* parentFrame = frame->tree().parent();
     if (!parentFrame->isLocalFrame())
         parentFrame = 0;
     frontend()->frameAttached(frameId(frame), frameId(toLocalFrame(parentFrame)));
 }
 
 void InspectorPageAgent::frameDetachedFromParent(LocalFrame* frame)
 {
     frontend()->frameDetached(frameId(frame));
 }
 
+FrameHost* InspectorPageAgent::frameHost()
+{
+    return m_inspectedFrame->host();
+}
+
+LocalFrame* InspectorPageAgent::frameForId(const String& frameId)
+{
+    LocalFrame* frame = InspectorIdentifiers<LocalFrame>::lookup(frameId);
+    return frame && frame->instrumentingAgents() == m_inspectedFrame->instrumentingAgents() ? frame : nullptr;
+}
+
+LocalFrame* InspectorPageAgent::findFrameWithSecurityOrigin(const String& originRawString)
+{
+    for (Frame* frame = inspectedFrame(); frame; frame = frame->tree().traverseNext(inspectedFrame())) {
+        if (!frame->isLocalFrame())
+            continue;
+        RefPtr<SecurityOrigin> documentOrigin = toLocalFrame(frame)->document()->securityOrigin();
+        if (documentOrigin->toRawString() == originRawString)
+            return toLocalFrame(frame);
+    }
+    return nullptr;
+}
+
 LocalFrame* InspectorPageAgent::assertFrame(ErrorString* errorString, const String& frameId)
 {
-    LocalFrame* frame = InspectorResolver::resolveFrame(m_inspectedFrame, frameId);
+    LocalFrame* frame = frameForId(frameId);
     if (!frame)
         *errorString = "No frame for given id found";
     return frame;
 }
 
 bool InspectorPageAgent::screencastEnabled()
 {
     return m_enabled && m_state->getBoolean(PageAgentState::screencastEnabled);
 }
 
+// static
+DocumentLoader* InspectorPageAgent::assertDocumentLoader(ErrorString* errorString, LocalFrame* frame)
+{
+    DocumentLoader* documentLoader = frame->loader().documentLoader();
+    if (!documentLoader)
+        *errorString = "No documentLoader for given frame found";
+    return documentLoader;
+}
+
 void InspectorPageAgent::frameStartedLoading(LocalFrame* frame)
 {
     frontend()->frameStartedLoading(frameId(frame));
 }
 
 void InspectorPageAgent::frameStoppedLoading(LocalFrame* frame)
 {
     frontend()->frameStoppedLoading(frameId(frame));
 }
 
@@ skipping 25 matching lines @@
 }
 
 void InspectorPageAgent::didScroll()
 {
     if (m_enabled)
         m_overlay->update();
 }
 
 void InspectorPageAgent::didResizeMainFrame()
 {
-    if (!m_inspectedFrame->isMainFrame())
+    if (!inspectedFrame()->isMainFrame())
         return;
 #if !OS(ANDROID)
     if (m_enabled && m_state->getBoolean(PageAgentState::showSizeOnResize))
         m_overlay->showAndHideViewSize(m_state->getBoolean(PageAgentState::showGridOnResize));
 #endif
     frontend()->frameResized();
 }
 
 void InspectorPageAgent::didRecalculateStyle(int)
 {
@@ skipping 91 matching lines @@
 {
     visitor->trace(m_inspectedFrame);
     visitor->trace(m_debuggerAgent);
     visitor->trace(m_cssAgent);
     visitor->trace(m_overlay);
     visitor->trace(m_inspectorResourceContentLoader);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink