DevTools: remove dependency of most agents on InspectorPageAgent

Source/core/inspector/InspectorApplicationCacheAgent.cpp

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 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:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 10 matching lines @@
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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/InspectorApplicationCacheAgent.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/inspector/InspectorIdentifiers.h"
-#include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/page/NetworkStateNotifier.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 namespace ApplicationCacheAgentState {
 static const char applicationCacheAgentEnabled[] = "applicationCacheAgentEnabled";
 }
 
-InspectorApplicationCacheAgent::InspectorApplicationCacheAgent(InspectorPageAgent* pageAgent)
+InspectorApplicationCacheAgent::InspectorApplicationCacheAgent(LocalFrame* inspectedFrame)
     : InspectorBaseAgent<InspectorApplicationCacheAgent, InspectorFrontend::ApplicationCache>("ApplicationCache")
-    , m_pageAgent(pageAgent)
+    , m_inspectedFrame(inspectedFrame)
 {
 }
 
 void InspectorApplicationCacheAgent::restore()
 {
     if (m_state->getBoolean(ApplicationCacheAgentState::applicationCacheAgentEnabled)) {
         ErrorString error;
         enable(&error);
     }
 }
@@ skipping 21 matching lines @@
     ApplicationCacheHost::Status status = host->status();
     ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
 
     String manifestURL = info.m_manifest.string();
     String frameId = InspectorIdentifiers<LocalFrame>::identifier(frame);
     frontend()->applicationCacheStatusUpdated(frameId, manifestURL, static_cast<int>(status));
 }
 
 void InspectorApplicationCacheAgent::networkStateChanged(LocalFrame* frame, bool online)
 {
-    if (frame == m_pageAgent->inspectedFrame())
+    if (frame == m_inspectedFrame)
         frontend()->networkStateUpdated(online);
 }
 
 void InspectorApplicationCacheAgent::getFramesWithManifests(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::FrameWithManifest> >& result)
 {
     result = TypeBuilder::Array<TypeBuilder::ApplicationCache::FrameWithManifest>::create();
 
-    LocalFrame* inspectedFrame = m_pageAgent->inspectedFrame();
-    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;
         DocumentLoader* documentLoader = toLocalFrame(frame)->loader().documentLoader();
         if (!documentLoader)
             continue;
 
         ApplicationCacheHost* host = documentLoader->applicationCacheHost();
         ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
         String manifestURL = info.m_manifest.string();
         if (!manifestURL.isEmpty()) {
             RefPtr<TypeBuilder::ApplicationCache::FrameWithManifest> value = TypeBuilder::ApplicationCache::FrameWithManifest::create()
                 .setFrameId(InspectorIdentifiers<LocalFrame>::identifier(toLocalFrame(frame)))
                 .setManifestURL(manifestURL)
                 .setStatus(static_cast<int>(host->status()));
             result->addItem(value);
         }
     }
 }
 
 DocumentLoader* InspectorApplicationCacheAgent::assertFrameWithDocumentLoader(ErrorString* errorString, String frameId)
 {
-    LocalFrame* frame = m_pageAgent->assertFrame(errorString, frameId);
-    if (!frame)
+    LocalFrame* frame = InspectorIdentifiers<LocalFrame>::lookup(frameId);
+    if (!frame || frame->instrumentingAgents() != m_inspectedFrame->instrumentingAgents()) {
+        *errorString = "No frame for given id found";
         return nullptr;
-
-    return InspectorPageAgent::assertDocumentLoader(errorString, frame);
+    }
+    DocumentLoader* documentLoader = frame->loader().documentLoader();
+    if (!documentLoader) {
+        *errorString = "No documentLoader for given frame found";
+        return nullptr;
+    }
+    return documentLoader;
 }
 
 void InspectorApplicationCacheAgent::getManifestForFrame(ErrorString* errorString, const String& frameId, String* manifestURL)
 {
     DocumentLoader* documentLoader = assertFrameWithDocumentLoader(errorString, frameId);
     if (!documentLoader)
         return;
 
     ApplicationCacheHost::CacheInfo info = documentLoader->applicationCacheHost()->applicationCacheInfo();
     *manifestURL = info.m_manifest.string();
@@ skipping 57 matching lines @@
 
     RefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> value = TypeBuilder::ApplicationCache::ApplicationCacheResource::create()
         .setUrl(resourceInfo.m_resource.string())
         .setSize(static_cast<int>(resourceInfo.m_size))
         .setType(builder.toString());
     return value;
 }
 
 DEFINE_TRACE(InspectorApplicationCacheAgent)
 {
-    visitor->trace(m_pageAgent);
+    visitor->trace(m_inspectedFrame);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink