ba3290b3101af7b64a2cd8de700435994163638f
[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 (parameters.clearResourceCaches)
219         clearResourceCaches();
220     if (parameters.clearApplicationCache)
221         clearApplicationCache();
222     
223 #if PLATFORM(MAC)
224     m_presenterApplicationPid = parameters.presenterApplicationPid;
225 #endif
226
227     if (parameters.shouldAlwaysUseComplexTextCodePath)
228         setAlwaysUsesComplexTextCodePath(true);
229
230 #if USE(CFURLSTORAGESESSIONS)
231     WebCore::ResourceHandle::setPrivateBrowsingStorageSessionIdentifierBase(parameters.uiProcessBundleIdentifier);
232 #endif
233 }
234
235 void WebProcess::setShouldTrackVisitedLinks(bool shouldTrackVisitedLinks)
236 {
237     PageGroup::setShouldTrackVisitedLinks(shouldTrackVisitedLinks);
238 }
239
240 void WebProcess::registerURLSchemeAsEmptyDocument(const String& urlScheme)
241 {
242     SchemeRegistry::registerURLSchemeAsEmptyDocument(urlScheme);
243 }
244
245 void WebProcess::registerURLSchemeAsSecure(const String& urlScheme) const
246 {
247     SchemeRegistry::registerURLSchemeAsSecure(urlScheme);
248 }
249
250 void WebProcess::setDomainRelaxationForbiddenForURLScheme(const String& urlScheme) const
251 {
252     SecurityOrigin::setDomainRelaxationForbiddenForURLScheme(true, urlScheme);
253 }
254
255 void WebProcess::setDefaultRequestTimeoutInterval(double timeoutInterval)
256 {
257     ResourceRequest::setDefaultTimeoutInterval(timeoutInterval);
258 }
259
260 void WebProcess::setAlwaysUsesComplexTextCodePath(bool alwaysUseComplexText)
261 {
262     WebCore::Font::setCodePath(alwaysUseComplexText ? WebCore::Font::Complex : WebCore::Font::Auto);
263 }
264
265 void WebProcess::languageChanged(const String& language) const
266 {
267     overrideDefaultLanguage(language);
268 }
269
270 void WebProcess::setVisitedLinkTable(const SharedMemory::Handle& handle)
271 {
272     RefPtr<SharedMemory> sharedMemory = SharedMemory::create(handle, SharedMemory::ReadOnly);
273     if (!sharedMemory)
274         return;
275
276     m_visitedLinkTable.setSharedMemory(sharedMemory.release());
277 }
278
279 PageGroup* WebProcess::sharedPageGroup()
280 {
281     return PageGroup::pageGroup("WebKit2Group");
282 }
283
284 void WebProcess::visitedLinkStateChanged(const Vector<WebCore::LinkHash>& linkHashes)
285 {
286     for (size_t i = 0; i < linkHashes.size(); ++i)
287         Page::visitedStateChanged(sharedPageGroup(), linkHashes[i]);
288 }
289
290 void WebProcess::allVisitedLinkStateChanged()
291 {
292     Page::allVisitedStateChanged(sharedPageGroup());
293 }
294
295 bool WebProcess::isLinkVisited(LinkHash linkHash) const
296 {
297     return m_visitedLinkTable.isLinkVisited(linkHash);
298 }
299
300 void WebProcess::addVisitedLink(WebCore::LinkHash linkHash)
301 {
302     if (isLinkVisited(linkHash))
303         return;
304     m_connection->send(Messages::WebContext::AddVisitedLinkHash(linkHash), 0);
305 }
306
307 #if !PLATFORM(MAC)
308 bool WebProcess::fullKeyboardAccessEnabled()
309 {
310     return false;
311 }
312 #endif
313
314 void WebProcess::setCacheModel(uint32_t cm)
315 {
316     CacheModel cacheModel = static_cast<CacheModel>(cm);
317
318     if (!m_hasSetCacheModel || cacheModel != m_cacheModel) {
319         m_hasSetCacheModel = true;
320         m_cacheModel = cacheModel;
321         platformSetCacheModel(cacheModel);
322     }
323 }
324
325 void WebProcess::calculateCacheSizes(CacheModel cacheModel, uint64_t memorySize, uint64_t diskFreeSize,
326     unsigned& cacheTotalCapacity, unsigned& cacheMinDeadCapacity, unsigned& cacheMaxDeadCapacity, double& deadDecodedDataDeletionInterval,
327     unsigned& pageCacheCapacity, unsigned long& urlCacheMemoryCapacity, unsigned long& urlCacheDiskCapacity)
328 {
329     switch (cacheModel) {
330     case CacheModelDocumentViewer: {
331         // Page cache capacity (in pages)
332         pageCacheCapacity = 0;
333
334         // Object cache capacities (in bytes)
335         if (memorySize >= 2048)
336             cacheTotalCapacity = 96 * 1024 * 1024;
337         else if (memorySize >= 1536)
338             cacheTotalCapacity = 64 * 1024 * 1024;
339         else if (memorySize >= 1024)
340             cacheTotalCapacity = 32 * 1024 * 1024;
341         else if (memorySize >= 512)
342             cacheTotalCapacity = 16 * 1024 * 1024;
343
344         cacheMinDeadCapacity = 0;
345         cacheMaxDeadCapacity = 0;
346
347         // Foundation memory cache capacity (in bytes)
348         urlCacheMemoryCapacity = 0;
349
350         // Foundation disk cache capacity (in bytes)
351         urlCacheDiskCapacity = 0;
352
353         break;
354     }
355     case CacheModelDocumentBrowser: {
356         // Page cache capacity (in pages)
357         if (memorySize >= 1024)
358             pageCacheCapacity = 3;
359         else if (memorySize >= 512)
360             pageCacheCapacity = 2;
361         else if (memorySize >= 256)
362             pageCacheCapacity = 1;
363         else
364             pageCacheCapacity = 0;
365
366         // Object cache capacities (in bytes)
367         if (memorySize >= 2048)
368             cacheTotalCapacity = 96 * 1024 * 1024;
369         else if (memorySize >= 1536)
370             cacheTotalCapacity = 64 * 1024 * 1024;
371         else if (memorySize >= 1024)
372             cacheTotalCapacity = 32 * 1024 * 1024;
373         else if (memorySize >= 512)
374             cacheTotalCapacity = 16 * 1024 * 1024;
375
376         cacheMinDeadCapacity = cacheTotalCapacity / 8;
377         cacheMaxDeadCapacity = cacheTotalCapacity / 4;
378
379         // Foundation memory cache capacity (in bytes)
380         if (memorySize >= 2048)
381             urlCacheMemoryCapacity = 4 * 1024 * 1024;
382         else if (memorySize >= 1024)
383             urlCacheMemoryCapacity = 2 * 1024 * 1024;
384         else if (memorySize >= 512)
385             urlCacheMemoryCapacity = 1 * 1024 * 1024;
386         else
387             urlCacheMemoryCapacity =      512 * 1024; 
388
389         // Foundation disk cache capacity (in bytes)
390         if (diskFreeSize >= 16384)
391             urlCacheDiskCapacity = 50 * 1024 * 1024;
392         else if (diskFreeSize >= 8192)
393             urlCacheDiskCapacity = 40 * 1024 * 1024;
394         else if (diskFreeSize >= 4096)
395             urlCacheDiskCapacity = 30 * 1024 * 1024;
396         else
397             urlCacheDiskCapacity = 20 * 1024 * 1024;
398
399         break;
400     }
401     case CacheModelPrimaryWebBrowser: {
402         // Page cache capacity (in pages)
403         // (Research indicates that value / page drops substantially after 3 pages.)
404         if (memorySize >= 2048)
405             pageCacheCapacity = 5;
406         else if (memorySize >= 1024)
407             pageCacheCapacity = 4;
408         else if (memorySize >= 512)
409             pageCacheCapacity = 3;
410         else if (memorySize >= 256)
411             pageCacheCapacity = 2;
412         else
413             pageCacheCapacity = 1;
414
415         // Object cache capacities (in bytes)
416         // (Testing indicates that value / MB depends heavily on content and
417         // browsing pattern. Even growth above 128MB can have substantial 
418         // value / MB for some content / browsing patterns.)
419         if (memorySize >= 2048)
420             cacheTotalCapacity = 128 * 1024 * 1024;
421         else if (memorySize >= 1536)
422             cacheTotalCapacity = 96 * 1024 * 1024;
423         else if (memorySize >= 1024)
424             cacheTotalCapacity = 64 * 1024 * 1024;
425         else if (memorySize >= 512)
426             cacheTotalCapacity = 32 * 1024 * 1024;
427
428         cacheMinDeadCapacity = cacheTotalCapacity / 4;
429         cacheMaxDeadCapacity = cacheTotalCapacity / 2;
430
431         // This code is here to avoid a PLT regression. We can remove it if we
432         // can prove that the overall system gain would justify the regression.
433         cacheMaxDeadCapacity = std::max(24u, cacheMaxDeadCapacity);
434
435         deadDecodedDataDeletionInterval = 60;
436
437         // Foundation memory cache capacity (in bytes)
438         // (These values are small because WebCore does most caching itself.)
439         if (memorySize >= 1024)
440             urlCacheMemoryCapacity = 4 * 1024 * 1024;
441         else if (memorySize >= 512)
442             urlCacheMemoryCapacity = 2 * 1024 * 1024;
443         else if (memorySize >= 256)
444             urlCacheMemoryCapacity = 1 * 1024 * 1024;
445         else
446             urlCacheMemoryCapacity =      512 * 1024; 
447
448         // Foundation disk cache capacity (in bytes)
449         if (diskFreeSize >= 16384)
450             urlCacheDiskCapacity = 175 * 1024 * 1024;
451         else if (diskFreeSize >= 8192)
452             urlCacheDiskCapacity = 150 * 1024 * 1024;
453         else if (diskFreeSize >= 4096)
454             urlCacheDiskCapacity = 125 * 1024 * 1024;
455         else if (diskFreeSize >= 2048)
456             urlCacheDiskCapacity = 100 * 1024 * 1024;
457         else if (diskFreeSize >= 1024)
458             urlCacheDiskCapacity = 75 * 1024 * 1024;
459         else
460             urlCacheDiskCapacity = 50 * 1024 * 1024;
461
462         break;
463     }
464     default:
465         ASSERT_NOT_REACHED();
466     };
467 }
468
469 WebPage* WebProcess::focusedWebPage() const
470 {    
471     HashMap<uint64_t, RefPtr<WebPage> >::const_iterator end = m_pageMap.end();
472     for (HashMap<uint64_t, RefPtr<WebPage> >::const_iterator it = m_pageMap.begin(); it != end; ++it) {
473         WebPage* page = (*it).second.get();
474         if (page->windowIsFocused())
475             return page;
476     }
477     return 0;
478 }
479     
480 WebPage* WebProcess::webPage(uint64_t pageID) const
481 {
482     return m_pageMap.get(pageID).get();
483 }
484
485 void WebProcess::createWebPage(uint64_t pageID, const WebPageCreationParameters& parameters)
486 {
487     // It is necessary to check for page existence here since during a window.open() (or targeted
488     // link) the WebPage gets created both in the synchronous handler and through the normal way. 
489     std::pair<HashMap<uint64_t, RefPtr<WebPage> >::iterator, bool> result = m_pageMap.add(pageID, 0);
490     if (result.second) {
491         ASSERT(!result.first->second);
492         result.first->second = WebPage::create(pageID, parameters);
493     }
494
495     ASSERT(result.first->second);
496 }
497
498 void WebProcess::removeWebPage(uint64_t pageID)
499 {
500     m_pageMap.remove(pageID);
501     terminateIfPossible();
502 }
503
504 bool WebProcess::isSeparateProcess() const
505 {
506     // If we're running on the main run loop, we assume that we're in a separate process.
507     return m_runLoop == RunLoop::main();
508 }
509  
510 void WebProcess::terminateIfPossible()
511 {
512     if (!m_pageMap.isEmpty())
513         return;
514
515     if (m_inDidClose)
516         return;
517
518     if (DownloadManager::shared().isDownloading())
519         return;
520
521     // Keep running forever if we're running in the same process.
522     if (!isSeparateProcess())
523         return;
524
525     // FIXME: the ShouldTerminate message should also send termination parameters, such as any session cookies that need to be preserved.
526     bool shouldTerminate = false;
527     if (m_connection->sendSync(Messages::WebProcessProxy::ShouldTerminate(), Messages::WebProcessProxy::ShouldTerminate::Reply(shouldTerminate), 0)
528         && !shouldTerminate)
529         return;
530
531     // Actually terminate the process.
532
533 #ifndef NDEBUG
534     gcController().garbageCollectNow();
535     memoryCache()->setDisabled(true);
536 #endif
537
538     // Invalidate our connection.
539     m_connection->invalidate();
540     m_connection = nullptr;
541
542     platformTerminate();
543     m_runLoop->stop();
544 }
545
546 CoreIPC::SyncReplyMode WebProcess::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder* reply)
547 {   
548     uint64_t pageID = arguments->destinationID();
549     if (!pageID)
550         return CoreIPC::AutomaticReply;
551     
552     WebPage* page = webPage(pageID);
553     if (!page)
554         return CoreIPC::AutomaticReply;
555     
556     page->didReceiveSyncMessage(connection, messageID, arguments, reply);
557     return CoreIPC::AutomaticReply;
558 }
559
560 void WebProcess::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
561 {
562     if (messageID.is<CoreIPC::MessageClassWebProcess>()) {
563         didReceiveWebProcessMessage(connection, messageID, arguments);
564         return;
565     }
566
567     if (messageID.is<CoreIPC::MessageClassAuthenticationManager>()) {
568         AuthenticationManager::shared().didReceiveMessage(connection, messageID, arguments);
569         return;
570     }
571
572     if (messageID.is<CoreIPC::MessageClassWebApplicationCacheManager>()) {
573         WebApplicationCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
574         return;
575     }
576
577     if (messageID.is<CoreIPC::MessageClassWebCookieManager>()) {
578         WebCookieManager::shared().didReceiveMessage(connection, messageID, arguments);
579         return;
580     }
581
582     if (messageID.is<CoreIPC::MessageClassWebDatabaseManager>()) {
583         WebDatabaseManager::shared().didReceiveMessage(connection, messageID, arguments);
584         return;
585     }
586
587     if (messageID.is<CoreIPC::MessageClassWebGeolocationManager>()) {
588         m_geolocationManager.didReceiveMessage(connection, messageID, arguments);
589         return;
590     }
591
592     if (messageID.is<CoreIPC::MessageClassWebIconDatabaseProxy>()) {
593         m_iconDatabaseProxy.didReceiveMessage(connection, messageID, arguments);
594         return;
595     }
596
597     if (messageID.is<CoreIPC::MessageClassWebKeyValueStorageManager>()) {
598         WebKeyValueStorageManager::shared().didReceiveMessage(connection, messageID, arguments);
599         return;
600     }
601
602     if (messageID.is<CoreIPC::MessageClassWebMediaCacheManager>()) {
603         WebMediaCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
604         return;
605     }
606
607     if (messageID.is<CoreIPC::MessageClassWebResourceCacheManager>()) {
608         WebResourceCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
609         return;
610     }
611
612     if (messageID.is<CoreIPC::MessageClassInjectedBundle>()) {
613         if (!m_injectedBundle)
614             return;
615         m_injectedBundle->didReceiveMessage(connection, messageID, arguments);    
616         return;
617     }
618
619     uint64_t pageID = arguments->destinationID();
620     if (!pageID)
621         return;
622     
623     WebPage* page = webPage(pageID);
624     if (!page)
625         return;
626     
627     page->didReceiveMessage(connection, messageID, arguments);
628 }
629
630 void WebProcess::didClose(CoreIPC::Connection*)
631 {
632     // When running in the same process the connection will never be closed.
633     ASSERT(isSeparateProcess());
634
635 #ifndef NDEBUG
636     m_inDidClose = true;
637
638     // Close all the live pages.
639     Vector<RefPtr<WebPage> > pages;
640     copyValuesToVector(m_pageMap, pages);
641     for (size_t i = 0; i < pages.size(); ++i)
642         pages[i]->close();
643     pages.clear();
644
645     gcController().garbageCollectNow();
646     memoryCache()->setDisabled(true);
647 #endif    
648
649     // The UI process closed this connection, shut down.
650     m_runLoop->stop();
651 }
652
653 void WebProcess::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::MessageID)
654 {
655     // We received an invalid message, but since this is from the UI process (which we trust),
656     // we'll let it slide.
657 }
658
659 NO_RETURN void WebProcess::didFailToSendSyncMessage(CoreIPC::Connection*)
660 {
661     // We were making a synchronous call to a UI process that doesn't exist any more.
662     // Callers are unlikely to be prepared for an error like this, so it's best to exit immediately.
663     exit(0);
664 }
665
666 WebFrame* WebProcess::webFrame(uint64_t frameID) const
667 {
668     return m_frameMap.get(frameID);
669 }
670
671 void WebProcess::addWebFrame(uint64_t frameID, WebFrame* frame)
672 {
673     m_frameMap.set(frameID, frame);
674 }
675
676 void WebProcess::removeWebFrame(uint64_t frameID)
677 {
678     m_frameMap.remove(frameID);
679
680     // We can end up here after our connection has closed when WebCore's frame life-support timer
681     // fires when the application is shutting down. There's no need (and no way) to update the UI
682     // process in this case.
683     if (!m_connection)
684         return;
685
686     m_connection->send(Messages::WebProcessProxy::DidDestroyFrame(frameID), 0);
687 }
688
689 WebPageGroupProxy* WebProcess::webPageGroup(uint64_t pageGroupID)
690 {
691     return m_pageGroupMap.get(pageGroupID).get();
692 }
693
694 WebPageGroupProxy* WebProcess::webPageGroup(const WebPageGroupData& pageGroupData)
695 {
696     std::pair<HashMap<uint64_t, RefPtr<WebPageGroupProxy> >::iterator, bool> result = m_pageGroupMap.add(pageGroupData.pageGroupID, 0);
697     if (result.second) {
698         ASSERT(!result.first->second);
699         result.first->second = WebPageGroupProxy::create(pageGroupData);
700     }
701
702     return result.first->second.get();
703 }
704
705 void WebProcess::clearResourceCaches(uint32_t cachesToClear)
706 {
707     ResourceCachesToClear resourceCachesToClear = static_cast<ResourceCachesToClear>(cachesToClear);
708
709     platformClearResourceCaches(resourceCachesToClear);
710
711     // Toggling the cache model like this forces the cache to evict all its in-memory resources.
712     // FIXME: We need a better way to do this.
713     CacheModel cacheModel = m_cacheModel;
714     setCacheModel(CacheModelDocumentViewer);
715     setCacheModel(cacheModel);
716
717     memoryCache()->evictResources();
718
719     // Empty the cross-origin preflight cache.
720     CrossOriginPreflightResultCache::shared().empty();
721 }
722
723 void WebProcess::clearApplicationCache()
724 {
725 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
726     // Empty the application cache.
727     cacheStorage().empty();
728 #endif
729 }
730
731 #if !ENABLE(PLUGIN_PROCESS)
732 void WebProcess::getSitesWithPluginData(const Vector<String>& pluginPaths, uint64_t callbackID)
733 {
734     HashSet<String> sitesSet;
735
736     for (size_t i = 0; i < pluginPaths.size(); ++i) {
737         RefPtr<NetscapePluginModule> netscapePluginModule = NetscapePluginModule::getOrCreate(pluginPaths[i]);
738         if (!netscapePluginModule)
739             continue;
740
741         Vector<String> sites = netscapePluginModule->sitesWithData();
742         for (size_t i = 0; i < sites.size(); ++i)
743             sitesSet.add(sites[i]);
744     }
745
746     Vector<String> sites;
747     copyToVector(sitesSet, sites);
748
749     m_connection->send(Messages::WebContext::DidGetSitesWithPluginData(sites, callbackID), 0);
750     terminateIfPossible();
751 }
752
753 void WebProcess::clearPluginSiteData(const Vector<String>& pluginPaths, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID)
754 {
755     for (size_t i = 0; i < pluginPaths.size(); ++i) {
756         RefPtr<NetscapePluginModule> netscapePluginModule = NetscapePluginModule::getOrCreate(pluginPaths[i]);
757         if (!netscapePluginModule)
758             continue;
759
760         if (sites.isEmpty()) {
761             // Clear everything.
762             netscapePluginModule->clearSiteData(String(), flags, maxAgeInSeconds);
763             continue;
764         }
765
766         for (size_t i = 0; i < sites.size(); ++i)
767             netscapePluginModule->clearSiteData(sites[i], flags, maxAgeInSeconds);
768     }
769
770     m_connection->send(Messages::WebContext::DidClearPluginSiteData(callbackID), 0);
771     terminateIfPossible();
772 }
773 #endif
774
775 void WebProcess::downloadRequest(uint64_t downloadID, uint64_t initiatingPageID, const ResourceRequest& request)
776 {
777     WebPage* initiatingPage = initiatingPageID ? webPage(initiatingPageID) : 0;
778
779     DownloadManager::shared().startDownload(downloadID, initiatingPage, request);
780 }
781
782 void WebProcess::cancelDownload(uint64_t downloadID)
783 {
784     DownloadManager::shared().cancelDownload(downloadID);
785 }
786
787 void WebProcess::setEnhancedAccessibility(bool flag)
788 {
789     WebCore::AXObjectCache::setEnhancedUserInterfaceAccessibility(flag);
790 }
791     
792 void WebProcess::startMemorySampler(const SandboxExtension::Handle& sampleLogFileHandle, const String& sampleLogFilePath, const double interval)
793 {
794 #if ENABLE(MEMORY_SAMPLER)    
795     WebMemorySampler::shared()->start(sampleLogFileHandle, sampleLogFilePath, interval);
796 #endif
797 }
798     
799 void WebProcess::stopMemorySampler()
800 {
801 #if ENABLE(MEMORY_SAMPLER)
802     WebMemorySampler::shared()->stop();
803 #endif
804 }
805
806 void WebProcess::setTextCheckerState(const TextCheckerState& textCheckerState)
807 {
808     m_textCheckerState = textCheckerState;
809 }
810
811 } // namespace WebKit