Remove duplicate API from WKContext
[WebKit-https.git] / Source / WebKit2 / WebProcess / WebProcess.cpp
1 /*
2  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "WebProcess.h"
28
29 #include "AuthenticationManager.h"
30 #include "DownloadManager.h"
31 #include "InjectedBundle.h"
32 #include "InjectedBundleMessageKinds.h"
33 #include "InjectedBundleUserMessageCoders.h"
34 #include "RunLoop.h"
35 #include "SandboxExtension.h"
36 #include "WebApplicationCacheManager.h"
37 #include "WebContextMessages.h"
38 #include "WebCookieManager.h"
39 #include "WebCoreArgumentCoders.h"
40 #include "WebDatabaseManager.h"
41 #include "WebFrame.h"
42 #include "WebGeolocationManagerMessages.h"
43 #include "WebKeyValueStorageManager.h"
44 #include "WebMediaCacheManager.h"
45 #include "WebMemorySampler.h"
46 #include "WebPage.h"
47 #include "WebPageCreationParameters.h"
48 #include "WebPlatformStrategies.h"
49 #include "WebPreferencesStore.h"
50 #include "WebProcessCreationParameters.h"
51 #include "WebProcessMessages.h"
52 #include "WebProcessProxyMessages.h"
53 #include "WebResourceCacheManager.h"
54 #include <WebCore/AXObjectCache.h>
55 #include <WebCore/ApplicationCacheStorage.h>
56 #include <WebCore/CrossOriginPreflightResultCache.h>
57 #include <WebCore/Font.h>
58 #include <WebCore/Language.h>
59 #include <WebCore/Logging.h>
60 #include <WebCore/MemoryCache.h>
61 #include <WebCore/Page.h>
62 #include <WebCore/PageGroup.h>
63 #include <WebCore/ResourceHandle.h>
64 #include <WebCore/SchemeRegistry.h>
65 #include <WebCore/SecurityOrigin.h>
66 #include <WebCore/Settings.h>
67 #include <WebCore/StorageTracker.h>
68 #include <wtf/PassRefPtr.h>
69 #include <wtf/RandomNumber.h>
70
71 #ifndef NDEBUG
72 #include <WebCore/MemoryCache.h>
73 #include <WebCore/GCController.h>
74 #endif
75
76 #if !OS(WINDOWS)
77 #include <unistd.h>
78 #endif
79
80 #if !ENABLE(PLUGIN_PROCESS)
81 #include "NetscapePluginModule.h"
82 #endif
83
84 using namespace WebCore;
85
86 namespace WebKit {
87
88 #if OS(WINDOWS)
89 static void sleep(unsigned seconds)
90 {
91     ::Sleep(seconds * 1000);
92 }
93 #endif
94
95 static void* randomCrashThread(void*)
96 {
97     // This delay was chosen semi-arbitrarily. We want the crash to happen somewhat quickly to
98     // enable useful stress testing, but not so quickly that the web process will always crash soon
99     // after launch.
100     static const unsigned maximumRandomCrashDelay = 180;
101
102     sleep(randomNumber() * maximumRandomCrashDelay);
103     CRASH();
104     return 0;
105 }
106
107 static void startRandomCrashThreadIfRequested()
108 {
109     if (!getenv("WEBKIT2_CRASH_WEB_PROCESS_RANDOMLY"))
110         return;
111     createThread(randomCrashThread, 0, "WebKit2: Random Crash Thread");
112 }
113
114 WebProcess& WebProcess::shared()
115 {
116     static WebProcess& process = *new WebProcess;
117     return process;
118 }
119
120 WebProcess::WebProcess()
121     : m_inDidClose(false)
122     , m_hasSetCacheModel(false)
123     , m_cacheModel(CacheModelDocumentViewer)
124 #if USE(ACCELERATED_COMPOSITING) && PLATFORM(MAC)
125     , m_compositingRenderServerPort(MACH_PORT_NULL)
126 #endif
127 #if PLATFORM(QT)
128     , m_networkAccessManager(0)
129 #endif
130     , m_textCheckerState()
131     , m_geolocationManager(this)
132     , m_iconDatabaseProxy(this)
133 {
134 #if USE(PLATFORM_STRATEGIES)
135     // Initialize our platform strategies.
136     WebPlatformStrategies::initialize();
137 #endif // USE(PLATFORM_STRATEGIES)
138
139     WebCore::InitializeLoggingChannelsIfNecessary();
140 }
141
142 void WebProcess::initialize(CoreIPC::Connection::Identifier serverIdentifier, RunLoop* runLoop)
143 {
144     ASSERT(!m_connection);
145
146     m_connection = CoreIPC::Connection::createClientConnection(serverIdentifier, this, runLoop);
147     m_connection->setDidCloseOnConnectionWorkQueueCallback(didCloseOnConnectionWorkQueue);
148
149     m_connection->open();
150
151     m_runLoop = runLoop;
152
153     startRandomCrashThreadIfRequested();
154 }
155
156 void WebProcess::initializeWebProcess(const WebProcessCreationParameters& parameters, CoreIPC::ArgumentDecoder* arguments)
157 {
158     ASSERT(m_pageMap.isEmpty());
159
160     platformInitializeWebProcess(parameters, arguments);
161
162     RefPtr<APIObject> injectedBundleInitializationUserData;
163     InjectedBundleUserMessageDecoder messageDecoder(injectedBundleInitializationUserData);
164     if (!arguments->decode(messageDecoder))
165         return;
166
167     if (!parameters.injectedBundlePath.isEmpty()) {
168         m_injectedBundle = InjectedBundle::create(parameters.injectedBundlePath);
169         m_injectedBundle->setSandboxExtension(SandboxExtension::create(parameters.injectedBundlePathExtensionHandle));
170
171         if (!m_injectedBundle->load(injectedBundleInitializationUserData.get())) {
172             // Don't keep around the InjectedBundle reference if the load fails.
173             m_injectedBundle.clear();
174         }
175     }
176
177 #if ENABLE(DATABASE)
178     // Make sure the WebDatabaseManager is initialized so that the Database directory is set.
179     WebDatabaseManager::initialize(parameters.databaseDirectory);
180 #endif
181
182 #if ENABLE(ICONDATABASE)
183     m_iconDatabaseProxy.setEnabled(parameters.iconDatabaseEnabled);
184 #endif
185
186 #if ENABLE(DOM_STORAGE)
187     StorageTracker::initializeTracker(parameters.localStorageDirectory);
188     m_localStorageDirectory = parameters.localStorageDirectory;
189 #endif
190     
191 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
192     if (!parameters.applicationCacheDirectory.isEmpty())
193         cacheStorage().setCacheDirectory(parameters.applicationCacheDirectory);
194 #endif
195
196     setShouldTrackVisitedLinks(parameters.shouldTrackVisitedLinks);
197     setCacheModel(static_cast<uint32_t>(parameters.cacheModel));
198
199     if (!parameters.languageCode.isEmpty())
200         overrideDefaultLanguage(parameters.languageCode);
201
202     m_textCheckerState = parameters.textCheckerState;
203
204     for (size_t i = 0; i < parameters.urlSchemesRegistererdAsEmptyDocument.size(); ++i)
205         registerURLSchemeAsEmptyDocument(parameters.urlSchemesRegistererdAsEmptyDocument[i]);
206
207     for (size_t i = 0; i < parameters.urlSchemesRegisteredAsSecure.size(); ++i)
208         registerURLSchemeAsSecure(parameters.urlSchemesRegisteredAsSecure[i]);
209
210     for (size_t i = 0; i < parameters.urlSchemesForWhichDomainRelaxationIsForbidden.size(); ++i)
211         setDomainRelaxationForbiddenForURLScheme(parameters.urlSchemesForWhichDomainRelaxationIsForbidden[i]);
212
213     setDefaultRequestTimeoutInterval(parameters.defaultRequestTimeoutInterval);
214
215     for (size_t i = 0; i < parameters.mimeTypesWithCustomRepresentation.size(); ++i)
216         m_mimeTypesWithCustomRepresentations.add(parameters.mimeTypesWithCustomRepresentation[i]);
217     
218 #if PLATFORM(MAC)
219     m_presenterApplicationPid = parameters.presenterApplicationPid;
220 #endif
221
222     if (parameters.shouldAlwaysUseComplexTextCodePath)
223         setAlwaysUsesComplexTextCodePath(true);
224
225 #if USE(CFURLSTORAGESESSIONS)
226     WebCore::ResourceHandle::setPrivateBrowsingStorageSessionIdentifierBase(parameters.uiProcessBundleIdentifier);
227 #endif
228 }
229
230 void WebProcess::setShouldTrackVisitedLinks(bool shouldTrackVisitedLinks)
231 {
232     PageGroup::setShouldTrackVisitedLinks(shouldTrackVisitedLinks);
233 }
234
235 void WebProcess::registerURLSchemeAsEmptyDocument(const String& urlScheme)
236 {
237     SchemeRegistry::registerURLSchemeAsEmptyDocument(urlScheme);
238 }
239
240 void WebProcess::registerURLSchemeAsSecure(const String& urlScheme) const
241 {
242     SchemeRegistry::registerURLSchemeAsSecure(urlScheme);
243 }
244
245 void WebProcess::setDomainRelaxationForbiddenForURLScheme(const String& urlScheme) const
246 {
247     SecurityOrigin::setDomainRelaxationForbiddenForURLScheme(true, urlScheme);
248 }
249
250 void WebProcess::setDefaultRequestTimeoutInterval(double timeoutInterval)
251 {
252     ResourceRequest::setDefaultTimeoutInterval(timeoutInterval);
253 }
254
255 void WebProcess::setAlwaysUsesComplexTextCodePath(bool alwaysUseComplexText)
256 {
257     WebCore::Font::setCodePath(alwaysUseComplexText ? WebCore::Font::Complex : WebCore::Font::Auto);
258 }
259
260 void WebProcess::languageChanged(const String& language) const
261 {
262     overrideDefaultLanguage(language);
263 }
264
265 void WebProcess::setVisitedLinkTable(const SharedMemory::Handle& handle)
266 {
267     RefPtr<SharedMemory> sharedMemory = SharedMemory::create(handle, SharedMemory::ReadOnly);
268     if (!sharedMemory)
269         return;
270
271     m_visitedLinkTable.setSharedMemory(sharedMemory.release());
272 }
273
274 PageGroup* WebProcess::sharedPageGroup()
275 {
276     return PageGroup::pageGroup("WebKit2Group");
277 }
278
279 void WebProcess::visitedLinkStateChanged(const Vector<WebCore::LinkHash>& linkHashes)
280 {
281     for (size_t i = 0; i < linkHashes.size(); ++i)
282         Page::visitedStateChanged(sharedPageGroup(), linkHashes[i]);
283 }
284
285 void WebProcess::allVisitedLinkStateChanged()
286 {
287     Page::allVisitedStateChanged(sharedPageGroup());
288 }
289
290 bool WebProcess::isLinkVisited(LinkHash linkHash) const
291 {
292     return m_visitedLinkTable.isLinkVisited(linkHash);
293 }
294
295 void WebProcess::addVisitedLink(WebCore::LinkHash linkHash)
296 {
297     if (isLinkVisited(linkHash))
298         return;
299     m_connection->send(Messages::WebContext::AddVisitedLinkHash(linkHash), 0);
300 }
301
302 #if !PLATFORM(MAC)
303 bool WebProcess::fullKeyboardAccessEnabled()
304 {
305     return false;
306 }
307 #endif
308
309 void WebProcess::setCacheModel(uint32_t cm)
310 {
311     CacheModel cacheModel = static_cast<CacheModel>(cm);
312
313     if (!m_hasSetCacheModel || cacheModel != m_cacheModel) {
314         m_hasSetCacheModel = true;
315         m_cacheModel = cacheModel;
316         platformSetCacheModel(cacheModel);
317     }
318 }
319
320 void WebProcess::calculateCacheSizes(CacheModel cacheModel, uint64_t memorySize, uint64_t diskFreeSize,
321     unsigned& cacheTotalCapacity, unsigned& cacheMinDeadCapacity, unsigned& cacheMaxDeadCapacity, double& deadDecodedDataDeletionInterval,
322     unsigned& pageCacheCapacity, unsigned long& urlCacheMemoryCapacity, unsigned long& urlCacheDiskCapacity)
323 {
324     switch (cacheModel) {
325     case CacheModelDocumentViewer: {
326         // Page cache capacity (in pages)
327         pageCacheCapacity = 0;
328
329         // Object cache capacities (in bytes)
330         if (memorySize >= 2048)
331             cacheTotalCapacity = 96 * 1024 * 1024;
332         else if (memorySize >= 1536)
333             cacheTotalCapacity = 64 * 1024 * 1024;
334         else if (memorySize >= 1024)
335             cacheTotalCapacity = 32 * 1024 * 1024;
336         else if (memorySize >= 512)
337             cacheTotalCapacity = 16 * 1024 * 1024;
338
339         cacheMinDeadCapacity = 0;
340         cacheMaxDeadCapacity = 0;
341
342         // Foundation memory cache capacity (in bytes)
343         urlCacheMemoryCapacity = 0;
344
345         // Foundation disk cache capacity (in bytes)
346         urlCacheDiskCapacity = 0;
347
348         break;
349     }
350     case CacheModelDocumentBrowser: {
351         // Page cache capacity (in pages)
352         if (memorySize >= 1024)
353             pageCacheCapacity = 3;
354         else if (memorySize >= 512)
355             pageCacheCapacity = 2;
356         else if (memorySize >= 256)
357             pageCacheCapacity = 1;
358         else
359             pageCacheCapacity = 0;
360
361         // Object cache capacities (in bytes)
362         if (memorySize >= 2048)
363             cacheTotalCapacity = 96 * 1024 * 1024;
364         else if (memorySize >= 1536)
365             cacheTotalCapacity = 64 * 1024 * 1024;
366         else if (memorySize >= 1024)
367             cacheTotalCapacity = 32 * 1024 * 1024;
368         else if (memorySize >= 512)
369             cacheTotalCapacity = 16 * 1024 * 1024;
370
371         cacheMinDeadCapacity = cacheTotalCapacity / 8;
372         cacheMaxDeadCapacity = cacheTotalCapacity / 4;
373
374         // Foundation memory cache capacity (in bytes)
375         if (memorySize >= 2048)
376             urlCacheMemoryCapacity = 4 * 1024 * 1024;
377         else if (memorySize >= 1024)
378             urlCacheMemoryCapacity = 2 * 1024 * 1024;
379         else if (memorySize >= 512)
380             urlCacheMemoryCapacity = 1 * 1024 * 1024;
381         else
382             urlCacheMemoryCapacity =      512 * 1024; 
383
384         // Foundation disk cache capacity (in bytes)
385         if (diskFreeSize >= 16384)
386             urlCacheDiskCapacity = 50 * 1024 * 1024;
387         else if (diskFreeSize >= 8192)
388             urlCacheDiskCapacity = 40 * 1024 * 1024;
389         else if (diskFreeSize >= 4096)
390             urlCacheDiskCapacity = 30 * 1024 * 1024;
391         else
392             urlCacheDiskCapacity = 20 * 1024 * 1024;
393
394         break;
395     }
396     case CacheModelPrimaryWebBrowser: {
397         // Page cache capacity (in pages)
398         // (Research indicates that value / page drops substantially after 3 pages.)
399         if (memorySize >= 2048)
400             pageCacheCapacity = 5;
401         else if (memorySize >= 1024)
402             pageCacheCapacity = 4;
403         else if (memorySize >= 512)
404             pageCacheCapacity = 3;
405         else if (memorySize >= 256)
406             pageCacheCapacity = 2;
407         else
408             pageCacheCapacity = 1;
409
410         // Object cache capacities (in bytes)
411         // (Testing indicates that value / MB depends heavily on content and
412         // browsing pattern. Even growth above 128MB can have substantial 
413         // value / MB for some content / browsing patterns.)
414         if (memorySize >= 2048)
415             cacheTotalCapacity = 128 * 1024 * 1024;
416         else if (memorySize >= 1536)
417             cacheTotalCapacity = 96 * 1024 * 1024;
418         else if (memorySize >= 1024)
419             cacheTotalCapacity = 64 * 1024 * 1024;
420         else if (memorySize >= 512)
421             cacheTotalCapacity = 32 * 1024 * 1024;
422
423         cacheMinDeadCapacity = cacheTotalCapacity / 4;
424         cacheMaxDeadCapacity = cacheTotalCapacity / 2;
425
426         // This code is here to avoid a PLT regression. We can remove it if we
427         // can prove that the overall system gain would justify the regression.
428         cacheMaxDeadCapacity = std::max(24u, cacheMaxDeadCapacity);
429
430         deadDecodedDataDeletionInterval = 60;
431
432         // Foundation memory cache capacity (in bytes)
433         // (These values are small because WebCore does most caching itself.)
434         if (memorySize >= 1024)
435             urlCacheMemoryCapacity = 4 * 1024 * 1024;
436         else if (memorySize >= 512)
437             urlCacheMemoryCapacity = 2 * 1024 * 1024;
438         else if (memorySize >= 256)
439             urlCacheMemoryCapacity = 1 * 1024 * 1024;
440         else
441             urlCacheMemoryCapacity =      512 * 1024; 
442
443         // Foundation disk cache capacity (in bytes)
444         if (diskFreeSize >= 16384)
445             urlCacheDiskCapacity = 175 * 1024 * 1024;
446         else if (diskFreeSize >= 8192)
447             urlCacheDiskCapacity = 150 * 1024 * 1024;
448         else if (diskFreeSize >= 4096)
449             urlCacheDiskCapacity = 125 * 1024 * 1024;
450         else if (diskFreeSize >= 2048)
451             urlCacheDiskCapacity = 100 * 1024 * 1024;
452         else if (diskFreeSize >= 1024)
453             urlCacheDiskCapacity = 75 * 1024 * 1024;
454         else
455             urlCacheDiskCapacity = 50 * 1024 * 1024;
456
457         break;
458     }
459     default:
460         ASSERT_NOT_REACHED();
461     };
462 }
463
464 WebPage* WebProcess::focusedWebPage() const
465 {    
466     HashMap<uint64_t, RefPtr<WebPage> >::const_iterator end = m_pageMap.end();
467     for (HashMap<uint64_t, RefPtr<WebPage> >::const_iterator it = m_pageMap.begin(); it != end; ++it) {
468         WebPage* page = (*it).second.get();
469         if (page->windowIsFocused())
470             return page;
471     }
472     return 0;
473 }
474     
475 WebPage* WebProcess::webPage(uint64_t pageID) const
476 {
477     return m_pageMap.get(pageID).get();
478 }
479
480 void WebProcess::createWebPage(uint64_t pageID, const WebPageCreationParameters& parameters)
481 {
482     // It is necessary to check for page existence here since during a window.open() (or targeted
483     // link) the WebPage gets created both in the synchronous handler and through the normal way. 
484     std::pair<HashMap<uint64_t, RefPtr<WebPage> >::iterator, bool> result = m_pageMap.add(pageID, 0);
485     if (result.second) {
486         ASSERT(!result.first->second);
487         result.first->second = WebPage::create(pageID, parameters);
488     }
489
490     ASSERT(result.first->second);
491 }
492
493 void WebProcess::removeWebPage(uint64_t pageID)
494 {
495     m_pageMap.remove(pageID);
496     terminateIfPossible();
497 }
498
499 bool WebProcess::isSeparateProcess() const
500 {
501     // If we're running on the main run loop, we assume that we're in a separate process.
502     return m_runLoop == RunLoop::main();
503 }
504  
505 void WebProcess::terminateIfPossible()
506 {
507     if (!m_pageMap.isEmpty())
508         return;
509
510     if (m_inDidClose)
511         return;
512
513     if (DownloadManager::shared().isDownloading())
514         return;
515
516     // Keep running forever if we're running in the same process.
517     if (!isSeparateProcess())
518         return;
519
520     // FIXME: the ShouldTerminate message should also send termination parameters, such as any session cookies that need to be preserved.
521     bool shouldTerminate = false;
522     if (m_connection->sendSync(Messages::WebProcessProxy::ShouldTerminate(), Messages::WebProcessProxy::ShouldTerminate::Reply(shouldTerminate), 0)
523         && !shouldTerminate)
524         return;
525
526     // Actually terminate the process.
527
528 #ifndef NDEBUG
529     gcController().garbageCollectNow();
530     memoryCache()->setDisabled(true);
531 #endif
532
533     // Invalidate our connection.
534     m_connection->invalidate();
535     m_connection = nullptr;
536
537     platformTerminate();
538     m_runLoop->stop();
539 }
540
541 CoreIPC::SyncReplyMode WebProcess::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder* reply)
542 {   
543     uint64_t pageID = arguments->destinationID();
544     if (!pageID)
545         return CoreIPC::AutomaticReply;
546     
547     WebPage* page = webPage(pageID);
548     if (!page)
549         return CoreIPC::AutomaticReply;
550     
551     page->didReceiveSyncMessage(connection, messageID, arguments, reply);
552     return CoreIPC::AutomaticReply;
553 }
554
555 void WebProcess::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
556 {
557     if (messageID.is<CoreIPC::MessageClassWebProcess>()) {
558         didReceiveWebProcessMessage(connection, messageID, arguments);
559         return;
560     }
561
562     if (messageID.is<CoreIPC::MessageClassAuthenticationManager>()) {
563         AuthenticationManager::shared().didReceiveMessage(connection, messageID, arguments);
564         return;
565     }
566
567     if (messageID.is<CoreIPC::MessageClassWebApplicationCacheManager>()) {
568         WebApplicationCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
569         return;
570     }
571
572     if (messageID.is<CoreIPC::MessageClassWebCookieManager>()) {
573         WebCookieManager::shared().didReceiveMessage(connection, messageID, arguments);
574         return;
575     }
576
577     if (messageID.is<CoreIPC::MessageClassWebDatabaseManager>()) {
578         WebDatabaseManager::shared().didReceiveMessage(connection, messageID, arguments);
579         return;
580     }
581
582     if (messageID.is<CoreIPC::MessageClassWebGeolocationManager>()) {
583         m_geolocationManager.didReceiveMessage(connection, messageID, arguments);
584         return;
585     }
586
587     if (messageID.is<CoreIPC::MessageClassWebIconDatabaseProxy>()) {
588         m_iconDatabaseProxy.didReceiveMessage(connection, messageID, arguments);
589         return;
590     }
591
592     if (messageID.is<CoreIPC::MessageClassWebKeyValueStorageManager>()) {
593         WebKeyValueStorageManager::shared().didReceiveMessage(connection, messageID, arguments);
594         return;
595     }
596
597     if (messageID.is<CoreIPC::MessageClassWebMediaCacheManager>()) {
598         WebMediaCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
599         return;
600     }
601
602     if (messageID.is<CoreIPC::MessageClassWebResourceCacheManager>()) {
603         WebResourceCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
604         return;
605     }
606
607     if (messageID.is<CoreIPC::MessageClassInjectedBundle>()) {
608         if (!m_injectedBundle)
609             return;
610         m_injectedBundle->didReceiveMessage(connection, messageID, arguments);    
611         return;
612     }
613
614     uint64_t pageID = arguments->destinationID();
615     if (!pageID)
616         return;
617     
618     WebPage* page = webPage(pageID);
619     if (!page)
620         return;
621     
622     page->didReceiveMessage(connection, messageID, arguments);
623 }
624
625 void WebProcess::didClose(CoreIPC::Connection*)
626 {
627     // When running in the same process the connection will never be closed.
628     ASSERT(isSeparateProcess());
629
630 #ifndef NDEBUG
631     m_inDidClose = true;
632
633     // Close all the live pages.
634     Vector<RefPtr<WebPage> > pages;
635     copyValuesToVector(m_pageMap, pages);
636     for (size_t i = 0; i < pages.size(); ++i)
637         pages[i]->close();
638     pages.clear();
639
640     gcController().garbageCollectNow();
641     memoryCache()->setDisabled(true);
642 #endif    
643
644     // The UI process closed this connection, shut down.
645     m_runLoop->stop();
646 }
647
648 void WebProcess::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::MessageID)
649 {
650     // We received an invalid message, but since this is from the UI process (which we trust),
651     // we'll let it slide.
652 }
653
654 NO_RETURN void WebProcess::didFailToSendSyncMessage(CoreIPC::Connection*)
655 {
656     // We were making a synchronous call to a UI process that doesn't exist any more.
657     // Callers are unlikely to be prepared for an error like this, so it's best to exit immediately.
658     exit(0);
659 }
660
661 WebFrame* WebProcess::webFrame(uint64_t frameID) const
662 {
663     return m_frameMap.get(frameID);
664 }
665
666 void WebProcess::addWebFrame(uint64_t frameID, WebFrame* frame)
667 {
668     m_frameMap.set(frameID, frame);
669 }
670
671 void WebProcess::removeWebFrame(uint64_t frameID)
672 {
673     m_frameMap.remove(frameID);
674
675     // We can end up here after our connection has closed when WebCore's frame life-support timer
676     // fires when the application is shutting down. There's no need (and no way) to update the UI
677     // process in this case.
678     if (!m_connection)
679         return;
680
681     m_connection->send(Messages::WebProcessProxy::DidDestroyFrame(frameID), 0);
682 }
683
684 WebPageGroupProxy* WebProcess::webPageGroup(uint64_t pageGroupID)
685 {
686     return m_pageGroupMap.get(pageGroupID).get();
687 }
688
689 WebPageGroupProxy* WebProcess::webPageGroup(const WebPageGroupData& pageGroupData)
690 {
691     std::pair<HashMap<uint64_t, RefPtr<WebPageGroupProxy> >::iterator, bool> result = m_pageGroupMap.add(pageGroupData.pageGroupID, 0);
692     if (result.second) {
693         ASSERT(!result.first->second);
694         result.first->second = WebPageGroupProxy::create(pageGroupData);
695     }
696
697     return result.first->second.get();
698 }
699
700 void WebProcess::clearResourceCaches(ResourceCachesToClear resourceCachesToClear)
701 {
702     platformClearResourceCaches(resourceCachesToClear);
703
704     // Toggling the cache model like this forces the cache to evict all its in-memory resources.
705     // FIXME: We need a better way to do this.
706     CacheModel cacheModel = m_cacheModel;
707     setCacheModel(CacheModelDocumentViewer);
708     setCacheModel(cacheModel);
709
710     memoryCache()->evictResources();
711
712     // Empty the cross-origin preflight cache.
713     CrossOriginPreflightResultCache::shared().empty();
714 }
715
716 void WebProcess::clearApplicationCache()
717 {
718 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
719     // Empty the application cache.
720     cacheStorage().empty();
721 #endif
722 }
723
724 #if !ENABLE(PLUGIN_PROCESS)
725 void WebProcess::getSitesWithPluginData(const Vector<String>& pluginPaths, uint64_t callbackID)
726 {
727     HashSet<String> sitesSet;
728
729     for (size_t i = 0; i < pluginPaths.size(); ++i) {
730         RefPtr<NetscapePluginModule> netscapePluginModule = NetscapePluginModule::getOrCreate(pluginPaths[i]);
731         if (!netscapePluginModule)
732             continue;
733
734         Vector<String> sites = netscapePluginModule->sitesWithData();
735         for (size_t i = 0; i < sites.size(); ++i)
736             sitesSet.add(sites[i]);
737     }
738
739     Vector<String> sites;
740     copyToVector(sitesSet, sites);
741
742     m_connection->send(Messages::WebContext::DidGetSitesWithPluginData(sites, callbackID), 0);
743     terminateIfPossible();
744 }
745
746 void WebProcess::clearPluginSiteData(const Vector<String>& pluginPaths, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID)
747 {
748     for (size_t i = 0; i < pluginPaths.size(); ++i) {
749         RefPtr<NetscapePluginModule> netscapePluginModule = NetscapePluginModule::getOrCreate(pluginPaths[i]);
750         if (!netscapePluginModule)
751             continue;
752
753         if (sites.isEmpty()) {
754             // Clear everything.
755             netscapePluginModule->clearSiteData(String(), flags, maxAgeInSeconds);
756             continue;
757         }
758
759         for (size_t i = 0; i < sites.size(); ++i)
760             netscapePluginModule->clearSiteData(sites[i], flags, maxAgeInSeconds);
761     }
762
763     m_connection->send(Messages::WebContext::DidClearPluginSiteData(callbackID), 0);
764     terminateIfPossible();
765 }
766 #endif
767
768 void WebProcess::downloadRequest(uint64_t downloadID, uint64_t initiatingPageID, const ResourceRequest& request)
769 {
770     WebPage* initiatingPage = initiatingPageID ? webPage(initiatingPageID) : 0;
771
772     DownloadManager::shared().startDownload(downloadID, initiatingPage, request);
773 }
774
775 void WebProcess::cancelDownload(uint64_t downloadID)
776 {
777     DownloadManager::shared().cancelDownload(downloadID);
778 }
779
780 void WebProcess::setEnhancedAccessibility(bool flag)
781 {
782     WebCore::AXObjectCache::setEnhancedUserInterfaceAccessibility(flag);
783 }
784     
785 void WebProcess::startMemorySampler(const SandboxExtension::Handle& sampleLogFileHandle, const String& sampleLogFilePath, const double interval)
786 {
787 #if ENABLE(MEMORY_SAMPLER)    
788     WebMemorySampler::shared()->start(sampleLogFileHandle, sampleLogFilePath, interval);
789 #endif
790 }
791     
792 void WebProcess::stopMemorySampler()
793 {
794 #if ENABLE(MEMORY_SAMPLER)
795     WebMemorySampler::shared()->stop();
796 #endif
797 }
798
799 void WebProcess::setTextCheckerState(const TextCheckerState& textCheckerState)
800 {
801     m_textCheckerState = textCheckerState;
802 }
803
804 } // namespace WebKit