LocalFrame* LinkResource::loadingFrame() const { HTMLImportsController* import = m_owner->document().importsController(); if (!import) return m_owner->document().frame(); return import->frame(); }
void LinkImport::process() { if (m_child) return; if (!m_owner) return; if (!shouldLoadResource()) return; if (!m_owner->document().import()) { ASSERT(m_owner->document().frame()); // The document should be the master. HTMLImportsController::provideTo(m_owner->document()); } LinkRequestBuilder builder(m_owner); if (!builder.isValid()) { didFinish(); return; } HTMLImport* parent = m_owner->document().import(); HTMLImportsController* controller = parent->controller(); m_child = controller->load(parent, this, builder.build(true)); if (!m_child) { didFinish(); return; } }
void LinkImport::process() { if (m_loader) return; if (!m_owner) return; if (!m_owner->document()->frame() && !m_owner->document()->import()) return; if (!m_owner->document()->import()) { ASSERT(m_owner->document()->frame()); // The document should be the master. HTMLImportsController::provideTo(m_owner->document()); } LinkRequestBuilder builder(m_owner); if (!builder.isValid()) { didFinish(); return; } HTMLImport* parent = m_owner->document()->import(); HTMLImportsController* controller = parent->controller(); m_loader = controller->createLoader(parent, builder.build(true)); if (!m_loader) { didFinish(); return; } m_loader->addClient(this); }
inline Document* StyleEngine::master() { if (isMaster()) return m_document; HTMLImportsController* import = document().importsController(); if (!import) // Document::import() can return null while executing its destructor. return 0; return import->master(); }
bool traverseTree(Node* rootNode, WillBeHeapVector<RawPtrWillBeMember<Node>, initialNodeVectorSize>* partiallyDependentNodes) { // To make each minor GC time bounded, we might need to give up // traversing at some point for a large DOM tree. That being said, // I could not observe the need even in pathological test cases. for (Node& node : NodeTraversal::startsAt(rootNode)) { if (node.containsWrapper()) { if (!node.isV8CollectableDuringMinorGC()) { // This node is not in the new space of V8. This indicates that // the minor GC cannot anyway judge reachability of this DOM tree. // Thus we give up traversing the DOM tree. return false; } node.clearV8CollectableDuringMinorGC(); partiallyDependentNodes->append(&node); } if (ShadowRoot* shadowRoot = node.youngestShadowRoot()) { if (!traverseTree(shadowRoot, partiallyDependentNodes)) return false; } else if (node.isShadowRoot()) { if (ShadowRoot* shadowRoot = toShadowRoot(node).olderShadowRoot()) { if (!traverseTree(shadowRoot, partiallyDependentNodes)) return false; } } // <template> has a |content| property holding a DOM fragment which we must traverse, // just like we do for the shadow trees above. if (isHTMLTemplateElement(node)) { if (!traverseTree(toHTMLTemplateElement(node).content(), partiallyDependentNodes)) return false; } // Document maintains the list of imported documents through HTMLImportsController. if (node.isDocumentNode()) { Document& document = toDocument(node); HTMLImportsController* controller = document.importsController(); if (controller && document == controller->master()) { for (unsigned i = 0; i < controller->loaderCount(); ++i) { if (!traverseTree(controller->loaderDocumentAt(i), partiallyDependentNodes)) return false; } } } } return true; }