void WebProcessProxy::didClose(CoreIPC::Connection*) { // Protect ourselves, as the call to the shared WebProcessManager's processDidClose() // below may otherwise cause us to be deleted before we can finish our work. RefPtr<WebProcessProxy> protect(this); m_connection = nullptr; m_responsivenessTimer.stop(); Vector<RefPtr<WebFrameProxy> > frames; copyValuesToVector(m_frameMap, frames); for (size_t i = 0, size = frames.size(); i < size; ++i) frames[i]->disconnect(); m_frameMap.clear(); Vector<RefPtr<WebPageProxy> > pages; copyValuesToVector(m_pageMap, pages); m_context->processDidClose(this); WebProcessManager::shared().processDidClose(this, m_context); for (size_t i = 0, size = pages.size(); i < size; ++i) pages[i]->processDidCrash(); }
void CompositeAnimationPrivate::styleAvailable() { if (m_numStyleAvailableWaiters == 0) return; // We have to go through animations in the order in which they appear in // the style, because order matters for additivity. Vector<RefPtr<KeyframeAnimation> > animations(m_keyframeAnimations.size()); copyValuesToVector(m_keyframeAnimations, animations); if (animations.size() > 1) std::stable_sort(animations.begin(), animations.end(), compareAnimationIndices); for (size_t i = 0; i < animations.size(); ++i) { KeyframeAnimation* anim = animations[i].get(); if (anim && anim->waitingForStyleAvailable()) anim->updateStateMachine(AnimationBase::AnimationStateInputStyleAvailable, -1); } CSSPropertyTransitionsMap::const_iterator end = m_transitions.end(); for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) { ImplicitAnimation* anim = it->second.get(); if (anim && anim->waitingForStyleAvailable()) anim->updateStateMachine(AnimationBase::AnimationStateInputStyleAvailable, -1); } }
void NPRuntimeObjectMap::invalidate() { Vector<NPJSObject*> npJSObjects; copyValuesToVector(m_npJSObjects, npJSObjects); // Deallocate all the object wrappers so we won't leak any JavaScript objects. for (size_t i = 0; i < npJSObjects.size(); ++i) deallocateNPObject(npJSObjects[i]); // We shouldn't have any NPJSObjects left now. ASSERT(m_npJSObjects.isEmpty()); Vector<NPObject*> objects; for (HashMap<NPObject*, JSC::Weak<JSNPObject>>::iterator ptr = m_jsNPObjects.begin(), end = m_jsNPObjects.end(); ptr != end; ++ptr) { JSNPObject* jsNPObject = ptr->value.get(); if (!jsNPObject) // Skip zombies. continue; objects.append(jsNPObject->leakNPObject()); } m_jsNPObjects.clear(); for (size_t i = 0; i < objects.size(); ++i) releaseNPObject(objects[i]); // Deal with any objects that were scheduled for delayed destruction if (m_npObjectsToFinalize.isEmpty()) return; ASSERT(m_finalizationTimer.isActive()); m_finalizationTimer.stop(); invalidateQueuedObjects(); }
void WebProcessProxy::interactionOccurredWhileUnresponsive(ResponsivenessTimer*) { Vector<RefPtr<WebPageProxy>> pages; copyValuesToVector(m_pageMap, pages); for (size_t i = 0, size = pages.size(); i < size; ++i) pages[i]->interactionOccurredWhileProcessUnresponsive(); }
static void unscheduleAll(const ResourceLoaderMap& loaders, SchedulePair& pair) { Vector<RefPtr<ResourceLoader>> loadersCopy; copyValuesToVector(loaders, loadersCopy); for (auto& loader : loadersCopy) loader->unschedule(pair); }
void WebProcessProxy::didBecomeResponsive(ResponsivenessTimer*) { Vector<RefPtr<WebPageProxy>> pages; copyValuesToVector(m_pageMap, pages); for (size_t i = 0, size = pages.size(); i < size; ++i) pages[i]->processDidBecomeResponsive(); }
void WebProcessProxy::shutDown() { shutDownProcess(); if (m_webConnection) { m_webConnection->invalidate(); m_webConnection = nullptr; } m_responsivenessTimer.invalidate(); m_tokenForHoldingLockedFiles = nullptr; Vector<RefPtr<WebFrameProxy>> frames; copyValuesToVector(m_frameMap, frames); for (size_t i = 0, size = frames.size(); i < size; ++i) frames[i]->webProcessWillShutDown(); m_frameMap.clear(); if (m_downloadProxyMap) m_downloadProxyMap->processDidClose(); for (VisitedLinkProvider* visitedLinkProvider : m_visitedLinkProviders) visitedLinkProvider->removeProcess(*this); m_visitedLinkProviders.clear(); for (WebUserContentControllerProxy* webUserContentControllerProxy : m_webUserContentControllerProxies) webUserContentControllerProxy->removeProcess(*this); m_webUserContentControllerProxies.clear(); m_processPool->disconnectProcess(this); }
void TiledDrawingAreaProxy::removeAllTiles() { Vector<RefPtr<TiledDrawingAreaTile> > tilesToRemove; copyValuesToVector(m_tiles, tilesToRemove); unsigned removeCount = tilesToRemove.size(); for (unsigned n = 0; n < removeCount; ++n) removeTile(tilesToRemove[n]->coordinate()); }
void NetscapePlugin::stopAllStreams() { Vector<RefPtr<NetscapePluginStream> > streams; copyValuesToVector(m_streams, streams); for (size_t i = 0; i < streams.size(); ++i) streams[i]->stop(NPRES_USER_BREAK); }
MediaStreamTrackPrivateVector MediaStreamPrivate::tracks() const { MediaStreamTrackPrivateVector tracks; tracks.reserveCapacity(m_trackSet.size()); copyValuesToVector(m_trackSet, tracks); return tracks; }
void WebProcessProxy::disconnectFramesFromPage(WebPageProxy* page) { Vector<RefPtr<WebFrameProxy>> frames; copyValuesToVector(m_frameMap, frames); for (size_t i = 0, size = frames.size(); i < size; ++i) { if (frames[i]->page() == page) frames[i]->disconnect(); } }
void WebProcessConnection::didClose(CoreIPC::Connection*) { // The web process crashed. Destroy all the plug-in controllers. Destroying the last plug-in controller // will cause the web process connection itself to be destroyed. Vector<PluginControllerProxy*> pluginControllers; copyValuesToVector(m_pluginControllers, pluginControllers); for (size_t i = 0; i < pluginControllers.size(); ++i) destroyPluginControllerProxy(pluginControllers[i]); }
void WebResourceLoadScheduler::networkProcessCrashed() { Vector<RefPtr<WebResourceLoader> > webResourceLoaders; copyValuesToVector(m_webResourceLoaders, webResourceLoaders); for (size_t i = 0; i < webResourceLoaders.size(); ++i) webResourceLoaders[i]->networkProcessCrashed(); ASSERT(m_webResourceLoaders.isEmpty()); }
void PluginView::cancelAllStreams() { Vector<RefPtr<Stream> > streams; copyValuesToVector(m_streams, streams); for (size_t i = 0; i < streams.size(); ++i) streams[i]->cancel(); // Cancelling a stream removes it from the m_streams map, so if we cancel all streams the map should be empty. ASSERT(m_streams.isEmpty()); }
void WebPageProxy::close() { if (!isValid()) return; m_closed = true; Vector<RefPtr<WebFrameProxy> > frames; copyValuesToVector(m_frameMap, frames); for (size_t i = 0, size = frames.size(); i < size; ++i) frames[i]->disconnect(); m_frameMap.clear(); m_mainFrame = 0; m_pageTitle = String(); m_toolTip = String(); Vector<RefPtr<ScriptReturnValueCallback> > scriptReturnValueCallbacks; copyValuesToVector(m_scriptReturnValueCallbacks, scriptReturnValueCallbacks); for (size_t i = 0, size = scriptReturnValueCallbacks.size(); i < size; ++i) scriptReturnValueCallbacks[i]->invalidate(); m_scriptReturnValueCallbacks.clear(); Vector<RefPtr<RenderTreeExternalRepresentationCallback> > renderTreeExternalRepresentationCallbacks; copyValuesToVector(m_renderTreeExternalRepresentationCallbacks, renderTreeExternalRepresentationCallbacks); for (size_t i = 0, size = renderTreeExternalRepresentationCallbacks.size(); i < size; ++i) renderTreeExternalRepresentationCallbacks[i]->invalidate(); m_renderTreeExternalRepresentationCallbacks.clear(); m_canGoForward = false; m_canGoBack = false; m_loaderClient.initialize(0); m_policyClient.initialize(0); m_uiClient.initialize(0); m_drawingArea.clear(); process()->connection()->send(WebPageMessage::Close, m_pageID, CoreIPC::In()); process()->removeWebPage(m_pageID); }
void WebProcessProxy::didClose(CoreIPC::Connection*) { // Protect ourselves, as the call to disconnect() below may otherwise cause us // to be deleted before we can finish our work. RefPtr<WebProcessProxy> protect(this); Vector<RefPtr<WebPageProxy> > pages; copyValuesToVector(m_pageMap, pages); disconnect(); for (size_t i = 0, size = pages.size(); i < size; ++i) pages[i]->processDidCrash(); }
void WebProcessProxy::didClose(CoreIPC::Connection*) { m_connection = 0; m_responsivenessTimer.stop(); Vector<RefPtr<WebPageProxy> > pages; copyValuesToVector(m_pageMap, pages); for (size_t i = 0, size = pages.size(); i < size; ++i) pages[i]->processDidExit(); // This may cause us to be deleted. WebProcessManager::shared().processDidClose(this); }
void NetworkConnectionToWebProcess::didClose(IPC::Connection&) { // Protect ourself as we might be otherwise be deleted during this function. Ref<NetworkConnectionToWebProcess> protector(*this); Vector<RefPtr<NetworkResourceLoader>> loaders; copyValuesToVector(m_networkResourceLoaders, loaders); for (auto& loader : loaders) loader->abort(); ASSERT(m_networkResourceLoaders.isEmpty()); NetworkBlobRegistry::singleton().connectionToWebProcessDidClose(this); NetworkProcess::singleton().removeNetworkConnectionToWebProcess(this); }
void WebPageProxy::processDidExit() { ASSERT(m_pageClient); m_valid = false; if (m_mainFrame) m_urlAtProcessExit = m_mainFrame->url(); Vector<RefPtr<WebFrameProxy> > frames; copyValuesToVector(m_frameMap, frames); for (size_t i = 0, size = frames.size(); i < size; ++i) frames[i]->disconnect(); m_frameMap.clear(); m_mainFrame = 0; m_pageTitle = String(); m_toolTip = String(); Vector<RefPtr<ScriptReturnValueCallback> > scriptReturnValueCallbacks; copyValuesToVector(m_scriptReturnValueCallbacks, scriptReturnValueCallbacks); for (size_t i = 0, size = scriptReturnValueCallbacks.size(); i < size; ++i) scriptReturnValueCallbacks[i]->invalidate(); m_scriptReturnValueCallbacks.clear(); Vector<RefPtr<RenderTreeExternalRepresentationCallback> > renderTreeExternalRepresentationCallbacks; copyValuesToVector(m_renderTreeExternalRepresentationCallbacks, renderTreeExternalRepresentationCallbacks); for (size_t i = 0, size = renderTreeExternalRepresentationCallbacks.size(); i < size; ++i) renderTreeExternalRepresentationCallbacks[i]->invalidate(); m_renderTreeExternalRepresentationCallbacks.clear(); m_canGoForward = false; m_canGoBack = false; m_pageClient->processDidExit(); }
void ResourceUsageThread::notifyObservers(ResourceUsageData&& data) { callOnMainThread([data = WTFMove(data)]() mutable { Vector<std::function<void (const ResourceUsageData&)>> functions; { auto& resourceUsageThread = ResourceUsageThread::singleton(); LockHolder locker(resourceUsageThread.m_lock); copyValuesToVector(resourceUsageThread.m_observers, functions); } for (auto& function : functions) function(data); }); }
void WebProcess::didClose(CoreIPC::Connection*) { #ifndef NDEBUG m_inDidClose = true; // Close all the live pages. Vector<RefPtr<WebPage>> pages; copyValuesToVector(m_pageMap, pages); for (size_t i = 0; i < pages.size(); ++i) pages[i]->close(); pages.clear(); gcController().garbageCollectSoon(); memoryCache()->setDisabled(true); #endif // The UI process closed this connection, shut down. RunLoop::main()->stop(); }
void WebProcessProxy::disconnect() { if (m_connection) { m_connection->connection()->removeQueueClient(this); m_connection->invalidate(); m_connection = nullptr; } m_responsivenessTimer.stop(); Vector<RefPtr<WebFrameProxy> > frames; copyValuesToVector(m_frameMap, frames); for (size_t i = 0, size = frames.size(); i < size; ++i) frames[i]->disconnect(); m_frameMap.clear(); m_context->disconnectProcess(this); }
void Loader::servePendingRequests(Priority minimumPriority) { m_requestTimer.stop(); m_nonHTTPProtocolHost.servePendingRequests(minimumPriority); Vector<Host*> hostsToServe; copyValuesToVector(m_hosts, hostsToServe); for (unsigned n = 0; n < hostsToServe.size(); ++n) { Host* host = hostsToServe[n]; if (host->hasRequests()) host->servePendingRequests(minimumPriority); else if (!host->processingResource()){ AtomicString name = host->name(); delete host; m_hosts.remove(name.impl()); } } }
void NPRemoteObjectMap::invalidate() { ASSERT(!m_isInvalidating); m_isInvalidating = true; Vector<NPObjectMessageReceiver*> messageReceivers; copyValuesToVector(m_registeredNPObjects, messageReceivers); // Now delete all the receivers. deleteAllValues(messageReceivers); ASSERT(m_registeredNPObjects.isEmpty()); for (HashSet<NPObject*>::const_iterator it = m_npObjectProxies.begin(), end = m_npObjectProxies.end(); it != end; ++it) NPObjectProxy::toNPObjectProxy(*it)->invalidate(); m_npObjectProxies.clear(); m_isInvalidating = false; }
void ResourceLoadScheduler::servePendingRequests(ResourceLoadPriority minimumPriority) { LOG(ResourceLoading, "ResourceLoadScheduler::servePendingRequests. m_suspendPendingRequestsCount=%d", m_suspendPendingRequestsCount); if (isSuspendingPendingRequests()) return; m_requestTimer.stop(); servePendingRequests(m_nonHTTPProtocolHost, minimumPriority); Vector<HostInformation*> hostsToServe; copyValuesToVector(m_hosts, hostsToServe); for (auto* host : hostsToServe) { if (host->hasRequests()) servePendingRequests(host, minimumPriority); else delete m_hosts.take(host->name()); } }
void Loader::cancelRequests(DocLoader* docLoader) { if (m_nonHTTPProtocolHost.hasRequests()) m_nonHTTPProtocolHost.cancelRequests(docLoader); Vector<Host*> hostsToCancel; copyValuesToVector(m_hosts, hostsToCancel); for (unsigned n = 0; n < hostsToCancel.size(); ++n) { Host* host = hostsToCancel[n]; if (host->hasRequests()) host->cancelRequests(docLoader); } scheduleServePendingRequests(); if (docLoader->loadInProgress()) ASSERT(docLoader->requestCount() == 1); else ASSERT(docLoader->requestCount() == 0); }
void NetworkResourceLoadScheduler::servePendingRequests(ResourceLoadPriority minimumPriority) { LOG(NetworkScheduling, "(NetworkProcess) NetworkResourceLoadScheduler::servePendingRequests Serving requests for up to %i hosts with minimum priority %i", m_hosts.size(), minimumPriority); m_requestTimer.stop(); m_nonHTTPProtocolHost->servePendingRequests(minimumPriority); m_hosts.checkConsistency(); Vector<RefPtr<HostRecord>> hostsToServe; copyValuesToVector(m_hosts, hostsToServe); size_t size = hostsToServe.size(); for (size_t i = 0; i < size; ++i) { HostRecord* host = hostsToServe[i].get(); if (host->hasRequests()) host->servePendingRequests(minimumPriority); else m_hosts.remove(host->name()); } }
void WebProcess::didClose(CoreIPC::Connection*) { // When running in the same process the connection will never be closed. ASSERT(isSeparateProcess()); #ifndef NDEBUG m_inDidClose = true; // Close all the live pages. Vector<RefPtr<WebPage> > pages; copyValuesToVector(m_pageMap, pages); for (size_t i = 0; i < pages.size(); ++i) pages[i]->close(); pages.clear(); gcController().garbageCollectSoon(); memoryCache()->setDisabled(true); #endif // The UI process closed this connection, shut down. m_runLoop->stop(); }
void WebProcess::didClose(IPC::Connection&) { #ifndef NDEBUG m_inDidClose = true; // Close all the live pages. Vector<RefPtr<WebPage>> pages; copyValuesToVector(m_pageMap, pages); for (auto& page : pages) page->close(); pages.clear(); GCController::singleton().garbageCollectSoon(); FontCache::singleton().invalidate(); MemoryCache::singleton().setDisabled(true); #endif // FIXME(146657): This explicit media stop command should not be necessary PlatformMediaSessionManager::sharedManager().stopAllMediaPlaybackForProcess(); // The UI process closed this connection, shut down. stopRunLoop(); }
void WebProcessProxy::disconnect() { clearConnection(); if (m_webConnection) { m_webConnection->invalidate(); m_webConnection = nullptr; } m_responsivenessTimer.invalidate(); Vector<RefPtr<WebFrameProxy>> frames; copyValuesToVector(m_frameMap, frames); for (size_t i = 0, size = frames.size(); i < size; ++i) frames[i]->disconnect(); m_frameMap.clear(); if (m_downloadProxyMap) m_downloadProxyMap->processDidClose(); m_context->disconnectProcess(this); }