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));
}
