DevTools: use per-LocalFrame instrumenting agents instead of per-Page ones.

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 484 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_page));
+    m_inspectorResourceContentLoader = adoptPtrWillBeNoop(new InspectorResourceContentLoader(inspectedFrame()));
 }
 
 void InspectorPageAgent::discardAgent()
 {
     if (!m_inspectorResourceContentLoader)
         return;
     m_inspectorResourceContentLoader->dispose();
     m_inspectorResourceContentLoader.clear();
 }
 
@@ skipping 65 matching lines @@
         *error = "Script not found";
         return;
     }
     scripts->remove(identifier);
 }
 
 void InspectorPageAgent::reload(ErrorString*, const bool* const optionalIgnoreCache, const String* optionalScriptToEvaluateOnLoad, const String* optionalScriptPreprocessor)
 {
     m_pendingScriptToEvaluateOnLoadOnce = optionalScriptToEvaluateOnLoad ? *optionalScriptToEvaluateOnLoad : "";
     m_pendingScriptPreprocessor = optionalScriptPreprocessor ? *optionalScriptPreprocessor : "";
-    m_page->mainFrame()->reload(asBool(optionalIgnoreCache) ? EndToEndReload : NormalReload, NotClientRedirect);
+    inspectedFrame()->reload(asBool(optionalIgnoreCache) ? EndToEndReload : NormalReload, NotClientRedirect);
 }
 
 void InspectorPageAgent::navigate(ErrorString*, const String& url, String* outFrameId)
 {
-    LocalFrame* frame = m_page->deprecatedLocalMainFrame();
-    *outFrameId = frameId(frame);
+    *outFrameId = frameId(inspectedFrame());
 }
 
 static PassRefPtr<TypeBuilder::Page::Cookie> buildObjectForCookie(const Cookie& cookie)
 {
     return TypeBuilder::Page::Cookie::create()
         .setName(cookie.name)
         .setValue(cookie.value)
         .setDomain(cookie.domain)
         .setPath(cookie.path)
         .setExpires(cookie.expires)
@@ skipping 85 matching lines @@
     for (const auto& resource : allResources)
         result.append(urlWithoutFragment(resource->url()));
 
     return result;
 }
 
 void InspectorPageAgent::getCookies(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::Page::Cookie> >& cookies)
 {
     ListHashSet<Cookie> rawCookiesList;
 
-    for (Frame* frame = mainFrame(); frame; frame = frame->tree().traverseNext(mainFrame())) {
+    for (Frame* frame = inspectedFrame(); frame; frame = frame->tree().traverseNext(inspectedFrame())) {
         if (!frame->isLocalFrame())
             continue;
         Document* document = toLocalFrame(frame)->document();
         Vector<KURL> allURLs = allResourcesURLsForFrame(toLocalFrame(frame));
         for (const auto& url : allURLs) {
             Vector<Cookie> docCookiesList;
             getRawCookies(document, url, docCookiesList);
             int cookiesSize = docCookiesList.size();
             for (int i = 0; i < cookiesSize; i++) {
                 if (!rawCookiesList.contains(docCookiesList[i]))
                     rawCookiesList.add(docCookiesList[i]);
             }
         }
     }
 
     cookies = buildArrayForCookies(rawCookiesList);
 }
 
 void InspectorPageAgent::deleteCookie(ErrorString*, const String& cookieName, const String& url)
 {
     KURL parsedURL(ParsedURLString, url);
-    for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext(m_page->mainFrame())) {
+    for (Frame* frame = inspectedFrame(); frame; frame = frame->tree().traverseNext(inspectedFrame())) {
         if (frame->isLocalFrame())
             blink::deleteCookie(toLocalFrame(frame)->document(), parsedURL, cookieName);
     }
 }
 
 void InspectorPageAgent::getResourceTree(ErrorString*, RefPtr<TypeBuilder::Page::FrameResourceTree>& object)
 {
-    object = buildObjectForFrameTree(m_page->deprecatedLocalMainFrame());
+    object = buildObjectForFrameTree(inspectedFrame());
 }
 
 void InspectorPageAgent::getResourceContentAfterResourcesContentLoaded(const String& frameId, const String& url, PassRefPtrWillBeRawPtr<GetResourceContentCallback> callback)
 {
     ErrorString errorString;
     LocalFrame* frame = assertFrame(&errorString, frameId);
     if (!frame) {
         callback->sendFailure(errorString);
         return;
     }
@@ skipping 158 matching lines @@
         || scale != currentScale
         || offsetX != currentOffsetX
         || offsetY != currentOffsetY;
 }
 
 void InspectorPageAgent::setShowPaintRects(ErrorString*, bool show)
 {
     m_state->setBoolean(PageAgentState::pageAgentShowPaintRects, show);
     m_client->setShowPaintRects(show);
 
-    if (!show && mainFrame() && mainFrame()->view())
-        mainFrame()->view()->invalidate();
+    if (!show && inspectedFrame() && inspectedFrame()->isMainFrame() && inspectedFrame()->view())
+        inspectedFrame()->view()->invalidate();
 }
 
 void InspectorPageAgent::setShowDebugBorders(ErrorString* errorString, bool show)
 {
     m_state->setBoolean(PageAgentState::pageAgentShowDebugBorders, show);
     if (show && !compositingEnabled(errorString))
         return;
     m_client->setShowDebugBorders(show);
 }
 
@@ skipping 19 matching lines @@
     m_state->setBoolean(PageAgentState::pageAgentShowScrollBottleneckRects, show);
     if (show && !compositingEnabled(errorString))
         return;
     m_client->setShowScrollBottleneckRects(show);
 }
 
 void InspectorPageAgent::getScriptExecutionStatus(ErrorString*, PageCommandHandler::Result::Enum* status)
 {
     bool disabledByScriptController = false;
     bool disabledInSettings = false;
-    LocalFrame* frame = mainFrame();
+    LocalFrame* frame = inspectedFrame();
     if (frame) {
         disabledByScriptController = !frame->script().canExecuteScripts(NotAboutToExecuteScript);
         if (frame->settings())
             disabledInSettings = !frame->settings()->scriptEnabled();
     }
 
     // Order is important.
     if (disabledInSettings)
         *status = PageCommandHandler::Result::Disabled;
     else if (disabledByScriptController)
         *status = PageCommandHandler::Result::Forbidden;
     else
         *status = PageCommandHandler::Result::Allowed;
 }
 
 void InspectorPageAgent::setScriptExecutionDisabled(ErrorString*, bool value)
 {
     m_state->setBoolean(PageAgentState::pageAgentScriptExecutionDisabled, value);
-    if (!mainFrame())
+    if (!inspectedFrame())
         return;
 
-    Settings* settings = mainFrame()->settings();
+    Settings* settings = inspectedFrame()->settings();
     if (settings) {
         m_ignoreScriptsEnabledNotification = true;
         settings->setScriptEnabled(!value);
         m_ignoreScriptsEnabledNotification = false;
     }
 }
 
 void InspectorPageAgent::didClearDocumentOfWindowObject(LocalFrame* frame)
 {
     if (!m_frontend)
         return;
 
     RefPtr<JSONObject> scripts = m_state->getObject(PageAgentState::pageAgentScriptsToEvaluateOnLoad);
     if (scripts) {
         for (const auto& script : *scripts) {
             String scriptText;
             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->isMainFrame())
+    if (frame != inspectedFrame())
         return;
     m_frontend->domContentEventFired(currentTime());
 }
 
 void InspectorPageAgent::loadEventFired(LocalFrame* frame)
 {
-    if (!frame->isMainFrame())
+    if (frame != inspectedFrame())
         return;
     m_frontend->loadEventFired(currentTime());
 }
 
 void InspectorPageAgent::didCommitLoad(LocalFrame*, DocumentLoader* loader)
 {
-    // FIXME: If "frame" is always guaranteed to be in the same Page as loader->frame()
-    // then all we need to check here is loader->frame()->isMainFrame()
-    // and we don't need "frame" at all.
-    if (loader->frame() == m_page->mainFrame()) {
+    if (loader->frame() == inspectedFrame()) {
         m_scriptToEvaluateOnLoadOnce = m_pendingScriptToEvaluateOnLoadOnce;
         m_scriptPreprocessorSource = m_pendingScriptPreprocessor;
         m_pendingScriptToEvaluateOnLoadOnce = String();
         m_pendingScriptPreprocessor = String();
         if (m_inspectorResourceContentLoader)
             m_inspectorResourceContentLoader->stop();
     }
     m_frontend->frameNavigated(buildObjectForFrame(loader->frame()));
     viewportChanged();
 }
 
 void InspectorPageAgent::frameAttachedToParent(LocalFrame* frame)
 {
     Frame* parentFrame = frame->tree().parent();
     if (!parentFrame->isLocalFrame())
         parentFrame = 0;
     m_frontend->frameAttached(frameId(frame), frameId(toLocalFrame(parentFrame)));
 }
 
 void InspectorPageAgent::frameDetachedFromParent(LocalFrame* frame)
 {
     HashMap<LocalFrame*, String>::iterator iterator = m_frameToIdentifier.find(frame);
     if (iterator != m_frameToIdentifier.end()) {
         m_frontend->frameDetached(iterator->value);
         m_identifierToFrame.remove(iterator->value);
         m_frameToIdentifier.remove(iterator);
     }
 }
 
-LocalFrame* InspectorPageAgent::mainFrame()
+FrameHost* InspectorPageAgent::frameHost()
+{
+    return &m_page->frameHost();
+}
+
+LocalFrame* InspectorPageAgent::inspectedFrame()
 {
     return m_page->deprecatedLocalMainFrame();
 }
 
 LocalFrame* InspectorPageAgent::frameForId(const String& frameId)
 {
     return frameId.isEmpty() ? nullptr : m_identifierToFrame.get(frameId);
 }
 
 String InspectorPageAgent::frameId(LocalFrame* frame)
@@ skipping 21 matching lines @@
     String identifier = m_loaderToIdentifier.get(loader);
     if (identifier.isNull()) {
         identifier = IdentifiersFactory::createIdentifier();
         m_loaderToIdentifier.set(loader, identifier);
     }
     return identifier;
 }
 
 LocalFrame* InspectorPageAgent::findFrameWithSecurityOrigin(const String& originRawString)
 {
-    for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
-        // FIXME: RemoteFrame security origins are not yet available.
+    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 = frameForId(frameId);
     if (!frame)
         *errorString = "No frame for given id found";
     return frame;
 }
 
 const AtomicString& InspectorPageAgent::resourceSourceMapURL(const String& url)
 {
     DEFINE_STATIC_LOCAL(const AtomicString, sourceMapHttpHeader, ("SourceMap", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, deprecatedSourceMapHttpHeader, ("X-SourceMap", AtomicString::ConstructFromLiteral));
     if (url.isEmpty())
         return nullAtom;
-    LocalFrame* frame = mainFrame();
+    LocalFrame* frame = inspectedFrame();
     if (!frame)
         return nullAtom;
     Resource* resource = cachedResource(frame, KURL(ParsedURLString, url));
     if (!resource)
         return nullAtom;
     const AtomicString& deprecatedHeaderSourceMapURL = resource->response().httpHeaderField(deprecatedSourceMapHttpHeader);
     if (!deprecatedHeaderSourceMapURL.isEmpty()) {
         // FIXME: add deprecated console message here.
         return deprecatedHeaderSourceMapURL;
     }
@@ skipping 83 matching lines @@
 
 void InspectorPageAgent::didScroll()
 {
     if (m_enabled)
         m_overlay->update();
     viewportChanged();
 }
 
 void InspectorPageAgent::viewportChanged()
 {
-    if (!m_enabled || !m_deviceMetricsOverridden)
+    if (!m_enabled || !m_deviceMetricsOverridden || !inspectedFrame()->isMainFrame())
         return;
-    IntSize contentsSize = m_page->deprecatedLocalMainFrame()->view()->contentsSize();
-    IntRect viewRect = m_page->deprecatedLocalMainFrame()->view()->visibleContentRect();
+    IntSize contentsSize = inspectedFrame()->view()->contentsSize();
+    IntRect viewRect = inspectedFrame()->view()->visibleContentRect();
     RefPtr<TypeBuilder::Page::Viewport> viewport = TypeBuilder::Page::Viewport::create()
         .setScrollX(viewRect.x())
         .setScrollY(viewRect.y())
         .setContentsWidth(contentsSize.width())
         .setContentsHeight(contentsSize.height())
         .setPageScaleFactor(m_page->pageScaleFactor())
         .setMinimumPageScaleFactor(m_client->minimumPageScaleFactor())
         .setMaximumPageScaleFactor(m_client->maximumPageScaleFactor());
     m_frontend->viewportChanged(viewport);
 }
 
 void InspectorPageAgent::didResizeMainFrame()
 {
+    if (!inspectedFrame()->isMainFrame())
+        return;
 #if !OS(ANDROID)
     if (m_enabled && m_state->getBoolean(PageAgentState::showSizeOnResize))
         m_overlay->showAndHideViewSize(m_state->getBoolean(PageAgentState::showGridOnResize));
 #endif
     m_frontend->frameResized();
     viewportChanged();
 }
 
 void InspectorPageAgent::didRecalculateStyle(int)
 {
@@ skipping 92 matching lines @@
     double scale = m_state->getDouble(PageAgentState::deviceScale, 1);
     double offsetX = m_state->getDouble(PageAgentState::deviceOffsetX, 0);
     double offsetY = m_state->getDouble(PageAgentState::deviceOffsetY, 0);
     updateViewMetrics(enabled, width, height, deviceScaleFactor, mobile, fitWindow, scale, offsetX, offsetY);
 }
 
 void InspectorPageAgent::updateViewMetrics(bool enabled, int width, int height, double deviceScaleFactor, bool mobile, bool fitWindow, double scale, double offsetX, double offsetY)
 {
     if (enabled && !m_page->settings().acceleratedCompositingEnabled())
         return;
+    if (!inspectedFrame()->isMainFrame())
+        return;
 
     m_deviceMetricsOverridden = enabled;
     m_emulateMobileEnabled = mobile;
     if (enabled)
         m_client->setDeviceMetricsOverride(width, height, static_cast<float>(deviceScaleFactor), mobile, fitWindow, static_cast<float>(scale), static_cast<float>(offsetX), static_cast<float>(offsetY));
     else
         m_client->clearDeviceMetricsOverride();
 
-    Document* document = mainFrame()->document();
+    Document* document = inspectedFrame()->document();
     if (document) {
         document->styleResolverChanged();
         document->mediaQueryAffectingValueChanged();
     }
 
     if (m_deviceMetricsOverridden) {
         m_page->settings().setTextAutosizingEnabled(mobile);
         m_page->settings().setPreferCompositingToLCDTextEnabled(mobile);
         m_page->settings().setDeviceScaleAdjustment(calculateFontScaleFactor(width, height, static_cast<float>(deviceScaleFactor)));
     } else {
         m_page->settings().setTextAutosizingEnabled(m_embedderTextAutosizingEnabled);
         m_page->settings().setPreferCompositingToLCDTextEnabled(m_embedderPreferCompositingToLCDTextEnabled);
         m_page->settings().setDeviceScaleAdjustment(m_embedderFontScaleFactor);
     }
 
     // FIXME: allow metrics override, fps counter and continuous painting at the same time: crbug.com/299837.
     m_client->setShowFPSCounter(m_state->getBoolean(PageAgentState::pageAgentShowFPSCounter) && !m_deviceMetricsOverridden);
     m_client->setContinuousPaintingEnabled(m_state->getBoolean(PageAgentState::pageAgentContinuousPaintingEnabled) && !m_deviceMetricsOverridden);
 }
 
 void InspectorPageAgent::updateTouchEventEmulationInPage(bool enabled)
 {
+    if (!inspectedFrame()->isMainFrame())
+        return;
     if (!m_touchEmulationEnabled) {
         m_originalTouchEnabled = RuntimeEnabledFeatures::touchEnabled();
         m_originalDeviceSupportsMouse = m_page->settings().deviceSupportsMouse();
         m_originalDeviceSupportsTouch = m_page->settings().deviceSupportsTouch();
         m_originalMaxTouchPoints = m_page->settings().maxTouchPoints();
     }
     RuntimeEnabledFeatures::setTouchEnabled(enabled ? true : m_originalTouchEnabled);
     if (!m_originalDeviceSupportsTouch) {
         m_page->settings().setDeviceSupportsMouse(enabled ? false : m_originalDeviceSupportsMouse);
         m_page->settings().setDeviceSupportsTouch(enabled ? true : m_originalDeviceSupportsTouch);
         // Currently emulation does not provide multiple touch points.
         m_page->settings().setMaxTouchPoints(enabled ? 1 : m_originalMaxTouchPoints);
     }
     m_touchEmulationEnabled = enabled;
     m_client->setTouchEventEmulationEnabled(enabled);
-    m_page->deprecatedLocalMainFrame()->view()->layout();
+    inspectedFrame()->view()->layout();
 }
 
 void InspectorPageAgent::setTouchEmulationEnabled(ErrorString*, bool enabled, const String* configuration)
 {
     if (m_state->getBoolean(PageAgentState::touchEventEmulationEnabled) == enabled)
         return;
 
     m_state->setBoolean(PageAgentState::touchEventEmulationEnabled, enabled);
     updateTouchEventEmulationInPage(enabled);
 }
 
 void InspectorPageAgent::setEmulatedMedia(ErrorString*, const String& media)
 {
+    if (!inspectedFrame()->isMainFrame())
+        return;
     String currentMedia = m_state->getString(PageAgentState::pageAgentEmulatedMedia);
     if (media == currentMedia)
         return;
 
     m_state->setString(PageAgentState::pageAgentEmulatedMedia, media);
-    Document* document = 0;
-    if (m_page->mainFrame())
-        document = m_page->deprecatedLocalMainFrame()->document();
+    Document* document = inspectedFrame()->document();
     if (document) {
         document->mediaQueryAffectingValueChanged();
         document->styleResolverChanged();
         document->updateLayout();
     }
 }
 
 bool InspectorPageAgent::applyViewportStyleOverride(StyleResolver* resolver)
 {
     if (!m_deviceMetricsOverridden || !m_emulateMobileEnabled)
@@ skipping 40 matching lines @@
     m_state->setBoolean(PageAgentState::showGridOnResize, asBool(showGrid));
 }
 
 void InspectorPageAgent::setOverlayMessage(ErrorString*, const String* message)
 {
     m_overlay->setPausedInDebuggerMessage(message);
 }
 
 void InspectorPageAgent::animationsPlaybackRate(ErrorString*, double* playbackRate)
 {
-    *playbackRate = toLocalFrame(m_page->mainFrame())->document()->timeline().playbackRate();
+    *playbackRate = inspectedFrame()->document()->timeline().playbackRate();
 }
 
 void InspectorPageAgent::setAnimationsPlaybackRate(ErrorString*, double playbackRate)
 {
-    for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
+    for (Frame* frame = inspectedFrame(); frame; frame = frame->tree().traverseNext(inspectedFrame())) {
         if (frame->isLocalFrame())
             toLocalFrame(frame)->document()->timeline().setPlaybackRate(playbackRate);
     }
 }
 
 void InspectorPageAgent::clearEditedResourcesContent()
 {
     m_editedResourceContent.clear();
 }
 
@@ skipping 13 matching lines @@
 void InspectorPageAgent::trace(Visitor* visitor)
 {
     visitor->trace(m_page);
     visitor->trace(m_injectedScriptManager);
     visitor->trace(m_inspectorResourceContentLoader);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink