void WebBatteryManagerProxy::providerUpdateBatteryStatus(WebBatteryStatus* status) { if (!processPool()) return; processPool()->sendToAllProcesses(Messages::WebBatteryManager::UpdateBatteryStatus(status->data())); }
void WebProcessProxy::didSetAssertionState(AssertionState state) { #if PLATFORM(IOS) && ENABLE(NETWORK_PROCESS) ASSERT(!m_backgroundTokenForNetworkProcess || !m_foregroundTokenForNetworkProcess); switch (state) { case AssertionState::Suspended: m_foregroundTokenForNetworkProcess = nullptr; m_backgroundTokenForNetworkProcess = nullptr; for (auto& page : m_pageMap.values()) page->processWillBecomeSuspended(); break; case AssertionState::Background: if (processPool().usesNetworkProcess()) m_backgroundTokenForNetworkProcess = processPool().ensureNetworkProcess().throttler().backgroundActivityToken(); m_foregroundTokenForNetworkProcess = nullptr; break; case AssertionState::Foreground: if (processPool().usesNetworkProcess()) m_foregroundTokenForNetworkProcess = processPool().ensureNetworkProcess().throttler().foregroundActivityToken(); m_backgroundTokenForNetworkProcess = nullptr; for (auto& page : m_pageMap.values()) page->processWillBecomeForeground(); break; } ASSERT(!m_backgroundTokenForNetworkProcess || !m_foregroundTokenForNetworkProcess); #else UNUSED_PARAM(state); #endif }
void WebNotificationManagerProxy::providerDidUpdateNotificationPolicy(const API::SecurityOrigin* origin, bool allowed) { if (!processPool()) return; processPool()->sendToAllProcesses(Messages::WebNotificationManager::DidUpdateNotificationDecision(origin->securityOrigin().toString(), allowed)); }
void WebBatteryManagerProxy::providerDidChangeBatteryStatus(const WTF::AtomicString& eventType, WebBatteryStatus* status) { if (!processPool()) return; processPool()->sendToAllProcesses(Messages::WebBatteryManager::DidChangeBatteryStatus(eventType, status->data())); }
void WebCookieManagerProxy::setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy policy) { #if PLATFORM(COCOA) persistHTTPCookieAcceptPolicy(policy); #endif #if USE(SOUP) processPool()->setInitialHTTPCookieAcceptPolicy(policy); #endif processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::SetHTTPCookieAcceptPolicy(policy)); }
void WebCookieManagerProxy::getHostnamesWithCookies(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction) { RefPtr<ArrayCallback> callback = ArrayCallback::create(WTF::move(callbackFunction)); uint64_t callbackID = callback->callbackID(); m_arrayCallbacks.set(callbackID, callback.release()); processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::GetHostnamesWithCookies(callbackID)); }
void WebNotificationManagerProxy::providerDidRemoveNotificationPolicies(API::Array* origins) { if (!processPool()) return; size_t size = origins->size(); if (!size) return; Vector<String> originStrings; originStrings.reserveInitialCapacity(size); for (size_t i = 0; i < size; ++i) originStrings.append(origins->at<API::SecurityOrigin>(i)->securityOrigin().toString()); processPool()->sendToAllProcesses(Messages::WebNotificationManager::DidRemoveNotificationDecisions(originStrings)); }
void WebMediaCacheManagerProxy::getHostnamesWithMediaCache(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction) { RefPtr<ArrayCallback> callback = ArrayCallback::create(WTF::move(callbackFunction)); uint64_t callbackID = callback->callbackID(); m_arrayCallbacks.set(callbackID, callback.release()); // FIXME (Multi-WebProcess): <rdar://problem/12239765> When we're sending this to multiple processes, we need to aggregate the callback data when it comes back. processPool()->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebMediaCacheManager::GetHostnamesWithMediaCache(callbackID)); }
void WebCookieManagerProxy::getHTTPCookieAcceptPolicy(std::function<void (HTTPCookieAcceptPolicy, CallbackBase::Error)> callbackFunction) { RefPtr<HTTPCookieAcceptPolicyCallback> callback = HTTPCookieAcceptPolicyCallback::create(WTF::move(callbackFunction)); uint64_t callbackID = callback->callbackID(); m_httpCookieAcceptPolicyCallbacks.set(callbackID, callback.release()); processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::GetHTTPCookieAcceptPolicy(callbackID)); }
void WebProcessProxy::retainIconForPageURL(const String& pageURL) { WebIconDatabase* iconDatabase = processPool().iconDatabase(); if (!iconDatabase || pageURL.isEmpty()) return; // Track retain counts so we can release them if the WebProcess terminates early. auto result = m_pageURLRetainCountMap.add(pageURL, 1); if (!result.isNewEntry) ++result.iterator->value; iconDatabase->retainIconForPageURL(pageURL); }
void WebProcessProxy::releaseRemainingIconsForPageURLs() { WebIconDatabase* iconDatabase = processPool().iconDatabase(); if (!iconDatabase) return; for (auto iter : m_pageURLRetainCountMap) { uint64_t count = iter.value; for (uint64_t i = 0; i < count; ++i) iconDatabase->releaseIconForPageURL(iter.key); } m_pageURLRetainCountMap.clear(); }
void WebProcessProxy::releaseIconForPageURL(const String& pageURL) { WebIconDatabase* iconDatabase = processPool().iconDatabase(); if (!iconDatabase || pageURL.isEmpty()) return; // Track retain counts so we can release them if the WebProcess terminates early. auto result = m_pageURLRetainCountMap.find(pageURL); if (result == m_pageURLRetainCountMap.end()) return; --result->value; if (!result->value) m_pageURLRetainCountMap.remove(result); iconDatabase->releaseIconForPageURL(pageURL); }
void WebMediaCacheManagerProxy::clearCacheForAllHostnames() { processPool()->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebMediaCacheManager::ClearCacheForAllHostnames()); }
void WebMediaCacheManagerProxy::clearCacheForHostname(const String& hostname) { processPool()->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebMediaCacheManager::ClearCacheForHostname(hostname)); }
void WebCookieManagerProxy::deleteCookiesForHostname(const String& hostname) { processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteCookiesForHostname(hostname)); }
void WebCookieManagerProxy::deleteAllCookies() { processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteAllCookies()); }
bool WebCookieManagerProxy::shouldTerminate(WebProcessProxy*) const { return processPool()->processModel() != ProcessModelSharedSecondaryProcess || (m_arrayCallbacks.isEmpty() && m_httpCookieAcceptPolicyCallbacks.isEmpty()); }
void WebCookieManagerProxy::stopObservingCookieChanges() { processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::StopObservingCookieChanges()); }
void WebCookieManagerProxy::deleteAllCookiesModifiedSince(std::chrono::system_clock::time_point time) { processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteAllCookiesModifiedSince(time)); }