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);

[dgozman, 2015/04/24 13:16:14]

Won't this crash now?

[caseq, 2015/04/24 13:50:55]

It doesn't on tests, at least. We don't seem to use loader in
cachedResourceContent() and we've got other calls that don't assert the loader
before calling cachedResourceContent() (in general, it would make sense for
cachedResourceContent() to take care of all implicit pre-requisites).

-    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(inspectedFrame()));
+    m_inspectorResourceContentLoader = adoptPtrWillBeNoop(new InspectorResourceContentLoader(m_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;
-    inspectedFrame()->reload(asBool(optionalIgnoreCache) ? EndToEndReload : NormalReload, NotClientRedirect);
+    m_inspectedFrame->reload(asBool(optionalIgnoreCache) ? EndToEndReload : NormalReload, NotClientRedirect);
 }
 
 void InspectorPageAgent::navigate(ErrorString*, const String& url, String* outFrameId)
 {
-    *outFrameId = frameId(inspectedFrame());
+    *outFrameId = frameId(m_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(inspectedFrame());
+    object = buildObjectForFrameTree(m_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 = frameForId(frameId);
+    LocalFrame* frame = InspectorResolver::resolveFrame(m_inspectedFrame, 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 != inspectedFrame())
+    if (frame != m_inspectedFrame)
         return;
     frontend()->domContentEventFired(monotonicallyIncreasingTime());
 }
 
 void InspectorPageAgent::loadEventFired(LocalFrame* frame)
 {
-    if (frame != inspectedFrame())
+    if (frame != m_inspectedFrame)
         return;
     frontend()->loadEventFired(monotonicallyIncreasingTime());
 }
 
 void InspectorPageAgent::didCommitLoad(LocalFrame*, DocumentLoader* loader)
 {
-    if (loader->frame() == inspectedFrame()) {
+    if (loader->frame() == m_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())) {
+    for (Frame* frame = m_inspectedFrame; frame; frame = frame->tree().traverseNext(m_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 = frameForId(frameId);
+    LocalFrame* frame = InspectorResolver::resolveFrame(m_inspectedFrame, 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 (!inspectedFrame()->isMainFrame())
+    if (!m_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