GraphicsLayer::client() should return a reference.
[WebKit-https.git] / Source / WebKit / win / WebView.cpp
1 /*
2  * Copyright (C) 2006-2013 Apple, Inc.  All rights reserved.
3  * Copyright (C) 2009, 2010, 2011 Appcelerator, Inc. All rights reserved.
4  * Copyright (C) 2011 Brent Fulgham. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #include "config.h"
29 #include "WebView.h"
30
31 #include "BackForwardController.h"
32 #include "COMVariantSetter.h"
33 #include "DOMCoreClasses.h"
34 #include "FullscreenVideoController.h"
35 #include "MarshallingHelpers.h"
36 #include "SoftLinking.h"
37 #include "SubframeLoader.h"
38 #include "TextIterator.h"
39 #include "WebBackForwardList.h"
40 #include "WebChromeClient.h"
41 #include "WebContextMenuClient.h"
42 #include "WebCoreTextRenderer.h"
43 #include "WebDatabaseManager.h"
44 #include "WebDocumentLoader.h"
45 #include "WebDownload.h"
46 #include "WebDragClient.h"
47 #include "WebEditorClient.h"
48 #include "WebElementPropertyBag.h"
49 #include "WebFrame.h"
50 #include "WebFrameLoaderClient.h"
51 #include "WebFrameNetworkingContext.h"
52 #include "WebGeolocationClient.h"
53 #include "WebGeolocationPosition.h"
54 #include "WebIconDatabase.h"
55 #include "WebInspector.h"
56 #include "WebInspectorClient.h"
57 #include "WebKit.h"
58 #include "WebKitDLL.h"
59 #include "WebKitLogging.h"
60 #include "WebKitStatisticsPrivate.h"
61 #include "WebKitSystemBits.h"
62 #include "WebKitVersion.h"
63 #include "WebMutableURLRequest.h"
64 #include "WebNotificationCenter.h"
65 #include "WebPlatformStrategies.h"
66 #include "WebPreferences.h"
67 #include "WebScriptWorld.h"
68 #include "resource.h"
69 #include <JavaScriptCore/APICast.h>
70 #include <JavaScriptCore/InitializeThreading.h>
71 #include <JavaScriptCore/JSCJSValue.h>
72 #include <JavaScriptCore/JSLock.h>
73 #include <WebCore/AXObjectCache.h>
74 #include <WebCore/ApplicationCacheStorage.h>
75 #include <WebCore/BString.h>
76 #include <WebCore/BackForwardController.h>
77 #include <WebCore/BackForwardList.h>
78 #include <WebCore/BitmapInfo.h>
79 #include <WebCore/Chrome.h>
80 #include <WebCore/ContextMenu.h>
81 #include <WebCore/ContextMenuController.h>
82 #include <WebCore/Cursor.h>
83 #include <WebCore/DatabaseManager.h>
84 #include <WebCore/Document.h>
85 #include <WebCore/DocumentMarkerController.h>
86 #include <WebCore/DragController.h>
87 #include <WebCore/DragData.h>
88 #include <WebCore/Editor.h>
89 #include <WebCore/EventHandler.h>
90 #include <WebCore/EventNames.h>
91 #include <WebCore/FileSystem.h>
92 #include <WebCore/FloatQuad.h>
93 #include <WebCore/FocusController.h>
94 #include <WebCore/FrameLoader.h>
95 #include <WebCore/FrameSelection.h>
96 #include <WebCore/FrameTree.h>
97 #include <WebCore/FrameView.h>
98 #include <WebCore/FrameWin.h>
99 #include <WebCore/GDIObjectCounter.h>
100 #include <WebCore/GeolocationController.h>
101 #include <WebCore/GeolocationError.h>
102 #include <WebCore/GraphicsContext.h>
103 #include <WebCore/HTMLMediaElement.h>
104 #include <WebCore/HTMLNames.h>
105 #include <WebCore/HWndDC.h>
106 #include <WebCore/HistoryController.h>
107 #include <WebCore/HistoryItem.h>
108 #include <WebCore/HitTestRequest.h>
109 #include <WebCore/HitTestResult.h>
110 #include <WebCore/IntRect.h>
111 #include <WebCore/JSElement.h>
112 #include <WebCore/KeyboardEvent.h>
113 #include <WebCore/Logging.h>
114 #include <WebCore/MIMETypeRegistry.h>
115 #include <WebCore/MainFrame.h>
116 #include <WebCore/MemoryCache.h>
117 #include <WebCore/NotImplemented.h>
118 #include <WebCore/Page.h>
119 #include <WebCore/PageCache.h>
120 #include <WebCore/PageGroup.h>
121 #include <WebCore/PlatformKeyboardEvent.h>
122 #include <WebCore/PlatformMouseEvent.h>
123 #include <WebCore/PlatformWheelEvent.h>
124 #include <WebCore/PluginData.h>
125 #include <WebCore/PluginDatabase.h>
126 #include <WebCore/PluginView.h>
127 #include <WebCore/PopupMenu.h>
128 #include <WebCore/PopupMenuWin.h>
129 #include <WebCore/ProgressTracker.h>
130 #include <WebCore/RenderLayer.h>
131 #include <WebCore/RenderTheme.h>
132 #include <WebCore/RenderTreeAsText.h>
133 #include <WebCore/RenderView.h>
134 #include <WebCore/RenderWidget.h>
135 #include <WebCore/ResourceHandle.h>
136 #include <WebCore/ResourceHandleClient.h>
137 #include <WebCore/ResourceRequest.h>
138 #include <WebCore/RuntimeEnabledFeatures.h>
139 #include <WebCore/SchemeRegistry.h>
140 #include <WebCore/ScriptController.h>
141 #include <WebCore/Scrollbar.h>
142 #include <WebCore/ScrollbarTheme.h>
143 #include <WebCore/SecurityOrigin.h>
144 #include <WebCore/SecurityPolicy.h>
145 #include <WebCore/Settings.h>
146 #include <WebCore/SimpleFontData.h>
147 #include <WebCore/SystemInfo.h>
148 #include <WebCore/WindowMessageBroadcaster.h>
149 #include <WebCore/WindowsTouch.h>
150 #include <bindings/ScriptValue.h>
151 #include <wtf/MainThread.h>
152
153 #if USE(CG)
154 #include <CoreGraphics/CGContext.h>
155 #endif
156
157 #if USE(CF)
158 #include <CoreFoundation/CoreFoundation.h>
159 #endif
160
161 #if USE(CFNETWORK)
162 #include <CFNetwork/CFURLCachePriv.h>
163 #include <CFNetwork/CFURLProtocolPriv.h>
164 #include <WebKitSystemInterface/WebKitSystemInterface.h> 
165 #endif
166
167 #if USE(CA)
168 #include <WebCore/CACFLayerTreeHost.h>
169 #include <WebCore/PlatformCALayer.h>
170 #endif
171
172 #if ENABLE(FULLSCREEN_API)
173 #include <WebCore/FullScreenController.h>
174 #endif
175
176 #include <ShlObj.h>
177 #include <comutil.h>
178 #include <dimm.h>
179 #include <oleacc.h>
180 #include <wchar.h>
181 #include <windowsx.h>
182 #include <wtf/HashSet.h>
183 #include <wtf/text/CString.h>
184 #include <wtf/text/StringConcatenate.h>
185 #include <wtf/win/GDIObject.h>
186
187 // Soft link functions for gestures and panning feedback
188 SOFT_LINK_LIBRARY(USER32);
189 SOFT_LINK_OPTIONAL(USER32, GetGestureInfo, BOOL, WINAPI, (HGESTUREINFO, PGESTUREINFO));
190 SOFT_LINK_OPTIONAL(USER32, SetGestureConfig, BOOL, WINAPI, (HWND, DWORD, UINT, PGESTURECONFIG, UINT));
191 SOFT_LINK_OPTIONAL(USER32, CloseGestureInfoHandle, BOOL, WINAPI, (HGESTUREINFO));
192 SOFT_LINK_LIBRARY(Uxtheme);
193 SOFT_LINK_OPTIONAL(Uxtheme, BeginPanningFeedback, BOOL, WINAPI, (HWND));
194 SOFT_LINK_OPTIONAL(Uxtheme, EndPanningFeedback, BOOL, WINAPI, (HWND, BOOL));
195 SOFT_LINK_OPTIONAL(Uxtheme, UpdatePanningFeedback, BOOL, WINAPI, (HWND, LONG, LONG, BOOL));
196
197 using namespace WebCore;
198 using namespace std;
199 using JSC::JSLock;
200
201 static HMODULE accessibilityLib;
202 static HashSet<WebView*> pendingDeleteBackingStoreSet;
203
204 static CFStringRef WebKitLocalCacheDefaultsKey = CFSTR("WebKitLocalCache");
205
206 static String webKitVersionString();
207
208 WebView* kit(Page* page)
209 {
210     if (!page)
211         return 0;
212     
213     if (page->chrome().client().isEmptyChromeClient())
214         return 0;
215     
216     return static_cast<WebChromeClient&>(page->chrome().client()).webView();
217 }
218
219 static inline AtomicString toAtomicString(BSTR bstr)
220 {
221     return AtomicString(bstr, SysStringLen(bstr));
222 }
223
224 static inline String toString(BSTR bstr)
225 {
226     return String(bstr, SysStringLen(bstr));
227 }
228
229 static inline String toString(BString &bstr)
230 {
231     return String(bstr, SysStringLen(bstr));
232 }
233
234 static inline URL toURL(BSTR bstr)
235 {
236     return URL(URL(), toString(bstr));
237 }
238
239 class PreferencesChangedOrRemovedObserver : public IWebNotificationObserver {
240 public:
241     static PreferencesChangedOrRemovedObserver* sharedInstance();
242
243 private:
244     PreferencesChangedOrRemovedObserver() {}
245     ~PreferencesChangedOrRemovedObserver() {}
246
247     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID, void**) { return E_FAIL; }
248     virtual ULONG STDMETHODCALLTYPE AddRef(void) { return 0; }
249     virtual ULONG STDMETHODCALLTYPE Release(void) { return 0; }
250
251 public:
252     // IWebNotificationObserver
253     virtual HRESULT STDMETHODCALLTYPE onNotify( 
254         /* [in] */ IWebNotification* notification);
255
256 private:
257     HRESULT notifyPreferencesChanged(WebCacheModel);
258     HRESULT notifyPreferencesRemoved(WebCacheModel);
259 };
260
261 PreferencesChangedOrRemovedObserver* PreferencesChangedOrRemovedObserver::sharedInstance()
262 {
263     static PreferencesChangedOrRemovedObserver* shared = new PreferencesChangedOrRemovedObserver;
264     return shared;
265 }
266
267 HRESULT PreferencesChangedOrRemovedObserver::onNotify(IWebNotification* notification)
268 {
269     HRESULT hr = S_OK;
270
271     COMPtr<IUnknown> unkPrefs;
272     hr = notification->getObject(&unkPrefs);
273     if (FAILED(hr))
274         return hr;
275
276     COMPtr<IWebPreferences> preferences(Query, unkPrefs);
277     if (!preferences)
278         return E_NOINTERFACE;
279
280     WebCacheModel cacheModel;
281     hr = preferences->cacheModel(&cacheModel);
282     if (FAILED(hr))
283         return hr;
284
285     BString name;
286     hr = notification->name(&name);
287     if (FAILED(hr))
288         return hr;
289
290     if (wcscmp(name, WebPreferences::webPreferencesChangedNotification()) == 0)
291         return notifyPreferencesChanged(cacheModel);
292
293     if (wcscmp(name, WebPreferences::webPreferencesRemovedNotification()) == 0)
294         return notifyPreferencesRemoved(cacheModel);
295
296     ASSERT_NOT_REACHED();
297     return E_FAIL;
298 }
299
300 HRESULT PreferencesChangedOrRemovedObserver::notifyPreferencesChanged(WebCacheModel cacheModel)
301 {
302     HRESULT hr = S_OK;
303
304     if (!WebView::didSetCacheModel() || cacheModel > WebView::cacheModel())
305         WebView::setCacheModel(cacheModel);
306     else if (cacheModel < WebView::cacheModel()) {
307         WebCacheModel sharedPreferencesCacheModel;
308         hr = WebPreferences::sharedStandardPreferences()->cacheModel(&sharedPreferencesCacheModel);
309         if (FAILED(hr))
310             return hr;
311         WebView::setCacheModel(max(sharedPreferencesCacheModel, WebView::maxCacheModelInAnyInstance()));
312     }
313
314     return hr;
315 }
316
317 HRESULT PreferencesChangedOrRemovedObserver::notifyPreferencesRemoved(WebCacheModel cacheModel)
318 {
319     HRESULT hr = S_OK;
320
321     if (cacheModel == WebView::cacheModel()) {
322         WebCacheModel sharedPreferencesCacheModel;
323         hr = WebPreferences::sharedStandardPreferences()->cacheModel(&sharedPreferencesCacheModel);
324         if (FAILED(hr))
325             return hr;
326         WebView::setCacheModel(max(sharedPreferencesCacheModel, WebView::maxCacheModelInAnyInstance()));
327     }
328
329     return hr;
330 }
331
332
333 const LPCWSTR kWebViewWindowClassName = L"WebViewWindowClass";
334
335 const int WM_XP_THEMECHANGED = 0x031A;
336 const int WM_VISTA_MOUSEHWHEEL = 0x020E;
337
338 static const int maxToolTipWidth = 250;
339
340 static const int delayBeforeDeletingBackingStoreMsec = 5000;
341
342 static ATOM registerWebView();
343
344 static void initializeStaticObservers();
345
346 static HRESULT updateSharedSettingsFromPreferencesIfNeeded(IWebPreferences*);
347
348 HRESULT createMatchEnumerator(Vector<IntRect>* rects, IEnumTextMatches** matches);
349
350 static bool continuousSpellCheckingEnabled;
351 static bool grammarCheckingEnabled;
352
353 static bool s_didSetCacheModel;
354 static WebCacheModel s_cacheModel = WebCacheModelDocumentViewer;
355
356 enum {
357     UpdateActiveStateTimer = 1,
358     DeleteBackingStoreTimer = 2,
359 };
360
361 // WebView ----------------------------------------------------------------
362
363 bool WebView::s_allowSiteSpecificHacks = false;
364
365 WebView::WebView()
366     : m_refCount(0)
367     , m_shouldInvertColors(false)
368 #if !ASSERT_DISABLED
369     , m_deletionHasBegun(false)
370 #endif
371     , m_hostWindow(0)
372     , m_viewWindow(0)
373     , m_mainFrame(0)
374     , m_page(0)
375 #if ENABLE(INSPECTOR)
376     , m_inspectorClient(0)
377 #endif // ENABLE(INSPECTOR)
378     , m_hasCustomDropTarget(false)
379     , m_useBackForwardList(true)
380     , m_userAgentOverridden(false)
381     , m_zoomMultiplier(1.0f)
382     , m_zoomsTextOnly(false)
383     , m_mouseActivated(false)
384     , m_dragData(0)
385     , m_currentCharacterCode(0)
386     , m_isBeingDestroyed(false)
387     , m_paintCount(0)
388     , m_hasSpellCheckerDocumentTag(false)
389     , m_didClose(false)
390     , m_inIMEComposition(0)
391     , m_toolTipHwnd(0)
392     , m_closeWindowTimer(0)
393     , m_topLevelParent(0)
394     , m_deleteBackingStoreTimerActive(false)
395     , m_transparent(false)
396     , m_lastPanX(0)
397     , m_lastPanY(0)
398     , m_xOverpan(0)
399     , m_yOverpan(0)
400     , m_isAcceleratedCompositing(false)
401     , m_nextDisplayIsSynchronous(false)
402     , m_lastSetCursor(0)
403     , m_usesLayeredWindow(false)
404     , m_needsDisplay(false)
405 {
406     JSC::initializeThreading();
407     WTF::initializeMainThread();
408
409     m_backingStoreSize.cx = m_backingStoreSize.cy = 0;
410
411     CoCreateInstance(CLSID_DragDropHelper, 0, CLSCTX_INPROC_SERVER, IID_IDropTargetHelper,(void**)&m_dropTargetHelper);
412
413     initializeStaticObservers();
414
415     WebPreferences* sharedPreferences = WebPreferences::sharedStandardPreferences();
416     BOOL enabled;
417     if (SUCCEEDED(sharedPreferences->continuousSpellCheckingEnabled(&enabled)))
418         continuousSpellCheckingEnabled = !!enabled;
419     if (SUCCEEDED(sharedPreferences->grammarCheckingEnabled(&enabled)))
420         grammarCheckingEnabled = !!enabled;
421
422     WebViewCount++;
423     gClassCount++;
424     gClassNameCount.add("WebView");
425 }
426
427 WebView::~WebView()
428 {
429     deleteBackingStore();
430
431     // the tooltip window needs to be explicitly destroyed since it isn't a WS_CHILD
432     if (::IsWindow(m_toolTipHwnd))
433         ::DestroyWindow(m_toolTipHwnd);
434
435     ASSERT(!m_page);
436     ASSERT(!m_preferences);
437     ASSERT(!m_viewWindow);
438
439 #if USE(CA)
440     ASSERT(!m_layerTreeHost);
441 #endif
442
443     WebViewCount--;
444     gClassCount--;
445     gClassNameCount.remove("WebView");
446 }
447
448 WebView* WebView::createInstance()
449 {
450     WebView* instance = new WebView();
451     instance->AddRef();
452     return instance;
453 }
454
455 void initializeStaticObservers()
456 {
457     static bool initialized;
458     if (initialized)
459         return;
460     initialized = true;
461
462     IWebNotificationCenter* notifyCenter = WebNotificationCenter::defaultCenterInternal();
463     notifyCenter->addObserver(PreferencesChangedOrRemovedObserver::sharedInstance(), WebPreferences::webPreferencesChangedNotification(), 0);
464     notifyCenter->addObserver(PreferencesChangedOrRemovedObserver::sharedInstance(), WebPreferences::webPreferencesRemovedNotification(), 0);
465 }
466
467 static HashSet<WebView*>& allWebViewsSet()
468 {
469     static HashSet<WebView*> allWebViewsSet;
470     return allWebViewsSet;
471 }
472
473 void WebView::addToAllWebViewsSet()
474 {
475     allWebViewsSet().add(this);
476 }
477
478 void WebView::removeFromAllWebViewsSet()
479 {
480     allWebViewsSet().remove(this);
481 }
482
483 void WebView::setCacheModel(WebCacheModel cacheModel)
484 {
485 #if USE(CFNETWORK)
486     if (s_didSetCacheModel && cacheModel == s_cacheModel)
487         return;
488
489     RetainPtr<CFURLCacheRef> cfurlCache = adoptCF(CFURLCacheCopySharedURLCache());
490     RetainPtr<CFStringRef> cfurlCacheDirectory = adoptCF(wkCopyFoundationCacheDirectory(0));
491     if (!cfurlCacheDirectory) {
492         RetainPtr<CFPropertyListRef> preference = adoptCF(CFPreferencesCopyAppValue(WebKitLocalCacheDefaultsKey, kCFPreferencesCurrentApplication));
493         if (preference && (CFStringGetTypeID() == CFGetTypeID(preference.get())))
494             cfurlCacheDirectory = adoptCF(static_cast<CFStringRef>(preference.leakRef()));
495         else
496             cfurlCacheDirectory = WebCore::localUserSpecificStorageDirectory().createCFString();
497     }
498
499     // As a fudge factor, use 1000 instead of 1024, in case the reported byte 
500     // count doesn't align exactly to a megabyte boundary.
501     unsigned long long memSize = WebMemorySize() / 1024 / 1000;
502     unsigned long long diskFreeSize = WebVolumeFreeSize(cfurlCacheDirectory.get()) / 1024 / 1000;
503
504     unsigned cacheTotalCapacity = 0;
505     unsigned cacheMinDeadCapacity = 0;
506     unsigned cacheMaxDeadCapacity = 0;
507     double deadDecodedDataDeletionInterval = 0;
508
509     unsigned pageCacheCapacity = 0;
510
511     CFIndex cfurlCacheMemoryCapacity = 0;
512     CFIndex cfurlCacheDiskCapacity = 0;
513
514     switch (cacheModel) {
515     case WebCacheModelDocumentViewer: {
516         // Page cache capacity (in pages)
517         pageCacheCapacity = 0;
518
519         // Object cache capacities (in bytes)
520         if (memSize >= 2048)
521             cacheTotalCapacity = 96 * 1024 * 1024;
522         else if (memSize >= 1536)
523             cacheTotalCapacity = 64 * 1024 * 1024;
524         else if (memSize >= 1024)
525             cacheTotalCapacity = 32 * 1024 * 1024;
526         else if (memSize >= 512)
527             cacheTotalCapacity = 16 * 1024 * 1024; 
528
529         cacheMinDeadCapacity = 0;
530         cacheMaxDeadCapacity = 0;
531
532         // Foundation memory cache capacity (in bytes)
533         cfurlCacheMemoryCapacity = 0;
534
535         // Foundation disk cache capacity (in bytes)
536         cfurlCacheDiskCapacity = CFURLCacheDiskCapacity(cfurlCache.get());
537
538         break;
539     }
540     case WebCacheModelDocumentBrowser: {
541         // Page cache capacity (in pages)
542         if (memSize >= 1024)
543             pageCacheCapacity = 3;
544         else if (memSize >= 512)
545             pageCacheCapacity = 2;
546         else if (memSize >= 256)
547             pageCacheCapacity = 1;
548         else
549             pageCacheCapacity = 0;
550
551         // Object cache capacities (in bytes)
552         if (memSize >= 2048)
553             cacheTotalCapacity = 96 * 1024 * 1024;
554         else if (memSize >= 1536)
555             cacheTotalCapacity = 64 * 1024 * 1024;
556         else if (memSize >= 1024)
557             cacheTotalCapacity = 32 * 1024 * 1024;
558         else if (memSize >= 512)
559             cacheTotalCapacity = 16 * 1024 * 1024; 
560
561         cacheMinDeadCapacity = cacheTotalCapacity / 8;
562         cacheMaxDeadCapacity = cacheTotalCapacity / 4;
563
564         // Foundation memory cache capacity (in bytes)
565         if (memSize >= 2048)
566             cfurlCacheMemoryCapacity = 4 * 1024 * 1024;
567         else if (memSize >= 1024)
568             cfurlCacheMemoryCapacity = 2 * 1024 * 1024;
569         else if (memSize >= 512)
570             cfurlCacheMemoryCapacity = 1 * 1024 * 1024;
571         else
572             cfurlCacheMemoryCapacity =      512 * 1024; 
573
574         // Foundation disk cache capacity (in bytes)
575         if (diskFreeSize >= 16384)
576             cfurlCacheDiskCapacity = 50 * 1024 * 1024;
577         else if (diskFreeSize >= 8192)
578             cfurlCacheDiskCapacity = 40 * 1024 * 1024;
579         else if (diskFreeSize >= 4096)
580             cfurlCacheDiskCapacity = 30 * 1024 * 1024;
581         else
582             cfurlCacheDiskCapacity = 20 * 1024 * 1024;
583
584         break;
585     }
586     case WebCacheModelPrimaryWebBrowser: {
587         // Page cache capacity (in pages)
588         // (Research indicates that value / page drops substantially after 3 pages.)
589         if (memSize >= 2048)
590             pageCacheCapacity = 5;
591         else if (memSize >= 1024)
592             pageCacheCapacity = 4;
593         else if (memSize >= 512)
594             pageCacheCapacity = 3;
595         else if (memSize >= 256)
596             pageCacheCapacity = 2;
597         else
598             pageCacheCapacity = 1;
599
600         // Object cache capacities (in bytes)
601         // (Testing indicates that value / MB depends heavily on content and
602         // browsing pattern. Even growth above 128MB can have substantial 
603         // value / MB for some content / browsing patterns.)
604         if (memSize >= 2048)
605             cacheTotalCapacity = 128 * 1024 * 1024;
606         else if (memSize >= 1536)
607             cacheTotalCapacity = 96 * 1024 * 1024;
608         else if (memSize >= 1024)
609             cacheTotalCapacity = 64 * 1024 * 1024;
610         else if (memSize >= 512)
611             cacheTotalCapacity = 32 * 1024 * 1024; 
612
613         cacheMinDeadCapacity = cacheTotalCapacity / 4;
614         cacheMaxDeadCapacity = cacheTotalCapacity / 2;
615
616         // This code is here to avoid a PLT regression. We can remove it if we
617         // can prove that the overall system gain would justify the regression.
618         cacheMaxDeadCapacity = max(24u, cacheMaxDeadCapacity);
619
620         deadDecodedDataDeletionInterval = 60;
621
622         // Foundation memory cache capacity (in bytes)
623         // (These values are small because WebCore does most caching itself.)
624         if (memSize >= 1024)
625             cfurlCacheMemoryCapacity = 4 * 1024 * 1024;
626         else if (memSize >= 512)
627             cfurlCacheMemoryCapacity = 2 * 1024 * 1024;
628         else if (memSize >= 256)
629             cfurlCacheMemoryCapacity = 1 * 1024 * 1024;
630         else
631             cfurlCacheMemoryCapacity =      512 * 1024; 
632
633         // Foundation disk cache capacity (in bytes)
634         if (diskFreeSize >= 16384)
635             cfurlCacheDiskCapacity = 175 * 1024 * 1024;
636         else if (diskFreeSize >= 8192)
637             cfurlCacheDiskCapacity = 150 * 1024 * 1024;
638         else if (diskFreeSize >= 4096)
639             cfurlCacheDiskCapacity = 125 * 1024 * 1024;
640         else if (diskFreeSize >= 2048)
641             cfurlCacheDiskCapacity = 100 * 1024 * 1024;
642         else if (diskFreeSize >= 1024)
643             cfurlCacheDiskCapacity = 75 * 1024 * 1024;
644         else
645             cfurlCacheDiskCapacity = 50 * 1024 * 1024;
646
647         break;
648     }
649     default:
650         ASSERT_NOT_REACHED();
651     }
652
653     // Don't shrink a big disk cache, since that would cause churn.
654     cfurlCacheDiskCapacity = max(cfurlCacheDiskCapacity, CFURLCacheDiskCapacity(cfurlCache.get()));
655
656     memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
657     memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
658     pageCache()->setCapacity(pageCacheCapacity);
659
660     CFURLCacheSetMemoryCapacity(cfurlCache.get(), cfurlCacheMemoryCapacity);
661     CFURLCacheSetDiskCapacity(cfurlCache.get(), cfurlCacheDiskCapacity);
662
663     s_didSetCacheModel = true;
664     s_cacheModel = cacheModel;
665     return;
666 #endif
667 }
668
669 WebCacheModel WebView::cacheModel()
670 {
671     return s_cacheModel;
672 }
673
674 bool WebView::didSetCacheModel()
675 {
676     return s_didSetCacheModel;
677 }
678
679 WebCacheModel WebView::maxCacheModelInAnyInstance()
680 {
681     WebCacheModel cacheModel = WebCacheModelDocumentViewer;
682
683     HashSet<WebView*>::iterator end = allWebViewsSet().end();
684     for (HashSet<WebView*>::iterator it = allWebViewsSet().begin(); it != end; ++it) {
685         COMPtr<IWebPreferences> pref;
686         if (FAILED((*it)->preferences(&pref)))
687             continue;
688         WebCacheModel prefCacheModel = WebCacheModelDocumentViewer;
689         if (FAILED(pref->cacheModel(&prefCacheModel)))
690             continue;
691
692         cacheModel = max(cacheModel, prefCacheModel);
693     }
694
695     return cacheModel;
696 }
697
698 HRESULT STDMETHODCALLTYPE WebView::close()
699 {
700     if (m_didClose)
701         return S_OK;
702
703     m_didClose = true;
704
705     setAcceleratedCompositing(false);
706
707     WebNotificationCenter::defaultCenterInternal()->postNotificationName(_bstr_t(WebViewWillCloseNotification).GetBSTR(), static_cast<IWebView*>(this), 0);
708
709     if (m_uiDelegatePrivate)
710         m_uiDelegatePrivate->webViewClosing(this);
711
712     removeFromAllWebViewsSet();
713
714     if (m_page)
715         m_page->mainFrame().loader().detachFromParent();
716
717     if (m_mouseOutTracker) {
718         m_mouseOutTracker->dwFlags = TME_CANCEL;
719         ::TrackMouseEvent(m_mouseOutTracker.get());
720         m_mouseOutTracker.clear();
721     }
722     
723     revokeDragDrop();
724
725     if (m_viewWindow) {
726         // We can't check IsWindow(m_viewWindow) here, because that will return true even while
727         // we're already handling WM_DESTROY. So we check !isBeingDestroyed() instead.
728         if (!isBeingDestroyed())
729             DestroyWindow(m_viewWindow);
730         // Either we just destroyed m_viewWindow, or it's in the process of being destroyed. Either
731         // way, we clear it out to make sure we don't try to use it later.
732         m_viewWindow = 0;
733     }
734
735     setHostWindow(0);
736
737     setAccessibilityDelegate(0);
738     setDownloadDelegate(0);
739     setEditingDelegate(0);
740     setFrameLoadDelegate(0);
741     setFrameLoadDelegatePrivate(0);
742     setHistoryDelegate(0);
743     setPolicyDelegate(0);
744     setResourceLoadDelegate(0);
745     setUIDelegate(0);
746     setFormDelegate(0);
747
748 #if ENABLE(INSPECTOR)
749     m_inspectorClient = 0;
750     if (m_webInspector)
751         m_webInspector->webViewClosed();
752 #endif // ENABLE(INSPECTOR)
753
754     delete m_page;
755     m_page = 0;
756
757     registerForIconNotification(false);
758     IWebNotificationCenter* notifyCenter = WebNotificationCenter::defaultCenterInternal();
759     notifyCenter->removeObserver(this, WebPreferences::webPreferencesChangedNotification(), static_cast<IWebPreferences*>(m_preferences.get()));
760
761     if (COMPtr<WebPreferences> preferences = m_preferences) {
762         BString identifier;
763         preferences->identifier(&identifier);
764
765         m_preferences = 0;
766         preferences->didRemoveFromWebView();
767         // Make sure we release the reference, since WebPreferences::removeReferenceForIdentifier will check for last reference to WebPreferences
768         preferences = 0;
769         if (identifier)
770             WebPreferences::removeReferenceForIdentifier(identifier);
771     }
772
773     deleteBackingStore();
774     return S_OK;
775 }
776
777 void WebView::repaint(const WebCore::IntRect& windowRect, bool contentChanged, bool immediate, bool repaintContentOnly)
778 {
779     if (isAcceleratedCompositing()) {
780         // The contentChanged, immediate, and repaintContentOnly parameters are all based on a non-
781         // compositing painting/scrolling model.
782         addToDirtyRegion(windowRect);
783         return;
784     }
785
786     if (!repaintContentOnly) {
787         RECT rect = windowRect;
788         ::InvalidateRect(m_viewWindow, &rect, false);
789     }
790     if (contentChanged)
791         addToDirtyRegion(windowRect);
792     if (immediate) {
793         if (repaintContentOnly)
794             updateBackingStore(core(topLevelFrame())->view());
795         else
796             ::UpdateWindow(m_viewWindow);
797     }
798     m_needsDisplay = true;
799 }
800
801 void WebView::deleteBackingStore()
802 {
803     pendingDeleteBackingStoreSet.remove(this);
804
805     if (m_deleteBackingStoreTimerActive) {
806         KillTimer(m_viewWindow, DeleteBackingStoreTimer);
807         m_deleteBackingStoreTimerActive = false;
808     }
809     m_backingStoreBitmap.clear();
810     m_backingStoreDirtyRegion.clear();
811     m_backingStoreSize.cx = m_backingStoreSize.cy = 0;
812 }
813
814 bool WebView::ensureBackingStore()
815 {
816     RECT windowRect;
817     ::GetClientRect(m_viewWindow, &windowRect);
818     LONG width = windowRect.right - windowRect.left;
819     LONG height = windowRect.bottom - windowRect.top;
820     if (width > 0 && height > 0 && (width != m_backingStoreSize.cx || height != m_backingStoreSize.cy)) {
821         deleteBackingStore();
822
823         m_backingStoreSize.cx = width;
824         m_backingStoreSize.cy = height;
825         BitmapInfo bitmapInfo = BitmapInfo::createBottomUp(IntSize(m_backingStoreSize));
826
827         void* pixels = NULL;
828         m_backingStoreBitmap = SharedGDIObject<HBITMAP>::create(adoptGDIObject(::CreateDIBSection(0, &bitmapInfo, DIB_RGB_COLORS, &pixels, 0, 0)));
829         return true;
830     }
831
832     return false;
833 }
834
835 void WebView::addToDirtyRegion(const IntRect& dirtyRect)
836 {
837     m_needsDisplay = true;
838
839     // FIXME: We want an assert here saying that the dirtyRect is inside the clienRect,
840     // but it was being hit during our layout tests, and is being investigated in
841     // http://webkit.org/b/29350.
842
843     if (isAcceleratedCompositing()) {
844         m_backingLayer->setNeedsDisplayInRect(dirtyRect);
845         return;
846     }
847
848     auto newRegion = adoptGDIObject(::CreateRectRgn(dirtyRect.x(), dirtyRect.y(),
849         dirtyRect.maxX(), dirtyRect.maxY()));
850     addToDirtyRegion(std::move(newRegion));
851 }
852
853 void WebView::addToDirtyRegion(GDIObject<HRGN> newRegion)
854 {
855     m_needsDisplay = true;
856
857     ASSERT(!isAcceleratedCompositing());
858
859     LOCAL_GDI_COUNTER(0, __FUNCTION__);
860
861     if (m_backingStoreDirtyRegion) {
862         auto combinedRegion = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
863         ::CombineRgn(combinedRegion.get(), m_backingStoreDirtyRegion->get(), newRegion.get(), RGN_OR);
864         m_backingStoreDirtyRegion = SharedGDIObject<HRGN>::create(std::move(combinedRegion));
865     } else
866         m_backingStoreDirtyRegion = SharedGDIObject<HRGN>::create(std::move(newRegion));
867
868     if (m_uiDelegatePrivate)
869         m_uiDelegatePrivate->webViewDidInvalidate(this);
870 }
871
872 void WebView::scrollBackingStore(FrameView* frameView, int dx, int dy, const IntRect& scrollViewRect, const IntRect& clipRect)
873 {
874     m_needsDisplay = true;
875
876     if (isAcceleratedCompositing()) {
877         // FIXME: We should be doing something smarter here, like moving tiles around and painting
878         // any newly-exposed tiles. <http://webkit.org/b/52714>
879         m_backingLayer->setNeedsDisplayInRect(scrollViewRect);
880         return;
881     }
882
883     LOCAL_GDI_COUNTER(0, __FUNCTION__);
884
885     // If there's no backing store we don't need to update it
886     if (!m_backingStoreBitmap) {
887         if (m_uiDelegatePrivate)
888             m_uiDelegatePrivate->webViewScrolled(this);
889
890         return;
891     }
892
893     // Make a region to hold the invalidated scroll area.
894     auto updateRegion = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
895
896     // Collect our device context info and select the bitmap to scroll.
897     HWndDC windowDC(m_viewWindow);
898     auto bitmapDC = adoptGDIObject(::CreateCompatibleDC(windowDC));
899     HGDIOBJ oldBitmap = ::SelectObject(bitmapDC.get(), m_backingStoreBitmap->get());
900     
901     // Scroll the bitmap.
902     RECT scrollRectWin(scrollViewRect);
903     RECT clipRectWin(clipRect);
904     ::ScrollDC(bitmapDC.get(), dx, dy, &scrollRectWin, &clipRectWin, updateRegion.get(), 0);
905     RECT regionBox;
906     ::GetRgnBox(updateRegion.get(), &regionBox);
907
908     // Flush.
909     GdiFlush();
910
911     // Add the dirty region to the backing store's dirty region.
912     addToDirtyRegion(std::move(updateRegion));
913
914     if (m_uiDelegatePrivate)
915         m_uiDelegatePrivate->webViewScrolled(this);
916
917     // Update the backing store.
918     updateBackingStore(frameView, bitmapDC.get(), false);
919
920     // Clean up.
921     ::SelectObject(bitmapDC.get(), oldBitmap);
922 }
923
924 void WebView::sizeChanged(const IntSize& newSize)
925 {
926     m_needsDisplay = true;
927
928     deleteBackingStore();
929
930     if (Frame* coreFrame = core(topLevelFrame()))
931         coreFrame->view()->resize(newSize);
932
933 #if USE(CA)
934     if (m_layerTreeHost)
935         m_layerTreeHost->resize();
936     if (m_backingLayer) {
937         m_backingLayer->setSize(newSize);
938         m_backingLayer->setNeedsDisplay();
939     }
940 #endif
941 }
942
943 // This emulates the Mac smarts for painting rects intelligently.  This is very
944 // important for us, since we double buffer based off dirty rects.
945 static void getUpdateRects(HRGN region, const IntRect& dirtyRect, Vector<IntRect>& rects)
946 {
947     ASSERT_ARG(region, region);
948
949     const int cRectThreshold = 10;
950     const float cWastedSpaceThreshold = 0.75f;
951
952     rects.clear();
953
954     DWORD regionDataSize = GetRegionData(region, sizeof(RGNDATA), NULL);
955     if (!regionDataSize) {
956         rects.append(dirtyRect);
957         return;
958     }
959
960     Vector<unsigned char> buffer(regionDataSize);
961     RGNDATA* regionData = reinterpret_cast<RGNDATA*>(buffer.data());
962     GetRegionData(region, regionDataSize, regionData);
963     if (regionData->rdh.nCount > cRectThreshold) {
964         rects.append(dirtyRect);
965         return;
966     }
967
968     double singlePixels = 0.0;
969     unsigned i;
970     RECT* rect;
971     for (i = 0, rect = reinterpret_cast<RECT*>(regionData->Buffer); i < regionData->rdh.nCount; i++, rect++)
972         singlePixels += (rect->right - rect->left) * (rect->bottom - rect->top);
973
974     double unionPixels = dirtyRect.width() * dirtyRect.height();
975     double wastedSpace = 1.0 - (singlePixels / unionPixels);
976     if (wastedSpace <= cWastedSpaceThreshold) {
977         rects.append(dirtyRect);
978         return;
979     }
980
981     for (i = 0, rect = reinterpret_cast<RECT*>(regionData->Buffer); i < regionData->rdh.nCount; i++, rect++)
982         rects.append(*rect);
983 }
984
985 void WebView::updateBackingStore(FrameView* frameView, HDC dc, bool backingStoreCompletelyDirty, WindowsToPaint windowsToPaint)
986 {
987     ASSERT(!isAcceleratedCompositing());
988
989     LOCAL_GDI_COUNTER(0, __FUNCTION__);
990
991     GDIObject<HDC> bitmapDCObject;
992
993     HDC bitmapDC = dc;
994     HGDIOBJ oldBitmap = 0;
995     if (!dc) {
996         HWndDC windowDC(m_viewWindow);
997         bitmapDCObject = adoptGDIObject(::CreateCompatibleDC(windowDC));
998         bitmapDC = bitmapDCObject.get();
999         oldBitmap = ::SelectObject(bitmapDC, m_backingStoreBitmap->get());
1000     }
1001
1002     if (m_backingStoreBitmap && (m_backingStoreDirtyRegion || backingStoreCompletelyDirty)) {
1003         // Do a layout first so that everything we render to the backing store is always current.
1004         if (Frame* coreFrame = core(m_mainFrame))
1005             if (FrameView* view = coreFrame->view())
1006                 view->updateLayoutAndStyleIfNeededRecursive();
1007
1008         Vector<IntRect> paintRects;
1009         if (!backingStoreCompletelyDirty && m_backingStoreDirtyRegion) {
1010             RECT regionBox;
1011             ::GetRgnBox(m_backingStoreDirtyRegion->get(), &regionBox);
1012             getUpdateRects(m_backingStoreDirtyRegion->get(), regionBox, paintRects);
1013         } else {
1014             RECT clientRect;
1015             ::GetClientRect(m_viewWindow, &clientRect);
1016             paintRects.append(clientRect);
1017         }
1018
1019         for (unsigned i = 0; i < paintRects.size(); ++i)
1020             paintIntoBackingStore(frameView, bitmapDC, paintRects[i], windowsToPaint);
1021
1022         if (m_uiDelegatePrivate)
1023             m_uiDelegatePrivate->webViewPainted(this);
1024
1025         m_backingStoreDirtyRegion.clear();
1026     }
1027
1028     if (!dc)
1029         ::SelectObject(bitmapDC, oldBitmap);
1030
1031     GdiFlush();
1032
1033     m_needsDisplay = true;
1034 }
1035
1036 void WebView::performLayeredWindowUpdate()
1037 {
1038     // The backing store may have been destroyed if the window rect was set to zero height or zero width.
1039     if (!m_backingStoreBitmap)
1040         return;
1041
1042     HWndDC hdcScreen(m_viewWindow);
1043     auto hdcMem = adoptGDIObject(::CreateCompatibleDC(hdcScreen));
1044     HBITMAP hbmOld = static_cast<HBITMAP>(::SelectObject(hdcMem.get(), m_backingStoreBitmap->get()));
1045
1046     BITMAP bmpInfo;
1047     ::GetObject(m_backingStoreBitmap->get(), sizeof(bmpInfo), &bmpInfo);
1048     SIZE windowSize = { bmpInfo.bmWidth, bmpInfo.bmHeight };
1049
1050     BLENDFUNCTION blendFunction;
1051     blendFunction.BlendOp = AC_SRC_OVER;
1052     blendFunction.BlendFlags = 0;
1053     blendFunction.SourceConstantAlpha = 0xFF;
1054     blendFunction.AlphaFormat = AC_SRC_ALPHA;
1055
1056     POINT layerPos = { 0, 0 };
1057     ::UpdateLayeredWindow(m_viewWindow, hdcScreen, 0, &windowSize, hdcMem.get(), &layerPos, 0, &blendFunction, ULW_ALPHA);
1058
1059     ::SelectObject(hdcMem.get(), hbmOld);
1060
1061     m_needsDisplay = false;
1062 }
1063
1064 void WebView::paint(HDC dc, LPARAM options)
1065 {
1066     LOCAL_GDI_COUNTER(0, __FUNCTION__);
1067
1068 #if USE(CA)
1069     if (isAcceleratedCompositing() && !usesLayeredWindow()) {
1070         m_layerTreeHost->flushPendingLayerChangesNow();
1071         // Flushing might have taken us out of compositing mode.
1072         if (isAcceleratedCompositing()) {
1073             // FIXME: We need to paint into dc (if provided). <http://webkit.org/b/52578>
1074             m_layerTreeHost->paint();
1075             ::ValidateRect(m_viewWindow, 0);
1076             return;
1077         }
1078     }
1079 #endif
1080
1081     Frame* coreFrame = core(m_mainFrame);
1082     if (!coreFrame)
1083         return;
1084     FrameView* frameView = coreFrame->view();
1085
1086     RECT rcPaint;
1087     HDC hdc;
1088     GDIObject<HRGN> region;
1089     int regionType = NULLREGION;
1090     PAINTSTRUCT ps;
1091     WindowsToPaint windowsToPaint;
1092     if (!dc) {
1093         region = adoptGDIObject(::CreateRectRgn(0, 0, 0, 0));
1094         regionType = GetUpdateRgn(m_viewWindow, region.get(), false);
1095         hdc = BeginPaint(m_viewWindow, &ps);
1096         rcPaint = ps.rcPaint;
1097         // We're painting to the screen, and our child windows can handle
1098         // painting themselves to the screen.
1099         windowsToPaint = PaintWebViewOnly;
1100     } else {
1101         hdc = dc;
1102         ::GetClientRect(m_viewWindow, &rcPaint);
1103         if (options & PRF_ERASEBKGND)
1104             ::FillRect(hdc, &rcPaint, (HBRUSH)GetStockObject(WHITE_BRUSH));
1105         // Since we aren't painting to the screen, we want to paint all our
1106         // children into the HDC.
1107         windowsToPaint = PaintWebViewAndChildren;
1108     }
1109
1110     bool backingStoreCompletelyDirty = ensureBackingStore();
1111     if (!m_backingStoreBitmap) {
1112         if (!dc)
1113             EndPaint(m_viewWindow, &ps);
1114         return;
1115     }
1116
1117     m_paintCount++;
1118
1119     auto bitmapDC = adoptGDIObject(::CreateCompatibleDC(hdc));
1120     HGDIOBJ oldBitmap = ::SelectObject(bitmapDC.get(), m_backingStoreBitmap->get());
1121
1122     // Update our backing store if needed.
1123     updateBackingStore(frameView, bitmapDC.get(), backingStoreCompletelyDirty, windowsToPaint);
1124
1125     // Now we blit the updated backing store
1126     IntRect windowDirtyRect = rcPaint;
1127     
1128     // Apply the same heuristic for this update region too.
1129     Vector<IntRect> blitRects;
1130     if (region && regionType == COMPLEXREGION)
1131         getUpdateRects(region.get(), windowDirtyRect, blitRects);
1132     else
1133         blitRects.append(windowDirtyRect);
1134
1135     for (unsigned i = 0; i < blitRects.size(); ++i)
1136         paintIntoWindow(bitmapDC.get(), hdc, blitRects[i]);
1137
1138     ::SelectObject(bitmapDC.get(), oldBitmap);
1139
1140     if (!dc)
1141         EndPaint(m_viewWindow, &ps);
1142
1143     m_paintCount--;
1144
1145     if (active())
1146         cancelDeleteBackingStoreSoon();
1147     else
1148         deleteBackingStoreSoon();
1149 }
1150
1151 void WebView::paintIntoBackingStore(FrameView* frameView, HDC bitmapDC, const IntRect& dirtyRect, WindowsToPaint windowsToPaint)
1152 {
1153     // FIXME: This function should never be called in accelerated compositing mode, and we should
1154     // assert as such. But currently it *is* sometimes called, so we can't assert yet. See
1155     // <http://webkit.org/b/58539>.
1156
1157     LOCAL_GDI_COUNTER(0, __FUNCTION__);
1158
1159     // FIXME: We want an assert here saying that the dirtyRect is inside the clienRect,
1160     // but it was being hit during our layout tests, and is being investigated in
1161     // http://webkit.org/b/29350.
1162
1163     RECT rect = dirtyRect;
1164
1165 #if FLASH_BACKING_STORE_REDRAW
1166     {
1167         HWndDC dc(m_viewWindow);
1168         auto yellowBrush = adoptGDIObject(::CreateSolidBrush(RGB(255, 255, 0)));
1169         FillRect(dc, &rect, yellowBrush.get());
1170         GdiFlush();
1171         Sleep(50);
1172         paintIntoWindow(bitmapDC, dc, dirtyRect);
1173     }
1174 #endif
1175
1176     GraphicsContext gc(bitmapDC, m_transparent);
1177     gc.setShouldIncludeChildWindows(windowsToPaint == PaintWebViewAndChildren);
1178     gc.save();
1179     if (m_transparent)
1180         gc.clearRect(dirtyRect);
1181     else
1182         FillRect(bitmapDC, &rect, (HBRUSH)GetStockObject(WHITE_BRUSH));
1183
1184     COMPtr<IWebUIDelegatePrivate2> uiPrivate(Query, m_uiDelegate);
1185     if (uiPrivate)
1186         uiPrivate->drawBackground(this, reinterpret_cast<OLE_HANDLE>(bitmapDC), &rect);
1187
1188     if (frameView && frameView->frame().contentRenderer()) {
1189         gc.clip(dirtyRect);
1190         frameView->paint(&gc, dirtyRect);
1191         if (m_shouldInvertColors)
1192             gc.fillRect(dirtyRect, Color::white, ColorSpaceDeviceRGB, CompositeDifference);
1193     }
1194     gc.restore();
1195 }
1196
1197 void WebView::paintIntoWindow(HDC bitmapDC, HDC windowDC, const IntRect& dirtyRect)
1198 {
1199     // FIXME: This function should never be called in accelerated compositing mode, and we should
1200     // assert as such. But currently it *is* sometimes called, so we can't assert yet. See
1201     // <http://webkit.org/b/58539>.
1202
1203     LOCAL_GDI_COUNTER(0, __FUNCTION__);
1204 #if FLASH_WINDOW_REDRAW
1205     auto greenBrush = adoptGDIObject(::CreateSolidBrush(RGB(0, 255, 0)));
1206     RECT rect = dirtyRect;
1207     FillRect(windowDC, &rect, greenBrush.get());
1208     GdiFlush();
1209     Sleep(50);
1210 #endif
1211
1212     // Blit the dirty rect from the backing store into the same position
1213     // in the destination DC.
1214     BitBlt(windowDC, dirtyRect.x(), dirtyRect.y(), dirtyRect.width(), dirtyRect.height(), bitmapDC,
1215            dirtyRect.x(), dirtyRect.y(), SRCCOPY);
1216
1217     m_needsDisplay = false;
1218 }
1219
1220 void WebView::frameRect(RECT* rect)
1221 {
1222     ::GetWindowRect(m_viewWindow, rect);
1223 }
1224
1225 class WindowCloseTimer : public WebCore::SuspendableTimer {
1226 public:
1227     static WindowCloseTimer* create(WebView*);
1228
1229 private:
1230     WindowCloseTimer(ScriptExecutionContext*, WebView*);
1231     virtual void contextDestroyed();
1232     virtual void fired();
1233
1234     WebView* m_webView;
1235 };
1236
1237 WindowCloseTimer* WindowCloseTimer::create(WebView* webView)
1238 {
1239     ASSERT_ARG(webView, webView);
1240     Frame* frame = core(webView->topLevelFrame());
1241     ASSERT(frame);
1242     if (!frame)
1243         return 0;
1244
1245     Document* document = frame->document();
1246     ASSERT(document);
1247     if (!document)
1248         return 0;
1249
1250     return new WindowCloseTimer(document, webView);
1251 }
1252
1253 WindowCloseTimer::WindowCloseTimer(ScriptExecutionContext* context, WebView* webView)
1254     : SuspendableTimer(context)
1255     , m_webView(webView)
1256 {
1257     ASSERT_ARG(context, context);
1258     ASSERT_ARG(webView, webView);
1259 }
1260
1261 void WindowCloseTimer::contextDestroyed()
1262 {
1263     SuspendableTimer::contextDestroyed();
1264     delete this;
1265 }
1266
1267 void WindowCloseTimer::fired()
1268 {
1269     m_webView->closeWindowTimerFired();
1270 }
1271
1272 void WebView::closeWindowSoon()
1273 {
1274     if (m_closeWindowTimer)
1275         return;
1276
1277     m_closeWindowTimer = WindowCloseTimer::create(this);
1278     if (!m_closeWindowTimer)
1279         return;
1280     m_closeWindowTimer->startOneShot(0);
1281
1282     AddRef();
1283 }
1284
1285 void WebView::closeWindowTimerFired()
1286 {
1287     closeWindow();
1288     Release();
1289 }
1290
1291 void WebView::closeWindow()
1292 {
1293     if (m_hasSpellCheckerDocumentTag) {
1294         if (m_editingDelegate)
1295             m_editingDelegate->closeSpellDocument(this);
1296         m_hasSpellCheckerDocumentTag = false;
1297     }
1298
1299     COMPtr<IWebUIDelegate> ui;
1300     if (SUCCEEDED(uiDelegate(&ui)))
1301         ui->webViewClose(this);
1302 }
1303
1304 bool WebView::canHandleRequest(const WebCore::ResourceRequest& request)
1305 {
1306     // On the mac there's an about url protocol implementation but CFNetwork doesn't have that.
1307     if (equalIgnoringCase(String(request.url().protocol()), "about"))
1308         return true;
1309
1310 #if USE(CFNETWORK)
1311     if (CFURLProtocolCanHandleRequest(request.cfURLRequest(UpdateHTTPBody)))
1312         return true;
1313
1314     // FIXME: Mac WebKit calls _representationExistsForURLScheme here
1315     return false;
1316 #else
1317     return true;
1318 #endif
1319 }
1320
1321 String WebView::standardUserAgentWithApplicationName(const String& applicationName)
1322 {
1323     DEPRECATED_DEFINE_STATIC_LOCAL(String, osVersion, (windowsVersionForUAString()));
1324     DEPRECATED_DEFINE_STATIC_LOCAL(String, webKitVersion, (webKitVersionString()));
1325
1326     return makeString("Mozilla/5.0 (", osVersion, ") AppleWebKit/", webKitVersion, " (KHTML, like Gecko)", applicationName.isEmpty() ? "" : " ", applicationName);
1327 }
1328
1329 Page* WebView::page()
1330 {
1331     return m_page;
1332 }
1333
1334 bool WebView::handleContextMenuEvent(WPARAM wParam, LPARAM lParam)
1335 {
1336     // Translate the screen coordinates into window coordinates
1337     POINT coords = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
1338     if (coords.x == -1 || coords.y == -1) {
1339         // The contextMenuController() holds onto the last context menu that was popped up on the
1340         // page until a new one is created. We need to clear this menu before propagating the event
1341         // through the DOM so that we can detect if we create a new menu for this event, since we
1342         // won't create a new menu if the DOM swallows the event and the defaultEventHandler does
1343         // not run.
1344         m_page->contextMenuController().clearContextMenu();
1345
1346         Frame& focusedFrame = m_page->focusController().focusedOrMainFrame();
1347         return focusedFrame.eventHandler().sendContextMenuEventForKey();
1348
1349     } else {
1350         if (!::ScreenToClient(m_viewWindow, &coords))
1351             return false;
1352     }
1353
1354     lParam = MAKELPARAM(coords.x, coords.y);
1355
1356     m_page->contextMenuController().clearContextMenu();
1357
1358     IntPoint documentPoint(m_page->mainFrame().view()->windowToContents(coords));
1359     HitTestResult result = m_page->mainFrame().eventHandler().hitTestResultAtPoint(documentPoint);
1360     Frame* targetFrame = result.innerNonSharedNode() ? result.innerNonSharedNode()->document().frame() : &m_page->focusController().focusedOrMainFrame();
1361
1362     targetFrame->view()->setCursor(pointerCursor());
1363     PlatformMouseEvent mouseEvent(m_viewWindow, WM_RBUTTONUP, wParam, lParam);
1364     bool handledEvent = targetFrame->eventHandler().sendContextMenuEvent(mouseEvent);
1365     if (!handledEvent)
1366         return false;
1367
1368     ContextMenuController& contextMenuController = m_page->contextMenuController();
1369
1370     // Show the menu
1371     ContextMenu* coreMenu = contextMenuController.contextMenu();
1372     if (!coreMenu)
1373         return false;
1374
1375     Frame* frame = contextMenuController.hitTestResult().innerNodeFrame();
1376     if (!frame)
1377         return false;
1378
1379     FrameView* view = frame->view();
1380     if (!view)
1381         return false;
1382
1383     POINT point(view->contentsToWindow(contextMenuController.hitTestResult().roundedPointInInnerNodeFrame()));
1384
1385     // Translate the point to screen coordinates
1386     if (!::ClientToScreen(m_viewWindow, &point))
1387         return false;
1388
1389     BOOL hasCustomMenus = false;
1390     if (m_uiDelegate)
1391         m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
1392
1393     if (hasCustomMenus)
1394         m_uiDelegate->trackCustomPopupMenu((IWebView*)this, (OLE_HANDLE)(ULONG64)coreMenu->platformContextMenu(), &point);
1395     else {
1396         // Surprisingly, TPM_RIGHTBUTTON means that items are selectable with either the right OR left mouse button
1397         UINT flags = TPM_RIGHTBUTTON | TPM_TOPALIGN | TPM_VERPOSANIMATION | TPM_HORIZONTAL
1398             | TPM_LEFTALIGN | TPM_HORPOSANIMATION;
1399         ::TrackPopupMenuEx(coreMenu->platformContextMenu(), flags, point.x, point.y, m_viewWindow, 0);
1400     }
1401
1402     return true;
1403 }
1404
1405 bool WebView::onMeasureItem(WPARAM /*wParam*/, LPARAM lParam)
1406 {
1407     if (!m_uiDelegate)
1408         return false;
1409
1410     BOOL hasCustomMenus = false;
1411     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
1412     if (!hasCustomMenus)
1413         return false;
1414
1415     m_uiDelegate->measureCustomMenuItem((IWebView*)this, (void*)lParam);
1416     return true;
1417 }
1418
1419 bool WebView::onDrawItem(WPARAM /*wParam*/, LPARAM lParam)
1420 {
1421     if (!m_uiDelegate)
1422         return false;
1423
1424     BOOL hasCustomMenus = false;
1425     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
1426     if (!hasCustomMenus)
1427         return false;
1428
1429     m_uiDelegate->drawCustomMenuItem((IWebView*)this, (void*)lParam);
1430     return true;
1431 }
1432
1433 bool WebView::onInitMenuPopup(WPARAM wParam, LPARAM /*lParam*/)
1434 {
1435     if (!m_uiDelegate)
1436         return false;
1437
1438     HMENU menu = (HMENU)wParam;
1439     if (!menu)
1440         return false;
1441
1442     BOOL hasCustomMenus = false;
1443     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
1444     if (!hasCustomMenus)
1445         return false;
1446
1447     m_uiDelegate->addCustomMenuDrawingData((IWebView*)this, (OLE_HANDLE)(ULONG64)menu);
1448     return true;
1449 }
1450
1451 bool WebView::onUninitMenuPopup(WPARAM wParam, LPARAM /*lParam*/)
1452 {
1453     if (!m_uiDelegate)
1454         return false;
1455
1456     HMENU menu = (HMENU)wParam;
1457     if (!menu)
1458         return false;
1459
1460     BOOL hasCustomMenus = false;
1461     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
1462     if (!hasCustomMenus)
1463         return false;
1464
1465     m_uiDelegate->cleanUpCustomMenuDrawingData((IWebView*)this, (OLE_HANDLE)(ULONG64)menu);
1466     return true;
1467 }
1468
1469 void WebView::performContextMenuAction(WPARAM wParam, LPARAM lParam, bool byPosition)
1470 {
1471     ContextMenu* menu = m_page->contextMenuController().contextMenu();
1472     ASSERT(menu);
1473
1474     ContextMenuItem* item = byPosition ? menu->itemAtIndex((unsigned)wParam) : menu->itemWithAction((ContextMenuAction)wParam);
1475     if (!item)
1476         return;
1477     m_page->contextMenuController().contextMenuItemSelected(item);
1478 }
1479
1480 bool WebView::handleMouseEvent(UINT message, WPARAM wParam, LPARAM lParam)
1481 {
1482     static LONG globalClickCount;
1483     static IntPoint globalPrevPoint;
1484     static MouseButton globalPrevButton;
1485     static LONG globalPrevMouseDownTime;
1486
1487     if (message == WM_CANCELMODE) {
1488         m_page->mainFrame().eventHandler().lostMouseCapture();
1489         return true;
1490     }
1491
1492     // Create our event.
1493     // On WM_MOUSELEAVE we need to create a mouseout event, so we force the position
1494     // of the event to be at (MINSHORT, MINSHORT).
1495     LPARAM position = (message == WM_MOUSELEAVE) ? ((MINSHORT << 16) | MINSHORT) : lParam;
1496     PlatformMouseEvent mouseEvent(m_viewWindow, message, wParam, position, m_mouseActivated);
1497
1498     setMouseActivated(false);
1499
1500     bool insideThreshold = abs(globalPrevPoint.x() - mouseEvent.position().x()) < ::GetSystemMetrics(SM_CXDOUBLECLK) &&
1501                            abs(globalPrevPoint.y() - mouseEvent.position().y()) < ::GetSystemMetrics(SM_CYDOUBLECLK);
1502     LONG messageTime = ::GetMessageTime();
1503
1504     bool handled = false;
1505
1506     if (message == WM_LBUTTONDOWN || message == WM_MBUTTONDOWN || message == WM_RBUTTONDOWN) {
1507         // FIXME: I'm not sure if this is the "right" way to do this
1508         // but without this call, we never become focused since we don't allow
1509         // the default handling of mouse events.
1510         SetFocus(m_viewWindow);
1511
1512         // Always start capturing events when the mouse goes down in our HWND.
1513         ::SetCapture(m_viewWindow);
1514
1515         if (((messageTime - globalPrevMouseDownTime) < (LONG)::GetDoubleClickTime()) && 
1516             insideThreshold &&
1517             mouseEvent.button() == globalPrevButton)
1518             globalClickCount++;
1519         else
1520             // Reset the click count.
1521             globalClickCount = 1;
1522         globalPrevMouseDownTime = messageTime;
1523         globalPrevButton = mouseEvent.button();
1524         globalPrevPoint = mouseEvent.position();
1525         
1526         mouseEvent.setClickCount(globalClickCount);
1527         handled = m_page->mainFrame().eventHandler().handleMousePressEvent(mouseEvent);
1528     } else if (message == WM_LBUTTONDBLCLK || message == WM_MBUTTONDBLCLK || message == WM_RBUTTONDBLCLK) {
1529         globalClickCount++;
1530         mouseEvent.setClickCount(globalClickCount);
1531         handled = m_page->mainFrame().eventHandler().handleMousePressEvent(mouseEvent);
1532     } else if (message == WM_LBUTTONUP || message == WM_MBUTTONUP || message == WM_RBUTTONUP) {
1533         // Record the global position and the button of the up.
1534         globalPrevButton = mouseEvent.button();
1535         globalPrevPoint = mouseEvent.position();
1536         mouseEvent.setClickCount(globalClickCount);
1537         m_page->mainFrame().eventHandler().handleMouseReleaseEvent(mouseEvent);
1538         ::ReleaseCapture();
1539     } else if (message == WM_MOUSELEAVE && m_mouseOutTracker) {
1540         // Once WM_MOUSELEAVE is fired windows clears this tracker
1541         // so there is no need to disable it ourselves.
1542         m_mouseOutTracker.clear();
1543         m_page->mainFrame().eventHandler().mouseMoved(mouseEvent);
1544         handled = true;
1545     } else if (message == WM_MOUSEMOVE) {
1546         if (!insideThreshold)
1547             globalClickCount = 0;
1548         mouseEvent.setClickCount(globalClickCount);
1549         handled = m_page->mainFrame().eventHandler().mouseMoved(mouseEvent);
1550         if (!m_mouseOutTracker) {
1551             m_mouseOutTracker = adoptPtr(new TRACKMOUSEEVENT);
1552             m_mouseOutTracker->cbSize = sizeof(TRACKMOUSEEVENT);
1553             m_mouseOutTracker->dwFlags = TME_LEAVE;
1554             m_mouseOutTracker->hwndTrack = m_viewWindow;
1555             ::TrackMouseEvent(m_mouseOutTracker.get());
1556         }
1557     }
1558     return handled;
1559 }
1560
1561 bool WebView::gestureNotify(WPARAM wParam, LPARAM lParam)
1562 {
1563     GESTURENOTIFYSTRUCT* gn = reinterpret_cast<GESTURENOTIFYSTRUCT*>(lParam);
1564
1565     Frame* coreFrame = core(m_mainFrame);
1566     if (!coreFrame)
1567         return false;
1568
1569     ScrollView* view = coreFrame->view();
1570     if (!view)
1571         return false;
1572
1573     // If we don't have this function, we shouldn't be receiving this message
1574     ASSERT(SetGestureConfigPtr());
1575
1576     bool hitScrollbar = false;
1577     POINT gestureBeginPoint = {gn->ptsLocation.x, gn->ptsLocation.y};
1578     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::DisallowShadowContent);
1579     for (Frame* childFrame = &m_page->mainFrame(); childFrame; childFrame = EventHandler::subframeForTargetNode(m_gestureTargetNode.get())) {
1580         FrameView* frameView = childFrame->view();
1581         if (!frameView)
1582             break;
1583         RenderView* renderView = childFrame->document()->renderView();
1584         if (!renderView)
1585             break;
1586         RenderLayer* layer = renderView->layer();
1587         if (!layer)
1588             break;
1589
1590         HitTestResult result(frameView->screenToContents(gestureBeginPoint));
1591         layer->hitTest(request, result);
1592         m_gestureTargetNode = result.innerNode();
1593
1594         if (!hitScrollbar)
1595             hitScrollbar = result.scrollbar();
1596     }
1597
1598     if (!hitScrollbar) {
1599         // The hit testing above won't detect if we've hit the main frame's vertical scrollbar. Check that manually now.
1600         RECT webViewRect;
1601         GetWindowRect(m_viewWindow, &webViewRect);
1602         hitScrollbar = (view->verticalScrollbar() && (gestureBeginPoint.x > (webViewRect.right - view->verticalScrollbar()->theme()->scrollbarThickness()))) 
1603             || (view->horizontalScrollbar() && (gestureBeginPoint.y > (webViewRect.bottom - view->horizontalScrollbar()->theme()->scrollbarThickness())));  
1604     }
1605
1606     bool canBeScrolled = false;
1607     if (m_gestureTargetNode) {
1608         for (RenderObject* renderer = m_gestureTargetNode->renderer(); renderer; renderer = renderer->parent()) {
1609             if (renderer->isBox() && toRenderBox(renderer)->canBeScrolledAndHasScrollableArea()) {
1610                 canBeScrolled = true;
1611                 break;
1612             }
1613         }
1614     } else {
1615         // We've hit the main document but not any of the document's content
1616         if (core(m_mainFrame)->view()->isScrollable())
1617             canBeScrolled = true;
1618     }
1619
1620     // We always allow two-fingered panning with inertia and a gutter (which limits movement to one
1621     // direction in most cases).
1622     DWORD dwPanWant = GC_PAN | GC_PAN_WITH_INERTIA | GC_PAN_WITH_GUTTER;
1623     DWORD dwPanBlock = 0;
1624
1625     if (hitScrollbar || !canBeScrolled) {
1626         // The part of the page under the gesture can't be scrolled, or the gesture is on a scrollbar.
1627         // Disallow single-fingered panning in this case so we'll fall back to the default
1628         // behavior (which allows the scrollbar thumb to be dragged, text selections to be made, etc.).
1629         dwPanBlock = GC_PAN_WITH_SINGLE_FINGER_VERTICALLY | GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY;
1630     } else {
1631         // The part of the page the gesture is under can be scrolled, and we're not under a scrollbar.
1632         // Allow single-fingered vertical panning in this case, so the user will be able to pan the page
1633         // with one or two fingers.
1634         dwPanWant |= GC_PAN_WITH_SINGLE_FINGER_VERTICALLY;
1635
1636         // Disable single-fingered horizontal panning only if the target node is text.
1637         if (m_gestureTargetNode && m_gestureTargetNode->isTextNode())
1638             dwPanBlock = GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY;
1639         else
1640             dwPanWant |= GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY;
1641     }
1642
1643     GESTURECONFIG gc = { GID_PAN, dwPanWant, dwPanBlock };
1644     return SetGestureConfigPtr()(m_viewWindow, 0, 1, &gc, sizeof(GESTURECONFIG));
1645 }
1646
1647 bool WebView::gesture(WPARAM wParam, LPARAM lParam) 
1648 {
1649     // We want to bail out if we don't have either of these functions
1650     if (!GetGestureInfoPtr() || !CloseGestureInfoHandlePtr())
1651         return false;
1652
1653     HGESTUREINFO gestureHandle = reinterpret_cast<HGESTUREINFO>(lParam);
1654     
1655     GESTUREINFO gi = {0};
1656     gi.cbSize = sizeof(GESTUREINFO);
1657
1658     if (!GetGestureInfoPtr()(gestureHandle, reinterpret_cast<PGESTUREINFO>(&gi)))
1659         return false;
1660
1661     switch (gi.dwID) {
1662     case GID_BEGIN:
1663         m_lastPanX = gi.ptsLocation.x;
1664         m_lastPanY = gi.ptsLocation.y;
1665
1666         break;
1667     case GID_END:
1668         m_gestureTargetNode = 0;
1669         break;
1670     case GID_PAN: {
1671         if (gi.dwFlags & GF_BEGIN) {
1672             m_lastPanX = gi.ptsLocation.x;
1673             m_lastPanY = gi.ptsLocation.y;
1674         }
1675         // Where are the fingers currently?
1676         long currentX = gi.ptsLocation.x;
1677         long currentY = gi.ptsLocation.y;
1678         // How far did we pan in each direction?
1679         long deltaX = currentX - m_lastPanX;
1680         long deltaY = currentY - m_lastPanY;
1681         // Calculate the overpan for window bounce
1682         m_yOverpan -= m_lastPanY - currentY;
1683         m_xOverpan -= m_lastPanX - currentX;
1684         // Update our class variables with updated values
1685         m_lastPanX = currentX;
1686         m_lastPanY = currentY;
1687
1688         Frame* coreFrame = core(m_mainFrame);
1689         if (!coreFrame) {
1690             CloseGestureInfoHandlePtr()(gestureHandle);
1691             return false;
1692         }
1693
1694         ScrollableArea* scrolledArea = 0;
1695
1696         if (!m_gestureTargetNode || !m_gestureTargetNode->renderer()) {
1697             // We might directly hit the document without hitting any nodes
1698             coreFrame->view()->scrollBy(IntSize(-deltaX, -deltaY));
1699             scrolledArea = coreFrame->view();
1700         } else
1701             m_gestureTargetNode->renderer()->enclosingLayer()->enclosingScrollableLayer()->scrollByRecursively(IntSize(-deltaX, -deltaY), WebCore::RenderLayer::ScrollOffsetClamped, &scrolledArea);
1702
1703         if (!(UpdatePanningFeedbackPtr() && BeginPanningFeedbackPtr() && EndPanningFeedbackPtr())) {
1704             CloseGestureInfoHandlePtr()(gestureHandle);
1705             return true;
1706         }
1707
1708         // Handle overpanning
1709         if (gi.dwFlags & GF_BEGIN) {
1710             BeginPanningFeedbackPtr()(m_viewWindow);
1711             m_yOverpan = 0;
1712             m_xOverpan = 0;
1713         } else if (gi.dwFlags & GF_END) {
1714             EndPanningFeedbackPtr()(m_viewWindow, true);
1715             m_yOverpan = 0;
1716             m_xOverpan = 0;
1717         }
1718
1719         if (!scrolledArea) {
1720             CloseGestureInfoHandlePtr()(gestureHandle);
1721             return true;
1722         }
1723
1724         Scrollbar* vertScrollbar = scrolledArea->verticalScrollbar();
1725
1726         int ypan = 0;
1727         int xpan = 0;
1728
1729         if (vertScrollbar && (!vertScrollbar->currentPos() || vertScrollbar->currentPos() >= vertScrollbar->maximum()))
1730             ypan = m_yOverpan;
1731
1732         Scrollbar* horiScrollbar = scrolledArea->horizontalScrollbar();
1733
1734         if (horiScrollbar && (!horiScrollbar->currentPos() || horiScrollbar->currentPos() >= horiScrollbar->maximum()))
1735             xpan = m_xOverpan;
1736
1737         UpdatePanningFeedbackPtr()(m_viewWindow, xpan, ypan, gi.dwFlags & GF_INERTIA);
1738
1739         CloseGestureInfoHandlePtr()(gestureHandle);
1740         return true;
1741     }
1742     default:
1743         break;
1744     }
1745
1746     // If we get to this point, the gesture has not been handled. We forward
1747     // the call to DefWindowProc by returning false, and we don't need to 
1748     // to call CloseGestureInfoHandle. 
1749     // http://msdn.microsoft.com/en-us/library/dd353228(VS.85).aspx
1750     return false;
1751 }
1752
1753 bool WebView::mouseWheel(WPARAM wParam, LPARAM lParam, bool isMouseHWheel)
1754 {
1755     // Ctrl+Mouse wheel doesn't ever go into WebCore.  It is used to
1756     // zoom instead (Mac zooms the whole Desktop, but Windows browsers trigger their
1757     // own local zoom modes for Ctrl+wheel).
1758     if (wParam & MK_CONTROL) {
1759         short delta = short(HIWORD(wParam));
1760         if (delta < 0)
1761             makeTextSmaller(0);
1762         else
1763             makeTextLarger(0);
1764         return true;
1765     }
1766     
1767     // FIXME: This doesn't fix https://bugs.webkit.org/show_bug.cgi?id=28217. This only fixes https://bugs.webkit.org/show_bug.cgi?id=28203.
1768     HWND focusedWindow = GetFocus();
1769     if (focusedWindow && focusedWindow != m_viewWindow) {
1770         // Our focus is on a different hwnd, see if it's a PopupMenu and if so, set the focus back on us (which will hide the popup).
1771         WCHAR className[256];
1772
1773         // Make sure truncation won't affect the comparison.
1774         ASSERT(WTF_ARRAY_LENGTH(className) > wcslen(PopupMenuWin::popupClassName()));
1775
1776         if (GetClassNameW(focusedWindow, className, WTF_ARRAY_LENGTH(className)) && !wcscmp(className, PopupMenuWin::popupClassName())) {
1777             // We don't let the WebView scroll here for two reasons - 1) To match Firefox behavior, 2) If we do scroll, we lose the
1778             // focus ring around the select menu.
1779             SetFocus(m_viewWindow);
1780             return true;
1781         }
1782     }
1783
1784     PlatformWheelEvent wheelEvent(m_viewWindow, wParam, lParam, isMouseHWheel);
1785     Frame* coreFrame = core(m_mainFrame);
1786     if (!coreFrame)
1787         return false;
1788
1789     return coreFrame->eventHandler().handleWheelEvent(wheelEvent);
1790 }
1791
1792 bool WebView::verticalScroll(WPARAM wParam, LPARAM /*lParam*/)
1793 {
1794     ScrollDirection direction;
1795     ScrollGranularity granularity;
1796     switch (LOWORD(wParam)) {
1797     case SB_LINEDOWN:
1798         granularity = ScrollByLine;
1799         direction = ScrollDown;
1800         break;
1801     case SB_LINEUP:
1802         granularity = ScrollByLine;
1803         direction = ScrollUp;
1804         break;
1805     case SB_PAGEDOWN:
1806         granularity = ScrollByDocument;
1807         direction = ScrollDown;
1808         break;
1809     case SB_PAGEUP:
1810         granularity = ScrollByDocument;
1811         direction = ScrollUp;
1812         break;
1813     default:
1814         return false;
1815         break;
1816     }
1817     
1818     Frame& frame = m_page->focusController().focusedOrMainFrame();
1819     return frame.eventHandler().scrollRecursively(direction, granularity);
1820 }
1821
1822 bool WebView::horizontalScroll(WPARAM wParam, LPARAM /*lParam*/)
1823 {
1824     ScrollDirection direction;
1825     ScrollGranularity granularity;
1826     switch (LOWORD(wParam)) {
1827     case SB_LINELEFT:
1828         granularity = ScrollByLine;
1829         direction = ScrollLeft;
1830         break;
1831     case SB_LINERIGHT:
1832         granularity = ScrollByLine;
1833         direction = ScrollRight;
1834         break;
1835     case SB_PAGELEFT:
1836         granularity = ScrollByDocument;
1837         direction = ScrollLeft;
1838         break;
1839     case SB_PAGERIGHT:
1840         granularity = ScrollByDocument;
1841         direction = ScrollRight;
1842         break;
1843     default:
1844         return false;
1845     }
1846
1847     Frame& frame = m_page->focusController().focusedOrMainFrame();
1848     return frame.eventHandler().scrollRecursively(direction, granularity);
1849 }
1850
1851
1852 bool WebView::execCommand(WPARAM wParam, LPARAM /*lParam*/)
1853 {
1854     Frame& frame = m_page->focusController().focusedOrMainFrame();
1855     switch (LOWORD(wParam)) {
1856         case SelectAll:
1857             return frame.editor().command("SelectAll").execute();
1858         case Undo:
1859             return frame.editor().command("Undo").execute();
1860         case Redo:
1861             return frame.editor().command("Redo").execute();
1862     }
1863     return false;
1864 }
1865
1866 bool WebView::keyUp(WPARAM virtualKeyCode, LPARAM keyData, bool systemKeyDown)
1867 {
1868     PlatformKeyboardEvent keyEvent(m_viewWindow, virtualKeyCode, keyData, PlatformEvent::KeyUp, systemKeyDown);
1869
1870     Frame& frame = m_page->focusController().focusedOrMainFrame();
1871     m_currentCharacterCode = 0;
1872
1873     return frame.eventHandler().keyEvent(keyEvent);
1874 }
1875
1876 static const unsigned CtrlKey = 1 << 0;
1877 static const unsigned AltKey = 1 << 1;
1878 static const unsigned ShiftKey = 1 << 2;
1879
1880
1881 struct KeyDownEntry {
1882     unsigned virtualKey;
1883     unsigned modifiers;
1884     const char* name;
1885 };
1886
1887 struct KeyPressEntry {
1888     unsigned charCode;
1889     unsigned modifiers;
1890     const char* name;
1891 };
1892
1893 static const KeyDownEntry keyDownEntries[] = {
1894     { VK_LEFT,   0,                  "MoveLeft"                                    },
1895     { VK_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"                  },
1896     { VK_LEFT,   CtrlKey,            "MoveWordLeft"                                },
1897     { VK_LEFT,   CtrlKey | ShiftKey, "MoveWordLeftAndModifySelection"              },
1898     { VK_RIGHT,  0,                  "MoveRight"                                   },
1899     { VK_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"                 },
1900     { VK_RIGHT,  CtrlKey,            "MoveWordRight"                               },
1901     { VK_RIGHT,  CtrlKey | ShiftKey, "MoveWordRightAndModifySelection"             },
1902     { VK_UP,     0,                  "MoveUp"                                      },
1903     { VK_UP,     ShiftKey,           "MoveUpAndModifySelection"                    },
1904     { VK_PRIOR,  ShiftKey,           "MovePageUpAndModifySelection"                },
1905     { VK_DOWN,   0,                  "MoveDown"                                    },
1906     { VK_DOWN,   ShiftKey,           "MoveDownAndModifySelection"                  },
1907     { VK_NEXT,   ShiftKey,           "MovePageDownAndModifySelection"              },
1908     { VK_PRIOR,  0,                  "MovePageUp"                                  },
1909     { VK_NEXT,   0,                  "MovePageDown"                                },
1910     { VK_HOME,   0,                  "MoveToBeginningOfLine"                       },
1911     { VK_HOME,   ShiftKey,           "MoveToBeginningOfLineAndModifySelection"     },
1912     { VK_HOME,   CtrlKey,            "MoveToBeginningOfDocument"                   },
1913     { VK_HOME,   CtrlKey | ShiftKey, "MoveToBeginningOfDocumentAndModifySelection" },
1914
1915     { VK_END,    0,                  "MoveToEndOfLine"                             },
1916     { VK_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"           },
1917     { VK_END,    CtrlKey,            "MoveToEndOfDocument"                         },
1918     { VK_END,    CtrlKey | ShiftKey, "MoveToEndOfDocumentAndModifySelection"       },
1919
1920     { VK_BACK,   0,                  "DeleteBackward"                              },
1921     { VK_BACK,   ShiftKey,           "DeleteBackward"                              },
1922     { VK_DELETE, 0,                  "DeleteForward"                               },
1923     { VK_BACK,   CtrlKey,            "DeleteWordBackward"                          },
1924     { VK_DELETE, CtrlKey,            "DeleteWordForward"                           },
1925     
1926     { 'B',       CtrlKey,            "ToggleBold"                                  },
1927     { 'I',       CtrlKey,            "ToggleItalic"                                },
1928
1929     { VK_ESCAPE, 0,                  "Cancel"                                      },
1930     { VK_OEM_PERIOD, CtrlKey,        "Cancel"                                      },
1931     { VK_TAB,    0,                  "InsertTab"                                   },
1932     { VK_TAB,    ShiftKey,           "InsertBacktab"                               },
1933     { VK_RETURN, 0,                  "InsertNewline"                               },
1934     { VK_RETURN, CtrlKey,            "InsertNewline"                               },
1935     { VK_RETURN, AltKey,             "InsertNewline"                               },
1936     { VK_RETURN, ShiftKey,           "InsertNewline"                               },
1937     { VK_RETURN, AltKey | ShiftKey,  "InsertNewline"                               },
1938
1939     // It's not quite clear whether clipboard shortcuts and Undo/Redo should be handled
1940     // in the application or in WebKit. We chose WebKit.
1941     { 'C',       CtrlKey,            "Copy"                                        },
1942     { 'V',       CtrlKey,            "Paste"                                       },
1943     { 'X',       CtrlKey,            "Cut"                                         },
1944     { 'A',       CtrlKey,            "SelectAll"                                   },
1945     { VK_INSERT, CtrlKey,            "Copy"                                        },
1946     { VK_DELETE, ShiftKey,           "Cut"                                         },
1947     { VK_INSERT, ShiftKey,           "Paste"                                       },
1948     { 'Z',       CtrlKey,            "Undo"                                        },
1949     { 'Z',       CtrlKey | ShiftKey, "Redo"                                        },
1950 };
1951
1952 static const KeyPressEntry keyPressEntries[] = {
1953     { '\t',   0,                  "InsertTab"                                   },
1954     { '\t',   ShiftKey,           "InsertBacktab"                               },
1955     { '\r',   0,                  "InsertNewline"                               },
1956     { '\r',   CtrlKey,            "InsertNewline"                               },
1957     { '\r',   AltKey,             "InsertNewline"                               },
1958     { '\r',   ShiftKey,           "InsertNewline"                               },
1959     { '\r',   AltKey | ShiftKey,  "InsertNewline"                               },
1960 };
1961
1962 const char* WebView::interpretKeyEvent(const KeyboardEvent* evt)
1963 {
1964     ASSERT(evt->type() == eventNames().keydownEvent || evt->type() == eventNames().keypressEvent);
1965
1966     static HashMap<int, const char*>* keyDownCommandsMap = 0;
1967     static HashMap<int, const char*>* keyPressCommandsMap = 0;
1968
1969     if (!keyDownCommandsMap) {
1970         keyDownCommandsMap = new HashMap<int, const char*>;
1971         keyPressCommandsMap = new HashMap<int, const char*>;
1972
1973         for (size_t i = 0; i < WTF_ARRAY_LENGTH(keyDownEntries); ++i)
1974             keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey, keyDownEntries[i].name);
1975
1976         for (size_t i = 0; i < WTF_ARRAY_LENGTH(keyPressEntries); ++i)
1977             keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode, keyPressEntries[i].name);
1978     }
1979
1980     unsigned modifiers = 0;
1981     if (evt->shiftKey())
1982         modifiers |= ShiftKey;
1983     if (evt->altKey())
1984         modifiers |= AltKey;
1985     if (evt->ctrlKey())
1986         modifiers |= CtrlKey;
1987
1988     if (evt->type() == eventNames().keydownEvent) {
1989         int mapKey = modifiers << 16 | evt->keyCode();
1990         return mapKey ? keyDownCommandsMap->get(mapKey) : 0;
1991     }
1992
1993     int mapKey = modifiers << 16 | evt->charCode();
1994     return mapKey ? keyPressCommandsMap->get(mapKey) : 0;
1995 }
1996
1997 bool WebView::handleEditingKeyboardEvent(KeyboardEvent* evt)
1998 {
1999     Node* node = evt->target()->toNode();
2000     ASSERT(node);
2001     Frame* frame = node->document().frame();
2002     ASSERT(frame);
2003
2004     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
2005     if (!keyEvent || keyEvent->isSystemKey())  // do not treat this as text input if it's a system key event
2006         return false;
2007
2008     Editor::Command command = frame->editor().command(interpretKeyEvent(evt));
2009
2010     if (keyEvent->type() == PlatformEvent::RawKeyDown) {
2011         // WebKit doesn't have enough information about mode to decide how commands that just insert text if executed via Editor should be treated,
2012         // so we leave it upon WebCore to either handle them immediately (e.g. Tab that changes focus) or let a keypress event be generated
2013         // (e.g. Tab that inserts a Tab character, or Enter).
2014         return !command.isTextInsertion() && command.execute(evt);
2015     }
2016
2017      if (command.execute(evt))
2018         return true;
2019
2020     // Don't insert null or control characters as they can result in unexpected behaviour
2021     if (evt->charCode() < ' ')
2022         return false;
2023
2024     return frame->editor().insertText(evt->keyEvent()->text(), evt);
2025 }
2026
2027 bool WebView::keyDown(WPARAM virtualKeyCode, LPARAM keyData, bool systemKeyDown)
2028 {
2029 #if ENABLE(FULLSCREEN_API)
2030     // Trap the ESC key when in full screen mode.
2031     if (virtualKeyCode == VK_ESCAPE && isFullScreen()) {
2032         m_fullscreenController->exitFullScreen();
2033         return false;
2034     }
2035 #endif
2036     Frame& frame = m_page->focusController().focusedOrMainFrame();
2037
2038     PlatformKeyboardEvent keyEvent(m_viewWindow, virtualKeyCode, keyData, PlatformEvent::RawKeyDown, systemKeyDown);
2039     bool handled = frame.eventHandler().keyEvent(keyEvent);
2040
2041     // These events cannot be canceled, and we have no default handling for them.
2042     // FIXME: match IE list more closely, see <http://msdn2.microsoft.com/en-us/library/ms536938.aspx>.
2043     if (systemKeyDown && virtualKeyCode != VK_RETURN)
2044         return false;
2045
2046     if (handled) {
2047         // FIXME: remove WM_UNICHAR, too
2048         MSG msg;
2049         // WM_SYSCHAR events should not be removed, because access keys are implemented in WebCore in WM_SYSCHAR handler.
2050         if (!systemKeyDown)
2051             ::PeekMessage(&msg, m_viewWindow, WM_CHAR, WM_CHAR, PM_REMOVE);
2052         return true;
2053     }
2054
2055     // We need to handle back/forward using either Ctrl+Left/Right Arrow keys.
2056     // FIXME: This logic should probably be in EventHandler::defaultArrowEventHandler().
2057     // FIXME: Should check that other modifiers aren't pressed.
2058     if (virtualKeyCode == VK_RIGHT && keyEvent.ctrlKey())
2059         return m_page->backForward().goForward();
2060     if (virtualKeyCode == VK_LEFT && keyEvent.ctrlKey())
2061         return m_page->backForward().goBack();
2062
2063     // Need to scroll the page if the arrow keys, pgup/dn, or home/end are hit.
2064     ScrollDirection direction;
2065     ScrollGranularity granularity;
2066     switch (virtualKeyCode) {
2067         case VK_LEFT:
2068             granularity = ScrollByLine;
2069             direction = ScrollLeft;
2070             break;
2071         case VK_RIGHT:
2072             granularity = ScrollByLine;
2073             direction = ScrollRight;
2074             break;
2075         case VK_UP:
2076             granularity = ScrollByLine;
2077             direction = ScrollUp;
2078             break;
2079         case VK_DOWN:
2080             granularity = ScrollByLine;
2081             direction = ScrollDown;
2082             break;
2083         case VK_HOME:
2084             granularity = ScrollByDocument;
2085             direction = ScrollUp;
2086             break;
2087         case VK_END:
2088             granularity = ScrollByDocument;
2089             direction = ScrollDown;
2090             break;
2091         case VK_PRIOR:
2092             granularity = ScrollByPage;
2093             direction = ScrollUp;
2094             break;
2095         case VK_NEXT:
2096             granularity = ScrollByPage;
2097             direction = ScrollDown;
2098             break;
2099         default:
2100             return false;
2101     }
2102
2103     return frame.eventHandler().scrollRecursively(direction, granularity);
2104 }
2105
2106 bool WebView::keyPress(WPARAM charCode, LPARAM keyData, bool systemKeyDown)
2107 {
2108     Frame& frame = m_page->focusController().focusedOrMainFrame();
2109
2110     PlatformKeyboardEvent keyEvent(m_viewWindow, charCode, keyData, PlatformEvent::Char, systemKeyDown);
2111     // IE does not dispatch keypress event for WM_SYSCHAR.
2112     if (systemKeyDown)
2113         return frame.eventHandler().handleAccessKey(keyEvent);
2114     return frame.eventHandler().keyEvent(keyEvent);
2115 }
2116
2117 void WebView::setIsBeingDestroyed()
2118 {
2119     m_isBeingDestroyed = true;
2120
2121     // Remove our this pointer from the window so we won't try to handle any more window messages.
2122     // See <http://webkit.org/b/55054>.
2123     ::SetWindowLongPtrW(m_viewWindow, 0, 0);
2124 }
2125
2126 void WebView::setShouldInvertColors(bool shouldInvertColors)
2127 {
2128     if (m_shouldInvertColors == shouldInvertColors)
2129         return;
2130
2131     m_shouldInvertColors = shouldInvertColors;
2132
2133 #if USE(CA)
2134     if (m_layerTreeHost)
2135         m_layerTreeHost->setShouldInvertColors(shouldInvertColors);
2136 #endif
2137
2138     RECT windowRect = {0};
2139     frameRect(&windowRect);
2140     repaint(windowRect, true, true);
2141 }
2142
2143 bool WebView::registerWebViewWindowClass()
2144 {
2145     static bool haveRegisteredWindowClass = false;
2146     if (haveRegisteredWindowClass)
2147         return true;
2148
2149     haveRegisteredWindowClass = true;
2150
2151     WNDCLASSEX wcex;
2152
2153     wcex.cbSize = sizeof(WNDCLASSEX);
2154
2155     wcex.style          = CS_DBLCLKS;
2156     wcex.lpfnWndProc    = WebViewWndProc;
2157     wcex.cbClsExtra     = 0;
2158     wcex.cbWndExtra     = sizeof(WebView*);
2159     wcex.hInstance      = gInstance;
2160     wcex.hIcon          = 0;
2161     wcex.hCursor        = ::LoadCursor(0, IDC_ARROW);
2162     wcex.hbrBackground  = 0;
2163     wcex.lpszMenuName   = 0;
2164     wcex.lpszClassName  = kWebViewWindowClassName;
2165     wcex.hIconSm        = 0;
2166
2167     return !!RegisterClassEx(&wcex);
2168 }
2169
2170 static HWND findTopLevelParent(HWND window)
2171 {
2172     if (!window)
2173         return 0;
2174
2175     HWND current = window;
2176     for (HWND parent = GetParent(current); current; current = parent, parent = GetParent(parent))
2177         if (!parent || !(GetWindowLongPtr(current, GWL_STYLE) & (WS_POPUP | WS_CHILD)))
2178             return current;
2179     ASSERT_NOT_REACHED();
2180     return 0;
2181 }
2182
2183 LRESULT CALLBACK WebView::WebViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2184 {
2185     LRESULT lResult = 0;
2186     LONG_PTR longPtr = GetWindowLongPtr(hWnd, 0);
2187     WebView* webView = reinterpret_cast<WebView*>(longPtr);
2188     WebFrame* mainFrameImpl = webView ? webView->topLevelFrame() : 0;
2189     if (!mainFrameImpl)
2190         return DefWindowProc(hWnd, message, wParam, lParam);
2191
2192     // We shouldn't be trying to handle any window messages after WM_DESTROY.
2193     // See <http://webkit.org/b/55054>.
2194     ASSERT(!webView->isBeingDestroyed());
2195
2196     // hold a ref, since the WebView could go away in an event handler.
2197     COMPtr<WebView> protector(webView);
2198     ASSERT(webView);
2199
2200     // Windows Media Player has a modal message loop that will deliver messages
2201     // to us at inappropriate times and we will crash if we handle them when
2202     // they are delivered. We repost paint messages so that we eventually get
2203     // a chance to paint once the modal loop has exited, but other messages
2204     // aren't safe to repost, so we just drop them.
2205     if (PluginView::isCallingPlugin()) {
2206         if (message == WM_PAINT)
2207             PostMessage(hWnd, message, wParam, lParam);
2208         return 0;
2209     }
2210
2211     bool handled = true;
2212
2213     switch (message) {
2214         case WM_PAINT: {
2215             webView->paint(0, 0);
2216             if (webView->usesLayeredWindow())
2217                 webView->performLayeredWindowUpdate();
2218             break;
2219         }
2220         case WM_ERASEBKGND:
2221             // Don't perform a background erase.
2222             handled = true;
2223             lResult = 1;
2224             break;
2225         case WM_PRINTCLIENT:
2226             webView->paint((HDC)wParam, lParam);
2227             break;
2228         case WM_DESTROY:
2229             webView->setIsBeingDestroyed();
2230             webView->close();
2231             break;
2232         case WM_GESTURENOTIFY:
2233             handled = webView->gestureNotify(wParam, lParam);
2234             break;
2235         case WM_GESTURE:
2236             handled = webView->gesture(wParam, lParam);
2237             break;
2238         case WM_MOUSEMOVE:
2239         case WM_LBUTTONDOWN:
2240         case WM_MBUTTONDOWN:
2241         case WM_RBUTTONDOWN:
2242         case WM_LBUTTONDBLCLK:
2243         case WM_MBUTTONDBLCLK:
2244         case WM_RBUTTONDBLCLK:
2245         case WM_LBUTTONUP:
2246         case WM_MBUTTONUP:
2247         case WM_RBUTTONUP:
2248         case WM_MOUSELEAVE:
2249         case WM_CANCELMODE:
2250             if (Frame* coreFrame = core(mainFrameImpl))
2251                 if (coreFrame->view()->didFirstLayout())
2252                     handled = webView->handleMouseEvent(message, wParam, lParam);
2253             break;
2254         case WM_MOUSEWHEEL:
2255         case WM_VISTA_MOUSEHWHEEL:
2256             if (Frame* coreFrame = core(mainFrameImpl))
2257                 if (coreFrame->view()->didFirstLayout())
2258                     handled = webView->mouseWheel(wParam, lParam, message == WM_VISTA_MOUSEHWHEEL);
2259             break;
2260         case WM_SYSKEYDOWN:
2261             handled = webView->keyDown(wParam, lParam, true);
2262             break;
2263         case WM_KEYDOWN:
2264             handled = webView->keyDown(wParam, lParam);
2265             break;
2266         case WM_SYSKEYUP:
2267             handled = webView->keyUp(wParam, lParam, true);
2268             break;
2269         case WM_KEYUP:
2270             handled = webView->keyUp(wParam, lParam);
2271             break;
2272         case WM_SYSCHAR:
2273             handled = webView->keyPress(wParam, lParam, true);
2274             break;
2275         case WM_CHAR:
2276             handled = webView->keyPress(wParam, lParam);
2277             break;
2278         // FIXME: We need to check WM_UNICHAR to support supplementary characters (that don't fit in 16 bits).
2279         case WM_SIZE:
2280             if (lParam != 0)
2281                 webView->sizeChanged(IntSize(LOWORD(lParam), HIWORD(lParam)));
2282             break;
2283         case WM_SHOWWINDOW:
2284             lResult = DefWindowProc(hWnd, message, wParam, lParam);
2285             if (wParam == 0) {
2286                 // The window is being hidden (e.g., because we switched tabs).
2287                 // Null out our backing store.
2288                 webView->deleteBackingStore();
2289             }
2290             break;
2291         case WM_SETFOCUS: {
2292             COMPtr<IWebUIDelegate> uiDelegate;
2293             COMPtr<IWebUIDelegatePrivate> uiDelegatePrivate;
2294             if (SUCCEEDED(webView->uiDelegate(&uiDelegate)) && uiDelegate
2295                 && SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**) &uiDelegatePrivate)) && uiDelegatePrivate)
2296                 uiDelegatePrivate->webViewReceivedFocus(webView);
2297
2298             FocusController& focusController = webView->page()->focusController();
2299             if (Frame* frame = focusController.focusedFrame()) {
2300                 // Send focus events unless the previously focused window is a
2301                 // child of ours (for example a plugin).
2302                 if (!IsChild(hWnd, reinterpret_cast<HWND>(wParam)))
2303                     focusController.setFocused(true);
2304             } else
2305                 focusController.setFocused(true);
2306             break;
2307         }
2308         case WM_KILLFOCUS: {
2309             COMPtr<IWebUIDelegate> uiDelegate;
2310             COMPtr<IWebUIDelegatePrivate> uiDelegatePrivate;
2311             HWND newFocusWnd = reinterpret_cast<HWND>(wParam);
2312             if (SUCCEEDED(webView->uiDelegate(&uiDelegate)) && uiDelegate
2313                 && SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**) &uiDelegatePrivate)) && uiDelegatePrivate)
2314                 uiDelegatePrivate->webViewLostFocus(webView, (OLE_HANDLE)(ULONG64)newFocusWnd);
2315
2316             FocusController& focusController = webView->page()->focusController();
2317             Frame& frame = focusController.focusedOrMainFrame();
2318             webView->resetIME(&frame);
2319             // Send blur events unless we're losing focus to a child of ours.
2320             if (!IsChild(hWnd, newFocusWnd))
2321                 focusController.setFocused(false);
2322
2323             // If we are pan-scrolling when we lose focus, stop the pan scrolling.
2324             frame.eventHandler().stopAutoscrollTimer();
2325
2326             break;
2327         }
2328         case WM_WINDOWPOSCHANGED:
2329             if (reinterpret_cast<WINDOWPOS*>(lParam)->flags & SWP_SHOWWINDOW)
2330                 webView->updateActiveStateSoon();
2331             handled = false;
2332             break;
2333         case WM_CUT:
2334             webView->cut(0);
2335             break;
2336         case WM_COPY:
2337             webView->copy(0);
2338             break;
2339         case WM_PASTE:
2340             webView->paste(0);
2341             break;
2342         case WM_CLEAR:
2343             webView->delete_(0);
2344             break;
2345         case WM_COMMAND:
2346             if (HIWORD(wParam))
2347                 handled = webView->execCommand(wParam, lParam);
2348             else // If the high word of wParam is 0, the message is from a menu
2349                 webView->performContextMenuAction(wParam, lParam, false);
2350             break;
2351         case WM_MENUCOMMAND:
2352             webView->performContextMenuAction(wParam, lParam, true);
2353             break;
2354         case WM_CONTEXTMENU:
2355             handled = webView->handleContextMenuEvent(wParam, lParam);
2356             break;
2357         case WM_INITMENUPOPUP:
2358             handled = webView->onInitMenuPopup(wParam, lParam);
2359             break;
2360         case WM_MEASUREITEM:
2361             handled = webView->onMeasureItem(wParam, lParam);
2362             break;
2363         case WM_DRAWITEM:
2364             handled = webView->onDrawItem(wParam, lParam);
2365             break;
2366         case WM_UNINITMENUPOPUP:
2367             handled = webView->onUninitMenuPopup(wParam, lParam);
2368             break;
2369         case WM_XP_THEMECHANGED:
2370             if (Frame* coreFrame = core(mainFrameImpl)) {
2371                 webView->deleteBackingStore();
2372                 coreFrame->page()->theme().themeChanged();
2373                 ScrollbarTheme::theme()->themeChanged();
2374                 RECT windowRect;
2375                 ::GetClientRect(hWnd, &windowRect);
2376                 ::InvalidateRect(hWnd, &windowRect, false);
2377                 if (webView->isAcceleratedCompositing())
2378                     webView->m_backingLayer->setNeedsDisplay();
2379            }
2380             break;
2381         case WM_MOUSEACTIVATE:
2382             webView->setMouseActivated(true);
2383             handled = false;
2384             break;
2385         case WM_GETDLGCODE: {
2386             COMPtr<IWebUIDelegate> uiDelegate;
2387             COMPtr<IWebUIDelegatePrivate> uiDelegatePrivate;
2388             LONG_PTR dlgCode = 0;
2389             UINT keyCode = 0;
2390             if (lParam) {
2391                 LPMSG lpMsg = (LPMSG)lParam;
2392                 if (lpMsg->message == WM_KEYDOWN)
2393                     keyCode = (UINT) lpMsg->wParam;
2394             }
2395             if (SUCCEEDED(webView->uiDelegate(&uiDelegate)) && uiDelegate
2396                 && SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**) &uiDelegatePrivate)) && uiDelegatePrivate
2397                 && SUCCEEDED(uiDelegatePrivate->webViewGetDlgCode(webView, keyCode, &dlgCode)))
2398                 return dlgCode;
2399             handled = false;
2400             break;
2401         }
2402         case WM_GETOBJECT:
2403             handled = webView->onGetObject(wParam, lParam, lResult);
2404             break;
2405         case WM_IME_STARTCOMPOSITION:
2406             handled = webView->onIMEStartComposition();
2407             break;
2408         case WM_IME_REQUEST:
2409             lResult = webView->onIMERequest(wParam, lParam);
2410             break;
2411         case WM_IME_COMPOSITION:
2412             handled = webView->onIMEComposition(lParam);
2413             break;
2414         case WM_IME_ENDCOMPOSITION:
2415             handled = webView->onIMEEndComposition();
2416             break;
2417         case WM_IME_CHAR:
2418             handled = webView->onIMEChar(wParam, lParam);
2419             break;
2420         case WM_IME_NOTIFY:
2421             handled = webView->onIMENotify(wParam, lParam, &lResult);
2422             break;
2423         case WM_IME_SELECT:
2424             handled = webView->onIMESelect(wParam, lParam);
2425             break;
2426         case WM_IME_SETCONTEXT:
2427             handled = webView->onIMESetContext(wParam, lParam);
2428             break;
2429         case WM_TIMER:
2430             switch (wParam) {
2431                 case UpdateActiveStateTimer:
2432                     KillTimer(hWnd, UpdateActiveStateTimer);
2433                     webView->updateActiveState();
2434                     break;
2435                 case DeleteBackingStoreTimer:
2436                     webView->deleteBackingStore();
2437                     break;
2438             }
2439             break;
2440         case WM_SETCURSOR:
2441             handled = ::SetCursor(webView->m_lastSetCursor);
2442             break;
2443         case WM_VSCROLL:
2444             handled = webView->verticalScroll(wParam, lParam);
2445             break;
2446         case WM_HSCROLL:
2447             handled = webView->horizontalScroll(wParam, lParam);
2448             break;
2449         default:
2450             handled = false;
2451             break;
2452     }
2453
2454     if (webView->needsDisplay() && message != WM_PAINT)
2455         ::UpdateWindow(hWnd);
2456
2457     if (!handled)
2458         lResult = DefWindowProc(hWnd, message, wParam, lParam);
2459     
2460     // Let the client know whether we consider this message handled.
2461     return (message == WM_KEYDOWN || message == WM_SYSKEYDOWN || message == WM_KEYUP || message == WM_SYSKEYUP) ? !handled : lResult;
2462 }
2463
2464 bool WebView::developerExtrasEnabled() const
2465 {
2466     if (m_preferences->developerExtrasDisabledByOverride())
2467         return false;
2468
2469 #ifdef NDEBUG
2470     BOOL enabled;
2471     return SUCCEEDED(m_preferences->developerExtrasEnabled(&enabled)) && enabled;
2472 #else
2473     return true;
2474 #endif
2475 }
2476
2477 static String webKitVersionString()
2478 {
2479 #if !USE(CAIRO)
2480     LPWSTR buildNumberStringPtr;
2481     if (::LoadStringW(gInstance, BUILD_NUMBER, reinterpret_cast<LPWSTR>(&buildNumberStringPtr), 0) && buildNumberStringPtr)
2482         return buildNumberStringPtr;
2483 #endif
2484     return String::format("%d.%d", WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION);
2485 }
2486
2487 const String& WebView::userAgentForKURL(const URL&)
2488 {
2489     if (m_userAgentOverridden)
2490         return m_userAgentCustom;
2491
2492     if (!m_userAgentStandard.length())
2493         m_userAgentStandard = WebView::standardUserAgentWithApplicationName(m_applicationName);
2494     return m_userAgentStandard;
2495 }
2496
2497 // IUnknown -------------------------------------------------------------------
2498
2499 HRESULT STDMETHODCALLTYPE WebView::QueryInterface(REFIID riid, void** ppvObject)
2500 {
2501     *ppvObject = 0;
2502     if (IsEqualGUID(riid, CLSID_WebView))
2503         *ppvObject = this;
2504     else if (IsEqualGUID(riid, IID_IUnknown))
2505         *ppvObject = static_cast<IWebView*>(this);
2506     else if (IsEqualGUID(riid, IID_IWebView))
2507         *ppvObject = static_cast<IWebView*>(this);
2508     else if (IsEqualGUID(riid, IID_IWebViewPrivate))
2509         *ppvObject = static_cast<IWebViewPrivate*>(this);
2510     else if (IsEqualGUID(riid, IID_IWebIBActions))
2511         *ppvObject = static_cast<IWebIBActions*>(this);
2512     else if (IsEqualGUID(riid, IID_IWebViewCSS))
2513         *ppvObject = static_cast<IWebViewCSS*>(this);
2514     else if (IsEqualGUID(riid, IID_IWebViewEditing))
2515         *ppvObject = static_cast<IWebViewEditing*>(this);
2516     else if (IsEqualGUID(riid, IID_IWebViewUndoableEditing))
2517         *ppvObject = static_cast<IWebViewUndoableEditing*>(this);
2518     else if (IsEqualGUID(riid, IID_IWebViewEditingActions))
2519         *ppvObject = static_cast<IWebViewEditingActions*>(this);
2520     else if (IsEqualGUID(riid, IID_IWebNotificationObserver))
2521         *ppvObject = static_cast<IWebNotificationObserver*>(this);
2522     else if (IsEqualGUID(riid, IID_IDropTarget))
2523         *ppvObject = static_cast<IDropTarget*>(this);
2524     else
2525         return E_NOINTERFACE;
2526
2527     AddRef();
2528     return S_OK;
2529 }
2530
2531 ULONG STDMETHODCALLTYPE WebView::AddRef(void)
2532 {
2533     ASSERT(!m_deletionHasBegun);
2534     return ++m_refCount;
2535 }
2536
2537 ULONG STDMETHODCALLTYPE WebView::Release(void)
2538 {
2539     ASSERT(!m_deletionHasBegun);
2540
2541     if (m_refCount == 1) {
2542         // Call close() now so that clients don't have to. (It's harmless to call close() multiple
2543         // times.) We do this here instead of in our destructor because close() can cause AddRef()
2544         // and Release() to be called, and if that happened in our destructor we would be destroyed
2545         // more than once.
2546         close();
2547     }
2548
2549     ULONG newRef = --m_refCount;
2550     if (!newRef) {
2551 #if !ASSERT_DISABLED
2552         m_deletionHasBegun = true;
2553 #endif
2554         delete(this);
2555     }
2556
2557     return newRef;
2558 }
2559
2560 // IWebView --------------------------------------------------------------------
2561
2562 HRESULT WebView::canShowMIMEType(/* [in] */ BSTR mimeType, /* [retval][out] */ BOOL* canShow)
2563 {
2564     if (!canShow)
2565         return E_POINTER;
2566
2567     *canShow = canShowMIMEType(toString(mimeType));
2568
2569     return S_OK;
2570 }
2571
2572 bool WebView::canShowMIMEType(const String& mimeType)
2573 {
2574     Frame* coreFrame = core(m_mainFrame);
2575     bool allowPlugins = coreFrame && coreFrame->loader().subframeLoader().allowPlugins(NotAboutToInstantiatePlugin);
2576
2577     bool canShow = MIMETypeRegistry::isSupportedImageMIMEType(mimeType)
2578         || MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType)
2579         || MIMETypeRegistry::isSupportedMediaMIMEType(mimeType);
2580
2581     if (!canShow && m_page) {
2582         canShow = (m_page->pluginData().supportsMimeType(mimeType, PluginData::AllPlugins) && allowPlugins)
2583             || m_page->pluginData().supportsMimeType(mimeType, PluginData::OnlyApplicationPlugins);
2584     }
2585
2586     if (!canShow)
2587         canShow = shouldUseEmbeddedView(mimeType);
2588
2589     return canShow;
2590 }
2591
2592 HRESULT WebView::canShowMIMETypeAsHTML(/* [in] */ BSTR mimeType, /* [retval][out] */ BOOL* canShow)
2593 {
2594     if (!canShow)
2595         return E_POINTER;
2596
2597     *canShow = canShowMIMETypeAsHTML(toString(mimeType));
2598
2599     return S_OK;
2600 }
2601
2602 bool WebView::canShowMIMETypeAsHTML(const String& /*mimeType*/)
2603 {
2604     // FIXME
2605     notImplemented();
2606     return true;
2607 }
2608
2609 HRESULT STDMETHODCALLTYPE WebView::MIMETypesShownAsHTML( 
2610     /* [retval][out] */ IEnumVARIANT** /*enumVariant*/)
2611 {
2612     ASSERT_NOT_REACHED();
2613     return E_NOTIMPL;
2614 }
2615
2616 HRESULT STDMETHODCALLTYPE WebView::setMIMETypesShownAsHTML( 
2617         /* [size_is][in] */ BSTR* /*mimeTypes*/,
2618         /* [in] */ int /*cMimeTypes*/)
2619 {
2620     ASSERT_NOT_REACHED();
2621     return E_NOTIMPL;
2622 }
2623
2624 HRESULT STDMETHODCALLTYPE WebView::URLFromPasteboard( 
2625     /* [in] */ IDataObject* /*pasteboard*/,
2626     /* [retval][out] */ BSTR* /*url*/)
2627 {
2628     ASSERT_NOT_REACHED();
2629     return E_NOTIMPL;
2630 }
2631
2632 HRESULT STDMETHODCALLTYPE WebView::URLTitleFromPasteboard( 
2633     /* [in] */ IDataObject* /*pasteboard*/,
2634     /* [retval][out] */ BSTR* /*urlTitle*/)
2635 {
2636     ASSERT_NOT_REACHED();
2637     return E_NOTIMPL;
2638 }
2639
2640 static void WebKitSetApplicationCachePathIfNecessary()
2641 {
2642     static bool initialized = false;
2643     if (initialized)
2644         return;
2645
2646     String path = localUserSpecificStorageDirectory();
2647
2648 #if USE(CF)
2649     RetainPtr<CFPropertyListRef> cacheDirectoryPreference = adoptCF(CFPreferencesCopyAppValue(WebKitLocalCacheDefaultsKey, kCFPreferencesCurrentApplication));
2650     if (cacheDirectoryPreference && (CFStringGetTypeID() == CFGetTypeID(cacheDirectoryPreference.get())))
2651         path = static_cast<CFStringRef>(cacheDirectoryPreference.get());
2652 #endif
2653
2654     if (!path.isNull())
2655         cacheStorage().setCacheDirectory(path);
2656
2657     initialized = true;
2658 }
2659
2660 bool WebView::shouldInitializeTrackPointHack()
2661 {
2662     static bool shouldCreateScrollbars;
2663     static bool hasRunTrackPointCheck;
2664
2665     if (hasRunTrackPointCheck)
2666         return shouldCreateScrollbars;
2667
2668     hasRunTrackPointCheck = true;
2669     const WCHAR trackPointKeys[][50] = { L"Software\\Lenovo\\TrackPoint",
2670         L"Software\\Lenovo\\UltraNav",
2671         L"Software\\Alps\\Apoint\\TrackPoint",
2672         L"Software\\Synaptics\\SynTPEnh\\UltraNavUSB",
2673         L"Software\\Synaptics\\SynTPEnh\\UltraNavPS2" };
2674
2675     for (int i = 0; i < 5; ++i) {
2676         HKEY trackPointKey;
2677         int readKeyResult = ::RegOpenKeyExW(HKEY_CURRENT_USER, trackPointKeys[i], 0, KEY_READ, &trackPointKey);
2678         ::RegCloseKey(trackPointKey);
2679         if (readKeyResult == ERROR_SUCCESS) {
2680             shouldCreateScrollbars = true;
2681             return shouldCreateScrollbars;
2682         }
2683     }
2684
2685     return shouldCreateScrollbars;
2686 }
2687     
2688 HRESULT STDMETHODCALLTYPE WebView::initWithFrame( 
2689     /* [in] */ RECT frame,
2690     /* [in] */ BSTR frameName,
2691     /* [in] */ BSTR groupName)
2692 {
2693     HRESULT hr = S_OK;
2694
2695     if (m_viewWindow)
2696         return E_FAIL;
2697
2698     registerWebViewWindowClass();
2699
2700     m_viewWindow = CreateWindowEx(0, kWebViewWindowClassName, 0, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
2701         frame.left, frame.top, frame.right - frame.left, frame.bottom - frame.top, m_hostWindow ? m_hostWindow : HWND_MESSAGE, 0, gInstance, 0);
2702     ASSERT(::IsWindow(m_viewWindow));
2703
2704     if (shouldInitializeTrackPointHack()) {
2705         // If we detected a registry key belonging to a TrackPoint driver, then create fake trackpoint
2706         // scrollbars, so the WebView will receive WM_VSCROLL and WM_HSCROLL messages. We create one
2707         // vertical scrollbar and one horizontal to allow for receiving both types of messages.
2708         ::CreateWindowW(L"SCROLLBAR", L"FAKETRACKPOINTHSCROLLBAR", WS_CHILD | WS_VISIBLE | SBS_HORZ, 0, 0, 0, 0, m_viewWindow, 0, gInstance, 0);
2709         ::CreateWindowW(L"SCROLLBAR", L"FAKETRACKPOINTVSCROLLBAR", WS_CHILD | WS_VISIBLE | SBS_VERT, 0, 0, 0, 0, m_viewWindow, 0, gInstance, 0);
2710     }
2711
2712     hr = registerDragDrop();
2713     if (FAILED(hr))
2714         return hr;
2715
2716     WebPreferences* sharedPreferences = WebPreferences::sharedStandardPreferences();
2717     sharedPreferences->willAddToWebView();
2718     m_preferences = sharedPreferences;
2719
2720     static bool didOneTimeInitialization;
2721     if (!didOneTimeInitialization) {
2722 #if !LOG_DISABLED
2723         initializeLoggingChannelsIfNecessary();
2724 #endif // !LOG_DISABLED
2725
2726         // Initialize our platform strategies first before invoking the rest
2727         // of the initialization code which may depend on the strategies.
2728         WebPlatformStrategies::initialize();
2729
2730 #if ENABLE(SQL_DATABASE)
2731         WebKitInitializeWebDatabasesIfNecessary();
2732 #endif
2733         WebKitSetApplicationCachePathIfNecessary();
2734         Settings::setDefaultMinDOMTimerInterval(0.004);
2735
2736         didOneTimeInitialization = true;
2737      }
2738
2739 #if USE(SAFARI_THEME)
2740     BOOL shouldPaintNativeControls;
2741     if (SUCCEEDED(m_preferences->shouldPaintNativeControls(&shouldPaintNativeControls)))
2742         Settings::setShouldPaintNativeControls(shouldPaintNativeControls);
2743 #endif
2744
2745     BOOL useHighResolutionTimer;
2746     if (SUCCEEDED(m_preferences->shouldUseHighResolutionTimers(&useHighResolutionTimer)))
2747         Settings::setShouldUseHighResolutionTimers(useHighResolutionTimer);
2748
2749 #if ENABLE(INSPECTOR)
2750     m_inspectorClient = new WebInspectorClient(this);
2751 #endif // ENABLE(INSPECTOR)
2752
2753     Page::PageClients pageClients;
2754     pageClients.chromeClient = new WebChromeClient(this);
2755     pageClients.contextMenuClient = new WebContextMenuClient(this);
2756     pageClients.editorClient = new WebEditorClient(this);
2757     pageClients.dragClient = new WebDragClient(this);
2758 #if ENABLE(INSPECTOR)
2759     pageClients.inspectorClient = m_inspectorClient;
2760 #endif // ENABLE(INSPECTOR)
2761     pageClients.loaderClientForMainFrame = new WebFrameLoaderClient;
2762     pageClients.progressTrackerClient = static_cast<WebFrameLoaderClient*>(pageClients.loaderClientForMainFrame);
2763
2764     m_page = new Page(pageClients);
2765     provideGeolocationTo(m_page, new WebGeolocationClient(this));
2766
2767     unsigned layoutMilestones = DidFirstLayout | DidFirstVisuallyNonEmptyLayout;
2768     m_page->addLayoutMilestones(static_cast<LayoutMilestones>(layoutMilestones));
2769
2770     BString localStoragePath;
2771     if (SUCCEEDED(m_preferences->localStorageDatabasePath(&localStoragePath)))
2772         m_page->settings().setLocalStorageDatabasePath(toString(localStoragePath));
2773
2774     if (m_uiDelegate) {
2775         BString path;
2776         if (SUCCEEDED(m_uiDelegate->ftpDirectoryTemplatePath(this, &path)))
2777             m_page->settings().setFTPDirectoryTemplatePath(toString(path));
2778     }
2779
2780     WebFrame* webFrame = WebFrame::createInstance();
2781     webFrame->initWithWebView(this, m_page);
2782     static_cast<WebFrameLoaderClient&>(m_page->mainFrame().loader().client()).setWebFrame(webFrame);
2783     m_mainFrame = webFrame;
2784     webFrame->Release(); // The WebFrame is owned by the Frame, so release our reference to it.
2785
2786     m_page->mainFrame().tree().setName(toString(frameName));
2787     m_page->mainFrame().init();
2788     setGroupName(groupName);
2789
2790     addToAllWebViewsSet();
2791
2792     #pragma warning(suppress: 4244)
2793     SetWindowLongPtr(m_viewWindow, 0, (LONG_PTR)this);
2794     ShowWindow(m_viewWindow, SW_SHOW);
2795
2796     initializeToolTipWindow();
2797     windowAncestryDidChange();
2798
2799     IWebNotificationCenter* notifyCenter = WebNotificationCenter::defaultCenterInternal();
2800     notifyCenter->addObserver(this, WebPreferences::webPreferencesChangedNotification(), static_cast<IWebPreferences*>(m_preferences.get()));
2801     m_preferences->postPreferencesChangesNotification();
2802
2803     setSmartInsertDeleteEnabled(TRUE);
2804     return hr;
2805 }
2806
2807 static bool initCommonControls()
2808 {
2809     static bool haveInitialized = false;
2810     if (haveInitialized)
2811         return true;
2812
2813     INITCOMMONCONTROLSEX init;
2814     init.dwSize = sizeof(init);
2815     init.dwICC = ICC_TREEVIEW_CLASSES;
2816     haveInitialized = !!::InitCommonControlsEx(&init);
2817     return haveInitialized;
2818 }
2819
2820 void WebView::initializeToolTipWindow()
2821 {
2822     if (!initCommonControls())
2823         return;
2824
2825     m_toolTipHwnd = CreateWindowEx(WS_EX_TRANSPARENT, TOOLTIPS_CLASS, 0, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
2826                                    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
2827                                    m_viewWindow, 0, 0, 0);
2828     if (!m_toolTipHwnd)
2829         return;
2830
2831     TOOLINFO info = {0};
2832     info.cbSize = sizeof(info);
2833     info.uFlags = TTF_IDISHWND | TTF_SUBCLASS ;
2834     info.uId = reinterpret_cast<UINT_PTR>(m_viewWindow);
2835
2836     ::SendMessage(m_toolTipHwnd, TTM_ADDTOOL, 0, reinterpret_cast<LPARAM>(&info));
2837     ::SendMessage(m_toolTipHwnd, TTM_SETMAXTIPWIDTH, 0, maxToolTipWidth);
2838
2839     ::SetWindowPos(m_toolTipHwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
2840 }
2841
2842 void WebView::setToolTip(const String& toolTip)
2843 {
2844     if (!m_toolTipHwnd)
2845         return;
2846
2847     if (toolTip == m_toolTip)
2848         return;
2849
2850     m_toolTip = toolTip;
2851
2852     if (!m_toolTip.isEmpty()) {
2853         TOOLINFO info = {0};
2854         info.cbSize = sizeof(info);
2855         info.uFlags = TTF_IDISHWND;
2856         info.uId = reinterpret_cast<UINT_PTR>(m_viewWindow);
2857         Vector<UChar> toolTipCharacters = m_toolTip.charactersWithNullTermination(); // Retain buffer long enough to make the SendMessage call
2858         info.lpszText = const_cast<UChar*>(toolTipCharacters.data());
2859         ::SendMessage(m_toolTipHwnd, TTM_UPDATETIPTEXT, 0, reinterpret_cast<LPARAM>(&info));
2860     }
2861
2862     ::SendMessage(m_toolTipHwnd, TTM_ACTIVATE, !m_toolTip.isEmpty(), 0);
2863 }
2864
2865 HRESULT WebView::notifyDidAddIcon(IWebNotification* notification)
2866 {
2867     COMPtr<IPropertyBag> propertyBag;
2868     HRESULT hr = notification->userInfo(&propertyBag);
2869     if (FAILED(hr))
2870         return hr;
2871     if (!propertyBag)
2872         return E_FAIL;
2873
2874     COMVariant iconUserInfoURL;
2875     hr = propertyBag->Read(WebIconDatabase::iconDatabaseNotificationUserInfoURLKey(), &iconUserInfoURL, 0);
2876     if (FAILED(hr))
2877         return hr;
2878
2879     if (iconUserInfoURL.variantType() != VT_BSTR)
2880         return E_FAIL;
2881
2882     String mainFrameURL;
2883     if (m_mainFrame)
2884         mainFrameURL = m_mainFrame->url().string();
2885
2886     if (!mainFrameURL.isEmpty() && mainFrameURL == toString(V_BSTR(&iconUserInfoURL)))
2887         dispatchDidReceiveIconFromWebFrame(m_mainFrame);
2888
2889     return hr;
2890 }
2891
2892 void WebView::registerForIconNotification(bool listen)
2893 {
2894     IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal();
2895     if (listen)
2896         nc->addObserver(this, WebIconDatabase::iconDatabaseDidAddIconNotification(), 0);
2897     else
2898         nc->removeObserver(this, WebIconDatabase::iconDatabaseDidAddIconNotification(), 0);
2899 }
2900
2901 void WebView::dispatchDidReceiveIconFromWebFrame(WebFrame* frame)
2902 {
2903     registerForIconNotification(false);
2904
2905     if (m_frameLoadDelegate) {
2906         String str = frame->url().string();
2907
2908         IntSize sz(16, 16);
2909
2910         BitmapInfo bmInfo = BitmapInfo::create(sz);
2911
2912         HBITMAP hBitmap = 0;
2913
2914         Image* icon = iconDatabase().synchronousIconForPageURL(str, sz);
2915
2916         if (icon && icon->width()) {
2917             HWndDC dc(0);
2918             hBitmap = CreateDIBSection(dc, &bmInfo, DIB_RGB_COLORS, 0, 0, 0);
2919             icon->getHBITMAPOfSize(hBitmap, &sz);
2920         }
2921
2922         HRESULT hr = m_frameLoadDelegate->didReceiveIcon(this, (OLE_HANDLE)hBitmap, frame);
2923         if (hr == E_NOTIMPL)
2924             DeleteObject(hBitmap);
2925     }
2926 }
2927
2928 HRESULT WebView::setAccessibilityDelegate(
2929     /* [in] */ IAccessibilityDelegate* d)
2930 {
2931     m_accessibilityDelegate = d;
2932     return S_OK;
2933 }
2934
2935 HRESULT WebView::accessibilityDelegate(
2936     /* [out][retval] */ IAccessibilityDelegate** d)
2937 {
2938     if (!m_accessibilityDelegate)
2939         return E_POINTER;
2940
2941     return m_accessibilityDelegate.copyRefTo(d);
2942 }
2943
2944 HRESULT STDMETHODCALLTYPE WebView::setUIDelegate( 
2945     /* [in] */ IWebUIDelegate* d)
2946 {
2947     m_uiDelegate = d;
2948
2949     if (m_uiDelegatePrivate)
2950         m_uiDelegatePrivate = 0;
2951
2952     if (d) {
2953         if (FAILED(d->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&m_uiDelegatePrivate)))
2954             m_uiDelegatePrivate = 0;
2955     }
2956
2957     return S_OK;
2958 }
2959
2960 HRESULT STDMETHODCALLTYPE WebView::uiDelegate( 
2961     /* [out][retval] */ IWebUIDelegate** d)
2962 {
2963     if (!m_uiDelegate)
2964         return E_FAIL;
2965
2966     return m_uiDelegate.copyRefTo(d);
2967 }
2968
2969 HRESULT STDMETHODCALLTYPE WebView::setResourceLoadDelegate( 
2970     /* [in] */ IWebResourceLoadDelegate* d)
2971 {
2972     m_resourceLoadDelegate = d;
2973     return S_OK;
2974 }
2975
2976 HRESULT STDMETHODCALLTYPE WebView::resourceLoadDelegate( 
2977     /* [out][retval] */ IWebResourceLoadDelegate** d)
2978 {
2979     if (!m_resourceLoadDelegate)
2980         return E_FAIL;
2981
2982     return m_resourceLoadDelegate.copyRefTo(d);
2983 }
2984
2985 HRESULT STDMETHODCALLTYPE WebView::setDownloadDelegate( 
2986     /* [in] */ IWebDownloadDelegate* d)
2987 {
2988     m_downloadDelegate = d;
2989     return S_OK;
2990 }
2991
2992 HRESULT STDMETHODCALLTYPE WebView::downloadDelegate( 
2993     /* [out][retval] */ IWebDownloadDelegate** d)
2994 {
2995     if (!m_downloadDelegate)
2996         return E_FAIL;
2997
2998     return m_downloadDelegate.copyRefTo(d);
2999 }
3000
3001 HRESULT STDMETHODCALLTYPE WebView::setFrameLoadDelegate( 
3002     /* [in] */ IWebFrameLoadDelegate* d)
3003 {
3004     m_frameLoadDelegate = d;
3005     return S_OK;
3006 }
3007
3008 HRESULT STDMETHODCALLTYPE WebView::frameLoadDelegate( 
3009     /* [out][retval] */ IWebFrameLoadDelegate** d)
3010 {
3011     if (!m_frameLoadDelegate)
3012         return E_FAIL;
3013
3014     return m_frameLoadDelegate.copyRefTo(d);
3015 }
3016
3017 HRESULT STDMETHODCALLTYPE WebView::setPolicyDelegate( 
3018     /* [in] */ IWebPolicyDelegate* d)
3019 {
3020     m_policyDelegate = d;
3021     return S_OK;
3022 }
3023
3024 HRESULT STDMETHODCALLTYPE WebView::policyDelegate( 
3025     /* [out][retval] */ IWebPolicyDelegate** d)
3026 {
3027     if (!m_policyDelegate)
3028         return E_FAIL;
3029     return m_policyDelegate.copyRefTo(d);
3030 }
3031
3032 HRESULT STDMETHODCALLTYPE WebView::mainFrame( 
3033     /* [out][retval] */ IWebFrame** frame)
3034 {
3035     if (!frame) {
3036         ASSERT_NOT_REACHED();
3037         return E_POINTER;
3038     }
3039
3040     *frame = m_mainFrame;
3041     if (!m_mainFrame)
3042         return E_FAIL;
3043
3044     m_mainFrame->AddRef();
3045     return S_OK;
3046 }
3047
3048 HRESULT STDMETHODCALLTYPE WebView::focusedFrame( 
3049     /* [out][retval] */ IWebFrame** frame)
3050 {
3051     if (!frame) {
3052         ASSERT_NOT_REACHED();
3053         return E_POINTER;
3054     }
3055
3056     *frame = 0;
3057     Frame* f = m_page->focusController().focusedFrame();
3058     if (!f)
3059         return E_FAIL;
3060
3061     WebFrame* webFrame = kit(f);
3062     if (!webFrame)
3063         return E_FAIL;
3064
3065     return webFrame->QueryInterface(IID_IWebFrame, (void**) frame);
3066 }
3067
3068 HRESULT STDMETHODCALLTYPE WebView::backForwardList( 
3069     /* [out][retval] */ IWebBackForwardList** list)
3070 {
3071     if (!m_useBackForwardList)
3072         return E_FAIL;
3073  
3074     *list = WebBackForwardList::createInstance(static_cast<WebCore::BackForwardList*>(m_page->backForward().client()));
3075
3076     return S_OK;
3077 }
3078
3079 HRESULT STDMETHODCALLTYPE WebView::setMaintainsBackForwardList( 
3080     /* [in] */ BOOL flag)
3081 {
3082     m_useBackForwardList = !!flag;
3083     return S_OK;
3084 }
3085
3086 HRESULT STDMETHODCALLTYPE WebView::goBack( 
3087     /* [retval][out] */ BOOL* succeeded)
3088 {
3089     *succeeded = m_page->backForward().goBack();
3090     return S_OK;
3091 }
3092
3093 HRESULT STDMETHODCALLTYPE WebView::goForward( 
3094     /* [retval][out] */ BOOL* succeeded)
3095 {
3096     *succeeded = m_page->backForward().goForward();
3097     return S_OK;
3098 }
3099
3100 HRESULT STDMETHODCALLTYPE WebView::goToBackForwardItem( 
3101     /* [in] */ IWebHistoryItem* item,
3102     /* [retval][out] */ BOOL* succeeded)
3103 {
3104     *succeeded = FALSE;
3105
3106     COMPtr<WebHistoryItem> webHistoryItem;
3107     HRESULT hr = item->QueryInterface(&webHistoryItem);
3108     if (FAILED(hr))
3109         return hr;
3110
3111     m_page->goToItem(webHistoryItem->historyItem(), FrameLoadTypeIndexedBackForward);
3112     *succeeded = TRUE;
3113
3114     return S_OK;
3115 }
3116
3117 HRESULT STDMETHODCALLTYPE WebView::setTextSizeMultiplier( 
3118     /* [in] */ float multiplier)
3119 {
3120     if (!m_mainFrame)
3121         return E_FAIL;
3122     setZoomMultiplier(multiplier, true);
3123     return S_OK;
3124 }
3125
3126 HRESULT STDMETHODCALLTYPE WebView::setPageSizeMultiplier( 
3127     /* [in] */ float multiplier)
3128 {
3129     if (!m_mainFrame)
3130         return E_FAIL;
3131     setZoomMultiplier(multiplier, false);
3132     return S_OK;
3133 }
3134
3135 void WebView::setZoomMultiplier(float multiplier, bool isTextOnly)
3136 {
3137     m_zoomMultiplier = multiplier;
3138     m_zoomsTextOnly = isTextOnly;
3139
3140     if (Frame* coreFrame = core(m_mainFrame)) {
3141         if (m_zoomsTextOnly)
3142             coreFrame->setPageAndTextZoomFactors(1, multiplier);
3143         else
3144             coreFrame->setPageAndTextZoomFactors(multiplier, 1);
3145     }
3146 }
3147
3148 HRESULT STDMETHODCALLTYPE WebView::textSizeMultiplier( 
3149     /* [retval][out] */ float* multiplier)
3150 {
3151     *multiplier = zoomMultiplier(true);
3152     return S_OK;
3153 }
3154
3155 HRESULT STDMETHODCALLTYPE WebView::pageSizeMultiplier( 
3156     /* [retval][out] */ float* multiplier)
3157 {
3158     *multiplier = zoomMultiplier(false);
3159     return S_OK;
3160 }
3161
3162 float WebView::zoomMultiplier(bool isTextOnly)
3163 {
3164     if (isTextOnly != m_zoomsTextOnly)
3165         return 1.0f;
3166     return m_zoomMultiplier;
3167 }
3168
3169 HRESULT STDMETHODCALLTYPE WebView::setApplicationNameForUserAgent( 
3170     /* [in] */ BSTR applicationName)
3171 {
3172     m_applicationName = toString(applicationName);
3173     m_userAgentStandard = String();
3174     return S_OK;
3175 }
3176
3177 HRESULT STDMETHODCALLTYPE WebView::applicationNameForUserAgent( 
3178     /* [retval][out] */ BSTR* applicationName)
3179 {
3180     *applicationName = BString(m_applicationName).release();
3181     if (!*applicationName && m_applicationName.length())
3182         return E_OUTOFMEMORY;
3183     return S_OK;
3184 }
3185
3186 HRESULT STDMETHODCALLTYPE WebView::setCustomUserAgent( 
3187     /* [in] */ BSTR userAgentString)
3188 {
3189     m_userAgentOverridden = userAgentString;
3190     m_userAgentCustom = toString(userAgentString);
3191     return S_OK;
3192 }
3193
3194 HRESULT STDMETHODCALLTYPE WebView::customUserAgent( 
3195     /* [retval][out] */ BSTR* userAgentString)
3196 {
3197     *userAgentString = 0;
3198     if (!m_userAgentOverridden)
3199         return S_OK;
3200     *userAgentString = BString(m_userAgentCustom).release();
3201     if (!*userAgentString && m_userAgentCustom.length())
3202         return E_OUTOFMEMORY;
3203     return S_OK;
3204 }
3205
3206 HRESULT STDMETHODCALLTYPE WebView::userAgentForURL( 
3207     /* [in] */ BSTR url,
3208     /* [retval][out] */ BSTR* userAgent)
3209 {
3210     String userAgentString = userAgentForKURL(MarshallingHelpers::BSTRToKURL(url));
3211     *userAgent = BString(userAgentString).release();
3212     if (!*userAgent && userAgentString.length())
3213         return E_OUTOFMEMORY;
3214     return S_OK;
3215 }
3216
3217 HRESULT STDMETHODCALLTYPE WebView::supportsTextEncoding( 
3218     /* [retval][out] */ BOOL* supports)
3219 {
3220     *supports = TRUE;
3221     return S_OK;
3222 }
3223
3224 HRESULT STDMETHODCALLTYPE WebView::setCustomTextEncodingName( 
3225     /* [in] */ BSTR encodingName)
3226 {
3227     if (!m_mainFrame)
3228         return E_FAIL;
3229
3230     HRESULT hr;
3231     BString oldEncoding;
3232     hr = customTextEncodingName(&oldEncoding);
3233     if (FAILED(hr))
3234         return hr;
3235
3236     if (oldEncoding != encodingName && (!oldEncoding || !encodingName || wcscmp(oldEncoding, encodingName))) {
3237         if (Frame* coreFrame = core(m_mainFrame))
3238             coreFrame->loader().reloadWithOverrideEncoding(toString(encodingName));
3239     }
3240
3241     return S_OK;
3242 }
3243
3244 HRESULT STDMETHODCALLTYPE WebView::customTextEncodingName( 
3245     /* [retval][out] */ BSTR* encodingName)
3246 {
3247     HRESULT hr = S_OK;
3248     COMPtr<IWebDataSource> dataSource;
3249     COMPtr<WebDataSource> dataSourceImpl;
3250     *encodingName = 0;
3251
3252     if (!m_mainFrame)
3253         return E_FAIL;
3254
3255     if (FAILED(m_mainFrame->provisionalDataSource(&dataSource)) || !dataSource) {
3256         hr = m_mainFrame->dataSource(&dataSource);
3257         if (FAILED(hr) || !dataSource)
3258             return hr;
3259     }
3260
3261     hr = dataSource->QueryInterface(IID_WebDataSource, (void**)&dataSourceImpl);
3262     if (FAILED(hr))
3263         return hr;
3264
3265     BString str = dataSourceImpl->documentLoader()->overrideEncoding();
3266     if (FAILED(hr))
3267         return hr;
3268
3269     if (!*encodingName)
3270         *encodingName = BString(m_overrideEncoding).release();
3271
3272     if (!*encodingName && m_overrideEncoding.length())
3273         return E_OUTOFMEMORY;
3274
3275     return S_OK;
3276 }
3277
3278 HRESULT STDMETHODCALLTYPE WebView::setMediaStyle( 
3279     /* [in] */ BSTR /*media*/)
3280 {
3281     ASSERT_NOT_REACHED();
3282     return E_NOTIMPL;
3283 }
3284
3285 HRESULT STDMETHODCALLTYPE WebView::mediaStyle( 
3286     /* [retval][out] */ BSTR* /*media*/)
3287 {
3288     ASSERT_NOT_REACHED();
3289     return E_NOTIMPL;
3290 }
3291
3292 HRESULT STDMETHODCALLTYPE WebView::stringByEvaluatingJavaScriptFromString( 
3293     /* [in] */ BSTR script, // assumes input does not have "JavaScript" at the begining.
3294     /* [retval][out] */ BSTR* result)
3295 {
3296     if (!result) {
3297         ASSERT_NOT_REACHED();
3298         return E_POINTER;
3299     }
3300
3301     *result = 0;
3302
3303     Frame* coreFrame = core(m_mainFrame);
3304     if (!coreFrame)
3305         return E_FAIL;
3306
3307     JSC::JSValue scriptExecutionResult = coreFrame->script().executeScript(WTF::String(script), true).jsValue();
3308     if (!scriptExecutionResult)
3309         return E_FAIL;
3310     else if (scriptExecutionResult.isString()) {
3311         JSC::ExecState* exec = coreFrame->script().globalObject(mainThreadNormalWorld())->globalExec();
3312         JSC::JSLockHolder lock(exec);
3313         *result = BString(scriptExecutionResult.getString(exec));
3314     }
3315
3316     return S_OK;
3317 }
3318
3319 HRESULT STDMETHODCALLTYPE WebView::windowScriptObject( 
3320     /* [retval][out] */ IWebScriptObject** /*webScriptObject*/)
3321 {
3322     ASSERT_NOT_REACHED();
3323     return E_NOTIMPL;
3324 }
3325
3326 HRESULT STDMETHODCALLTYPE WebView::setPreferences( 
3327     /* [in] */ IWebPreferences* prefs)
3328 {
3329     if (!prefs)
3330         prefs = WebPreferences::sharedStandardPreferences();
3331
3332     if (m_preferences == prefs)
3333         return S_OK;
3334
3335     COMPtr<WebPreferences> webPrefs(Query, prefs);
3336     if (!webPrefs)
3337         return E_NOINTERFACE;
3338     webPrefs->willAddToWebView();
3339
3340     COMPtr<WebPreferences> oldPrefs = m_preferences;
3341
3342     IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal();
3343     nc->removeObserver(this, WebPreferences::webPreferencesChangedNotification(), static_cast<IWebPreferences*>(m_preferences.get()));
3344
3345     BString identifier;
3346     oldPrefs->identifier(&identifier);
3347     oldPrefs->didRemoveFromWebView();
3348     oldPrefs = 0; // Make sure we release the reference, since WebPreferences::removeReferenceForIdentifier will check for last reference to WebPreferences
3349
3350     m_preferences = webPrefs;
3351
3352     if (identifier)
3353         WebPreferences::removeReferenceForIdentifier(identifier);
3354
3355     nc->addObserver(this, WebPreferences::webPreferencesChangedNotification(), static_cast<IWebPreferences*>(m_preferences.get()));
3356
3357     m_preferences->postPreferencesChangesNotification();
3358
3359     return S_OK;
3360 }
3361
3362 HRESULT STDMETHODCALLTYPE WebView::preferences( 
3363     /* [retval][out] */ IWebPreferences** prefs)
3364 {
3365     if (!prefs)
3366         return E_POINTER;
3367     *prefs = m_preferences.get();
3368     if (m_preferences)
3369         m_preferences->AddRef();
3370     return S_OK;
3371 }
3372
3373 HRESULT STDMETHODCALLTYPE WebView::setPreferencesIdentifier( 
3374     /* [in] */ BSTR /*anIdentifier*/)
3375 {
3376     ASSERT_NOT_REACHED();
3377     return E_NOTIMPL;
3378 }
3379
3380 HRESULT STDMETHODCALLTYPE WebView::preferencesIdentifier( 
3381     /* [retval][out] */ BSTR* /*anIdentifier*/)
3382 {
3383     ASSERT_NOT_REACHED();
3384     return E_NOTIMPL;
3385 }
3386
3387 static void systemParameterChanged(WPARAM parameter)
3388 {
3389 #if USE(CG)
3390     if (parameter == SPI_SETFONTSMOOTHING || parameter == SPI_SETFONTSMOOTHINGTYPE || parameter == SPI_SETFONTSMOOTHINGCONTRAST || parameter == SPI_SETFONTSMOOTHINGORIENTATION)
3391         wkSystemFontSmoothingChanged();
3392 #endif
3393 }
3394
3395 void WebView::windowReceivedMessage(HWND, UINT message, WPARAM wParam, LPARAM)
3396 {
3397     switch (message) {
3398     case WM_NCACTIVATE:
3399         updateActiveStateSoon();
3400         if (!wParam)
3401             deleteBackingStoreSoon();
3402         break;
3403     case WM_SETTINGCHANGE:
3404         systemParameterChanged(wParam);
3405         break;
3406     }
3407 }
3408
3409 void WebView::updateActiveStateSoon() const
3410 {
3411     // This function is called while processing the WM_NCACTIVATE message.
3412     // While processing WM_NCACTIVATE when we are being deactivated, GetActiveWindow() will
3413     // still return our window. If we were to call updateActiveState() in that case, we would
3414     // wrongly think that we are still the active window. To work around this, we update our
3415     // active state after a 0-delay timer fires, at which point GetActiveWindow() will return
3416     // the newly-activated window.
3417
3418     SetTimer(m_viewWindow, UpdateActiveStateTimer, 0, 0);
3419 }
3420
3421 void WebView::deleteBackingStoreSoon()
3422 {
3423     if (pendingDeleteBackingStoreSet.size() > 2) {
3424         Vector<WebView*> views;
3425         HashSet<WebView*>::iterator end = pendingDeleteBackingStoreSet.end();
3426         for (HashSet<WebView*>::iterator it = pendingDeleteBackingStoreSet.begin(); it != end; ++it)
3427             views.append(*it);
3428         for (int i = 0; i < views.size(); ++i)
3429             views[i]->deleteBackingStore();
3430         ASSERT(pendingDeleteBackingStoreSet.isEmpty());
3431     }
3432
3433     pendingDeleteBackingStoreSet.add(this);
3434     m_deleteBackingStoreTimerActive = true;
3435     SetTimer(m_viewWindow, DeleteBackingStoreTimer, delayBeforeDeletingBackingStoreMsec, 0);
3436 }
3437
3438 void WebView::cancelDeleteBackingStoreSoon()
3439 {
3440     if (!m_deleteBackingStoreTimerActive)
3441         return;
3442     pendingDeleteBackingStoreSet.remove(this);
3443     m_deleteBackingStoreTimerActive = false;
3444     KillTimer(m_viewWindow, DeleteBackingStoreTimer);
3445 }
3446
3447 HRESULT STDMETHODCALLTYPE WebView::setHostWindow( 
3448     /* [in] */ OLE_HANDLE oleWindow)
3449 {
3450     HWND window = (HWND)(ULONG64)oleWindow;
3451     if (m_viewWindow) {
3452         if (window)
3453             SetParent(m_viewWindow, window);
3454         else if (!isBeingDestroyed()) {
3455             // Turn the WebView into a message-only window so it will no longer be a child of the
3456             // old host window and will be hidden from screen. We only do this when
3457             // isBeingDestroyed() is false because doing this while handling WM_DESTROY can leave
3458             // m_viewWindow in a weird state (see <http://webkit.org/b/29337>).
3459             SetParent(m_viewWindow, HWND_MESSAGE);
3460         }
3461     }
3462
3463     m_hostWindow = window;
3464
3465     windowAncestryDidChange();
3466
3467     return S_OK;
3468 }
3469
3470 HRESULT STDMETHODCALLTYPE WebView::hostWindow( 
3471     /* [retval][out] */ OLE_HANDLE* window)
3472 {
3473     *window = (OLE_HANDLE)(ULONG64)m_hostWindow;
3474     return S_OK;
3475 }
3476
3477
3478 static Frame *incrementFrame(Frame *curr, bool forward, bool wrapFlag)
3479 {
3480     return forward
3481         ? curr->tree().traverseNextWithWrap(wrapFlag)
3482         : curr->tree().traversePreviousWithWrap(wrapFlag);
3483 }
3484
3485 HRESULT STDMETHODCALLTYPE WebView::searchFor( 
3486     /* [in] */ BSTR str,
3487     /* [in] */ BOOL forward,
3488     /* [in] */ BOOL caseFlag,
3489     /* [in] */ BOOL wrapFlag,
3490     /* [retval][out] */ BOOL* found)
3491 {
3492     if (!found)
3493         return E_INVALIDARG;
3494     
3495     if (!m_page)
3496         return E_UNEXPECTED;
3497
3498     if (!str || !SysStringLen(str))
3499         return E_INVALIDARG;
3500
3501     FindOptions options = (caseFlag ? 0 : CaseInsensitive) | (forward ? 0 : Backwards) | (wrapFlag ? WrapAround : 0);
3502     *found = m_page->findString(toString(str), options);
3503     return S_OK;
3504 }
3505
3506 bool WebView::active()
3507 {
3508     HWND activeWindow = GetActiveWindow();
3509     if (usesLayeredWindow() && activeWindow == m_viewWindow)
3510         return true;
3511
3512     return (activeWindow && m_topLevelParent == findTopLevelParent(activeWindow));
3513 }
3514
3515 void WebView::updateActiveState()
3516 {
3517     m_page->focusController().setActive(active());
3518 }
3519
3520 HRESULT STDMETHODCALLTYPE WebView::updateFocusedAndActiveState()
3521 {
3522     updateActiveState();
3523
3524     bool active = m_page->focusController().isActive();
3525     Frame& mainFrame = m_page->mainFrame();
3526     Frame& focusedFrame = m_page->focusController().focusedOrMainFrame();
3527     mainFrame.selection().setFocused(active && &mainFrame == &focusedFrame);
3528
3529     return S_OK;
3530 }
3531
3532 HRESULT STDMETHODCALLTYPE WebView::executeCoreCommandByName(BSTR name, BSTR value)
3533 {
3534     m_page->focusController().focusedOrMainFrame().editor().command(toString(name)).execute(toString(value));
3535
3536     return S_OK;
3537 }
3538
3539 HRESULT STDMETHODCALLTYPE WebView::clearMainFrameName()
3540 {
3541     m_page->mainFrame().tree().clearName();
3542
3543     return S_OK;
3544 }
3545
3546 HRESULT STDMETHODCALLTYPE WebView::markAllMatchesForText(
3547     BSTR str, BOOL caseSensitive, BOOL highlight, UINT limit, UINT* matches)
3548 {
3549     if (!matches)
3550         return E_INVALIDARG;
3551
3552     if (!m_page)
3553         return E_UNEXPECTED;
3554
3555     if (!str || !SysStringLen(str))
3556         return E_INVALIDARG;
3557
3558     *matches = m_page->markAllMatchesForText(toString(str), caseSensitive ? TextCaseSensitive : TextCaseInsensitive, highlight, limit);
3559     return S_OK;
3560 }
3561
3562 HRESULT STDMETHODCALLTYPE WebView::unmarkAllTextMatches()
3563 {
3564     if (!m_page)
3565         return E_UNEXPECTED;
3566
3567     m_page->unmarkAllTextMatches();
3568     return S_OK;
3569 }
3570
3571 HRESULT STDMETHODCALLTYPE WebView::rectsForTextMatches(
3572     IEnumTextMatches** pmatches)
3573 {
3574     Vector<IntRect> allRects;
3575     WebCore::Frame* frame = &m_page->mainFrame();
3576     do {
3577         if (Document* document = frame->document()) {
3578             IntRect visibleRect = frame->view()->visibleContentRect();
3579             Vector<IntRect> frameRects = document->markers().renderedRectsForMarkers(DocumentMarker::TextMatch);
3580             IntPoint frameOffset(-frame->view()->scrollOffset().width(), -frame->view()->scrollOffset().height());
3581             frameOffset = frame->view()->convertToContainingWindow(frameOffset);
3582
3583             Vector<IntRect>::iterator end = frameRects.end();
3584             for (Vector<IntRect>::iterator it = frameRects.begin(); it < end; it++) {
3585                 it->intersect(visibleRect);
3586                 it->move(frameOffset.x(), frameOffset.y());
3587                 allRects.append(*it);
3588             }
3589         }
3590         frame = incrementFrame(frame, true, false);
3591     } while (frame);
3592
3593     return createMatchEnumerator(&allRects, pmatches);
3594 }
3595
3596 HRESULT STDMETHODCALLTYPE WebView::generateSelectionImage(BOOL forceWhiteText, OLE_HANDLE* hBitmap)
3597 {
3598     *hBitmap = 0;
3599
3600     WebCore::Frame& frame = m_page->focusController().focusedOrMainFrame();
3601
3602     auto bitmap = imageFromSelection(&frame, forceWhiteText ? TRUE : FALSE);
3603     *hBitmap = static_cast<OLE_HANDLE>(reinterpret_cast<ULONG64>(bitmap.leak()));
3604
3605     return S_OK;
3606 }
3607
3608 HRESULT STDMETHODCALLTYPE WebView::selectionRect(RECT* rc)
3609 {
3610     WebCore::Frame& frame = m_page->focusController().focusedOrMainFrame();
3611
3612     IntRect ir = enclosingIntRect(frame.selection().selectionBounds());
3613     ir = frame.view()->convertToContainingWindow(ir);
3614     ir.move(-frame.view()->scrollOffset().width(), -frame.view()->scrollOffset().height());
3615     rc->left = ir.x();
3616     rc->top = ir.y();
3617     rc->bottom = rc->top + ir.height();
3618     rc->right = rc->left + ir.width();
3619
3620     return S_OK;
3621 }
3622
3623 HRESULT STDMETHODCALLTYPE WebView::registerViewClass( 
3624     /* [in] */ IWebDocumentView* /*view*/,
3625     /* [in] */ IWebDocumentRepresentation* /*representation*/,
3626     /* [in] */ BSTR /*forMIMEType*/)
3627 {
3628     ASSERT_NOT_REACHED();
3629     return E_NOTIMPL;
3630 }
3631
3632 HRESULT STDMETHODCALLTYPE WebView::setGroupName( 
3633         /* [in] */ BSTR groupName)
3634 {
3635     if (!m_page)
3636         return S_OK;
3637     m_page->setGroupName(toString(groupName));
3638     return S_OK;
3639 }
3640     
3641 HRESULT STDMETHODCALLTYPE WebView::groupName( 
3642         /* [retval][out] */ BSTR* groupName)
3643 {
3644     *groupName = 0;
3645     if (!m_page)
3646         return S_OK;
3647     String groupNameString = m_page->groupName();
3648     *groupName = BString(groupNameString).release();
3649     if (!*groupName && groupNameString.length())
3650         return E_OUTOFMEMORY;
3651     return S_OK;
3652 }
3653     
3654 HRESULT STDMETHODCALLTYPE WebView::estimatedProgress( 
3655         /* [retval][out] */ double* estimatedProgress)
3656 {
3657     *estimatedProgress = m_page->progress().estimatedProgress();
3658     return S_OK;
3659 }
3660     
3661 HRESULT STDMETHODCALLTYPE WebView::isLoading( 
3662         /* [retval][out] */ BOOL* isLoading)
3663 {
3664     COMPtr<IWebDataSource> dataSource;
3665     COMPtr<IWebDataSource> provisionalDataSource;
3666
3667     if (!isLoading)
3668         return E_POINTER;
3669
3670     *isLoading = FALSE;
3671
3672     if (!m_mainFrame)
3673         return E_FAIL;
3674
3675     if (SUCCEEDED(m_mainFrame->dataSource(&dataSource)))
3676         dataSource->isLoading(isLoading);
3677
3678     if (*isLoading)
3679         return S_OK;
3680
3681     if (SUCCEEDED(m_mainFrame->provisionalDataSource(&provisionalDataSource)))
3682         provisionalDataSource->isLoading(isLoading);
3683     return S_OK;
3684 }
3685     
3686 HRESULT STDMETHODCALLTYPE WebView::elementAtPoint( 
3687         /* [in] */ LPPOINT point,
3688         /* [retval][out] */ IPropertyBag** elementDictionary)
3689 {
3690     if (!elementDictionary) {
3691         ASSERT_NOT_REACHED();
3692         return E_POINTER;
3693     }
3694
3695     *elementDictionary = 0;
3696
3697     Frame* frame = core(m_mainFrame);
3698     if (!frame)
3699         return E_FAIL;
3700
3701     IntPoint webCorePoint = IntPoint(point->x, point->y);
3702     HitTestResult result = HitTestResult(webCorePoint);
3703     if (frame->contentRenderer())
3704         result = frame->eventHandler().hitTestResultAtPoint(webCorePoint);
3705     *elementDictionary = WebElementPropertyBag::createInstance(result);
3706     return S_OK;
3707 }
3708     
3709 HRESULT STDMETHODCALLTYPE WebView::pasteboardTypesForSelection( 
3710     /* [retval][out] */ IEnumVARIANT** /*enumVariant*/)
3711 {
3712     ASSERT_NOT_REACHED();
3713     return E_NOTIMPL;
3714 }
3715     
3716 HRESULT STDMETHODCALLTYPE WebView::writeSelectionWithPasteboardTypes( 
3717         /* [size_is][in] */ BSTR* /*types*/,
3718         /* [in] */ int /*cTypes*/,
3719         /* [in] */ IDataObject* /*pasteboard*/)
3720 {
3721     ASSERT_NOT_REACHED();
3722     return E_NOTIMPL;
3723 }
3724     
3725 HRESULT STDMETHODCALLTYPE WebView::pasteboardTypesForElement( 
3726     /* [in] */ IPropertyBag* /*elementDictionary*/,
3727     /* [retval][out] */ IEnumVARIANT** /*enumVariant*/)
3728 {
3729     ASSERT_NOT_REACHED();
3730     return E_NOTIMPL;
3731 }
3732     
3733 HRESULT STDMETHODCALLTYPE WebView::writeElement( 
3734         /* [in] */ IPropertyBag* /*elementDictionary*/,
3735         /* [size_is][in] */ BSTR* /*withPasteboardTypes*/,
3736         /* [in] */ int /*cWithPasteboardTypes*/,
3737         /* [in] */ IDataObject* /*pasteboard*/)
3738 {
3739     ASSERT_NOT_REACHED();
3740     return E_NOTIMPL;
3741 }
3742     
3743 HRESULT STDMETHODCALLTYPE WebView::selectedText(
3744         /* [out, retval] */ BSTR* text)
3745 {
3746     if (!text) {
3747         ASSERT_NOT_REACHED();
3748         return E_POINTER;
3749     }
3750
3751     *text = 0;
3752
3753     Frame* focusedFrame = m_page ? &m_page->focusController().focusedOrMainFrame() : 0;
3754     if (!focusedFrame)
3755         return E_FAIL;
3756
3757     String frameSelectedText = focusedFrame->editor().selectedText();
3758     *text = BString(frameSelectedText).release();
3759     if (!*text && frameSelectedText.length())
3760         return E_OUTOFMEMORY;
3761     return S_OK;
3762 }
3763
3764 HRESULT STDMETHODCALLTYPE WebView::centerSelectionInVisibleArea(
3765         /* [in] */ IUnknown* /* sender */)
3766 {
3767     Frame* coreFrame = core(m_mainFrame);
3768     if (!coreFrame)
3769         return E_FAIL;
3770
3771     coreFrame->selection().revealSelection(ScrollAlignment::alignCenterAlways);
3772     return S_OK;
3773 }
3774
3775
3776 HRESULT STDMETHODCALLTYPE WebView::moveDragCaretToPoint( 
3777         /* [in] */ LPPOINT /*point*/)
3778 {
3779     ASSERT_NOT_REACHED();
3780     return E_NOTIMPL;
3781 }
3782     
3783 HRESULT STDMETHODCALLTYPE WebView::removeDragCaret( void)
3784 {
3785     ASSERT_NOT_REACHED();
3786     return E_NOTIMPL;
3787 }
3788     
3789 HRESULT STDMETHODCALLTYPE WebView::setDrawsBackground( 
3790         /* [in] */ BOOL /*drawsBackground*/)
3791 {
3792     ASSERT_NOT_REACHED();
3793     return E_NOTIMPL;
3794 }
3795     
3796 HRESULT STDMETHODCALLTYPE WebView::drawsBackground( 
3797         /* [retval][out] */ BOOL* /*drawsBackground*/)
3798 {
3799     ASSERT_NOT_REACHED();
3800     return E_NOTIMPL;
3801 }
3802     
3803 HRESULT STDMETHODCALLTYPE WebView::setMainFrameURL( 
3804         /* [in] */ BSTR /*urlString*/)
3805 {
3806     ASSERT_NOT_REACHED();
3807     return E_NOTIMPL;
3808 }
3809     
3810 HRESULT STDMETHODCALLTYPE WebView::mainFrameURL( 
3811         /* [retval][out] */ BSTR* urlString)
3812 {
3813     if (!urlString)
3814         return E_POINTER;
3815
3816     if (!m_mainFrame)
3817         return E_FAIL;
3818
3819     COMPtr<IWebDataSource> dataSource;
3820
3821     if (FAILED(m_mainFrame->provisionalDataSource(&dataSource))) {
3822         if (FAILED(m_mainFrame->dataSource(&dataSource)))
3823             return E_FAIL;
3824     }
3825
3826     if (!dataSource) {
3827         *urlString = 0;
3828         return S_OK;
3829     }
3830     
3831     COMPtr<IWebMutableURLRequest> request;
3832     if (FAILED(dataSource->request(&request)) || !request)
3833         return E_FAIL;
3834
3835     if (FAILED(request->URL(urlString)))
3836         return E_FAIL;
3837
3838     return S_OK;
3839 }
3840     
3841 HRESULT STDMETHODCALLTYPE WebView::mainFrameDocument( 
3842         /* [retval][out] */ IDOMDocument** document)
3843 {
3844     if (document)
3845         *document = 0;
3846     if (!m_mainFrame)
3847         return E_FAIL;
3848     return m_mainFrame->DOMDocument(document);
3849 }
3850     
3851 HRESULT STDMETHODCALLTYPE WebView::mainFrameTitle( 
3852         /* [retval][out] */ BSTR* /*title*/)
3853 {
3854     ASSERT_NOT_REACHED();
3855     return E_NOTIMPL;
3856 }
3857     
3858 HRESULT STDMETHODCALLTYPE WebView::mainFrameIcon( 
3859         /* [retval][out] */ OLE_HANDLE* /*hBitmap*/)
3860 {
3861     ASSERT_NOT_REACHED();
3862     return E_NOTIMPL;
3863 }
3864
3865 HRESULT STDMETHODCALLTYPE WebView::registerURLSchemeAsLocal( 
3866         /* [in] */ BSTR scheme)
3867 {
3868     if (!scheme)
3869         return E_POINTER;
3870
3871     SchemeRegistry::registerURLSchemeAsLocal(toString(scheme));
3872
3873     return S_OK;
3874 }
3875
3876 // IWebIBActions ---------------------------------------------------------------
3877
3878 HRESULT STDMETHODCALLTYPE WebView::takeStringURLFrom( 
3879         /* [in] */ IUnknown* /*sender*/)
3880 {
3881     ASSERT_NOT_REACHED();
3882     return E_NOTIMPL;
3883 }
3884     
3885 HRESULT STDMETHODCALLTYPE WebView::stopLoading( 
3886         /* [in] */ IUnknown* /*sender*/)
3887 {
3888     if (!m_mainFrame)
3889         return E_FAIL;
3890
3891     return m_mainFrame->stopLoading();
3892 }
3893     
3894 HRESULT STDMETHODCALLTYPE WebView::reload( 
3895         /* [in] */ IUnknown* /*sender*/)
3896 {
3897     if (!m_mainFrame)
3898         return E_FAIL;
3899
3900     return m_mainFrame->reload();
3901 }
3902     
3903 HRESULT STDMETHODCALLTYPE WebView::canGoBack( 
3904         /* [in] */ IUnknown* /*sender*/,
3905         /* [retval][out] */ BOOL* result)
3906 {
3907     *result = !!(m_page->backForward().client()->backItem() && !m_page->defersLoading());
3908     return S_OK;
3909 }
3910     
3911 HRESULT STDMETHODCALLTYPE WebView::goBack( 
3912         /* [in] */ IUnknown* /*sender*/)
3913 {
3914     ASSERT_NOT_REACHED();
3915     return E_NOTIMPL;
3916 }
3917     
3918 HRESULT STDMETHODCALLTYPE WebView::canGoForward( 
3919         /* [in] */ IUnknown* /*sender*/,
3920         /* [retval][out] */ BOOL* result)
3921 {
3922     *result = !!(m_page->backForward().client()->forwardItem() && !m_page->defersLoading());
3923     return S_OK;
3924 }
3925     
3926 HRESULT STDMETHODCALLTYPE WebView::goForward( 
3927         /* [in] */ IUnknown* /*sender*/)
3928 {
3929     ASSERT_NOT_REACHED();
3930     return E_NOTIMPL;
3931 }
3932
3933 // FIXME: This code should move into WebCore so it can be shared by all the WebKits.
3934 #define MinimumZoomMultiplier   0.5f
3935 #define MaximumZoomMultiplier   3.0f
3936 #define ZoomMultiplierRatio     1.2f
3937
3938 HRESULT STDMETHODCALLTYPE WebView::canMakeTextLarger( 
3939         /* [in] */ IUnknown* /*sender*/,
3940         /* [retval][out] */ BOOL* result)
3941 {
3942     bool canGrowMore = canZoomIn(m_zoomsTextOnly);
3943     *result = canGrowMore ? TRUE : FALSE;
3944     return S_OK;
3945 }
3946
3947 HRESULT STDMETHODCALLTYPE WebView::canZoomPageIn( 
3948         /* [in] */ IUnknown* /*sender*/,
3949         /* [retval][out] */ BOOL* result)
3950 {
3951     bool canGrowMore = canZoomIn(false);
3952     *result = canGrowMore ? TRUE : FALSE;
3953     return S_OK;
3954 }
3955
3956 bool WebView::canZoomIn(bool isTextOnly)
3957 {
3958     return zoomMultiplier(isTextOnly) * ZoomMultiplierRatio < MaximumZoomMultiplier;
3959 }
3960     
3961 HRESULT STDMETHODCALLTYPE WebView::makeTextLarger( 
3962         /* [in] */ IUnknown* /*sender*/)
3963 {
3964     return zoomIn(m_zoomsTextOnly);
3965 }
3966
3967 HRESULT STDMETHODCALLTYPE WebView::zoomPageIn( 
3968         /* [in] */ IUnknown* /*sender*/)
3969 {
3970     return zoomIn(false);
3971 }
3972
3973 HRESULT WebView::zoomIn(bool isTextOnly)
3974 {
3975     if (!canZoomIn(isTextOnly))
3976         return E_FAIL;
3977     setZoomMultiplier(zoomMultiplier(isTextOnly) * ZoomMultiplierRatio, isTextOnly);
3978     return S_OK;
3979 }
3980
3981 HRESULT STDMETHODCALLTYPE WebView::canMakeTextSmaller( 
3982         /* [in] */ IUnknown* /*sender*/,
3983         /* [retval][out] */ BOOL* result)
3984 {
3985     bool canShrinkMore = canZoomOut(m_zoomsTextOnly);
3986     *result = canShrinkMore ? TRUE : FALSE;
3987     return S_OK;
3988 }
3989
3990 HRESULT STDMETHODCALLTYPE WebView::canZoomPageOut( 
3991         /* [in] */ IUnknown* /*sender*/,
3992         /* [retval][out] */ BOOL* result)
3993 {
3994     bool canShrinkMore = canZoomOut(false);
3995     *result = canShrinkMore ? TRUE : FALSE;
3996     return S_OK;
3997 }
3998
3999 bool WebView::canZoomOut(bool isTextOnly)
4000 {
4001     return zoomMultiplier(isTextOnly) / ZoomMultiplierRatio > MinimumZoomMultiplier;
4002 }
4003
4004 HRESULT STDMETHODCALLTYPE WebView::makeTextSmaller( 
4005         /* [in] */ IUnknown* /*sender*/)
4006 {
4007     return zoomOut(m_zoomsTextOnly);
4008 }
4009
4010 HRESULT STDMETHODCALLTYPE WebView::zoomPageOut( 
4011         /* [in] */ IUnknown* /*sender*/)
4012 {
4013     return zoomOut(false);
4014 }
4015
4016 HRESULT WebView::zoomOut(bool isTextOnly)
4017 {
4018     if (!canZoomOut(isTextOnly))
4019         return E_FAIL;
4020     setZoomMultiplier(zoomMultiplier(isTextOnly) / ZoomMultiplierRatio, isTextOnly);
4021     return S_OK;
4022 }
4023
4024 HRESULT STDMETHODCALLTYPE WebView::canMakeTextStandardSize( 
4025     /* [in] */ IUnknown* /*sender*/,
4026     /* [retval][out] */ BOOL* result)
4027 {
4028     // Since we always reset text zoom and page zoom together, this should continue to return an answer about text zoom even if its not enabled.
4029     bool notAlreadyStandard = canResetZoom(true);
4030     *result = notAlreadyStandard ? TRUE : FALSE;
4031     return S_OK;
4032 }
4033
4034 HRESULT STDMETHODCALLTYPE WebView::canResetPageZoom( 
4035     /* [in] */ IUnknown* /*sender*/,
4036     /* [retval][out] */ BOOL* result)
4037 {
4038     bool notAlreadyStandard = canResetZoom(false);
4039     *result = notAlreadyStandard ? TRUE : FALSE;
4040     return S_OK;
4041 }
4042
4043 bool WebView::canResetZoom(bool isTextOnly)
4044 {
4045     return zoomMultiplier(isTextOnly) != 1.0f;
4046 }
4047
4048 HRESULT STDMETHODCALLTYPE WebView::makeTextStandardSize( 
4049     /* [in] */ IUnknown* /*sender*/)
4050 {
4051     return resetZoom(true);
4052 }
4053
4054 HRESULT STDMETHODCALLTYPE WebView::resetPageZoom( 
4055     /* [in] */ IUnknown* /*sender*/)
4056 {
4057     return resetZoom(false);
4058 }
4059
4060 HRESULT WebView::resetZoom(bool isTextOnly)
4061 {
4062     if (!canResetZoom(isTextOnly))
4063         return E_FAIL;
4064     setZoomMultiplier(1.0f, isTextOnly);
4065     return S_OK;
4066 }
4067
4068 HRESULT STDMETHODCALLTYPE WebView::toggleContinuousSpellChecking( 
4069     /* [in] */ IUnknown* /*sender*/)
4070 {
4071     HRESULT hr;
4072     BOOL enabled;
4073     if (FAILED(hr = isContinuousSpellCheckingEnabled(&enabled)))
4074         return hr;
4075     return setContinuousSpellCheckingEnabled(enabled ? FALSE : TRUE);
4076 }
4077
4078 HRESULT STDMETHODCALLTYPE WebView::toggleSmartInsertDelete( 
4079     /* [in] */ IUnknown* /*sender*/)
4080 {
4081     BOOL enabled = FALSE;
4082     HRESULT hr = smartInsertDeleteEnabled(&enabled);
4083     if (FAILED(hr))
4084         return hr;
4085
4086     return setSmartInsertDeleteEnabled(enabled ? FALSE : TRUE);
4087 }
4088
4089 HRESULT STDMETHODCALLTYPE WebView::toggleGrammarChecking( 
4090     /* [in] */ IUnknown* /*sender*/)
4091 {
4092     BOOL enabled;
4093     HRESULT hr = isGrammarCheckingEnabled(&enabled);
4094     if (FAILED(hr))
4095         return hr;
4096
4097     return setGrammarCheckingEnabled(enabled ? FALSE : TRUE);
4098 }
4099
4100 HRESULT STDMETHODCALLTYPE WebView::reloadFromOrigin( 
4101         /* [in] */ IUnknown* /*sender*/)
4102 {
4103     if (!m_mainFrame)
4104         return E_FAIL;
4105
4106     return m_mainFrame->reloadFromOrigin();
4107 }
4108
4109 // IWebViewCSS -----------------------------------------------------------------
4110
4111 HRESULT STDMETHODCALLTYPE WebView::computedStyleForElement( 
4112         /* [in] */ IDOMElement* /*element*/,
4113         /* [in] */ BSTR /*pseudoElement*/,
4114         /* [retval][out] */ IDOMCSSStyleDeclaration** /*style*/)
4115 {
4116     ASSERT_NOT_REACHED();
4117     return E_NOTIMPL;
4118 }
4119
4120 // IWebViewEditing -------------------------------------------------------------
4121
4122 HRESULT STDMETHODCALLTYPE WebView::editableDOMRangeForPoint( 
4123         /* [in] */ LPPOINT /*point*/,
4124         /* [retval][out] */ IDOMRange** /*range*/)
4125 {
4126     ASSERT_NOT_REACHED();
4127     return E_NOTIMPL;
4128 }
4129     
4130 HRESULT STDMETHODCALLTYPE WebView::setSelectedDOMRange( 
4131         /* [in] */ IDOMRange* /*range*/,
4132         /* [in] */ WebSelectionAffinity /*affinity*/)
4133 {
4134     ASSERT_NOT_REACHED();
4135     return E_NOTIMPL;
4136 }
4137     
4138 HRESULT STDMETHODCALLTYPE WebView::selectedDOMRange( 
4139         /* [retval][out] */ IDOMRange** /*range*/)
4140 {
4141     ASSERT_NOT_REACHED();
4142     return E_NOTIMPL;
4143 }
4144     
4145 HRESULT STDMETHODCALLTYPE WebView::selectionAffinity( 
4146         /* [retval][out][retval][out] */ WebSelectionAffinity* /*affinity*/)
4147 {
4148     ASSERT_NOT_REACHED();
4149     return E_NOTIMPL;
4150 }
4151     
4152 HRESULT STDMETHODCALLTYPE WebView::setEditable( 
4153         /* [in] */ BOOL /*flag*/)
4154 {
4155     ASSERT_NOT_REACHED();
4156     return E_NOTIMPL;
4157 }
4158     
4159 HRESULT STDMETHODCALLTYPE WebView::isEditable( 
4160         /* [retval][out] */ BOOL* /*isEditable*/)
4161 {
4162     ASSERT_NOT_REACHED();
4163     return E_NOTIMPL;
4164 }
4165     
4166 HRESULT STDMETHODCALLTYPE WebView::setTypingStyle( 
4167         /* [in] */ IDOMCSSStyleDeclaration* /*style*/)
4168 {
4169     ASSERT_NOT_REACHED();
4170     return E_NOTIMPL;
4171 }
4172     
4173 HRESULT STDMETHODCALLTYPE WebView::typingStyle( 
4174         /* [retval][out] */ IDOMCSSStyleDeclaration** /*style*/)
4175 {
4176     ASSERT_NOT_REACHED();
4177     return E_NOTIMPL;
4178 }
4179     
4180 HRESULT STDMETHODCALLTYPE WebView::setSmartInsertDeleteEnabled( 
4181         /* [in] */ BOOL flag)
4182 {
4183     if (m_page->settings().smartInsertDeleteEnabled() != !!flag) {
4184         m_page->settings().setSmartInsertDeleteEnabled(!!flag);
4185         setSelectTrailingWhitespaceEnabled(!flag);
4186     }
4187     return S_OK;
4188 }
4189     
4190 HRESULT STDMETHODCALLTYPE WebView::smartInsertDeleteEnabled( 
4191         /* [retval][out] */ BOOL* enabled)
4192 {
4193     *enabled = m_page->settings().smartInsertDeleteEnabled() ? TRUE : FALSE;
4194     return S_OK;
4195 }
4196  
4197 HRESULT STDMETHODCALLTYPE WebView::setSelectTrailingWhitespaceEnabled( 
4198         /* [in] */ BOOL flag)
4199 {
4200     if (m_page->settings().selectTrailingWhitespaceEnabled() != !!flag) {
4201         m_page->settings().setSelectTrailingWhitespaceEnabled(!!flag);
4202         setSmartInsertDeleteEnabled(!flag);
4203     }
4204     return S_OK;
4205 }
4206     
4207 HRESULT STDMETHODCALLTYPE WebView::isSelectTrailingWhitespaceEnabled( 
4208         /* [retval][out] */ BOOL* enabled)
4209 {
4210     *enabled = m_page->settings().selectTrailingWhitespaceEnabled() ? TRUE : FALSE;
4211     return S_OK;
4212 }
4213
4214 HRESULT STDMETHODCALLTYPE WebView::setContinuousSpellCheckingEnabled( 
4215         /* [in] */ BOOL flag)
4216 {
4217     if (continuousSpellCheckingEnabled != !!flag) {
4218         continuousSpellCheckingEnabled = !!flag;
4219         COMPtr<IWebPreferences> prefs;
4220         if (SUCCEEDED(preferences(&prefs)))
4221             prefs->setContinuousSpellCheckingEnabled(flag);
4222     }
4223     
4224     BOOL spellCheckingEnabled;
4225     if (SUCCEEDED(isContinuousSpellCheckingEnabled(&spellCheckingEnabled)) && spellCheckingEnabled)
4226         preflightSpellChecker();
4227     else
4228         m_mainFrame->unmarkAllMisspellings();
4229
4230     return S_OK;
4231 }
4232     
4233 HRESULT STDMETHODCALLTYPE WebView::isContinuousSpellCheckingEnabled( 
4234         /* [retval][out] */ BOOL* enabled)
4235 {
4236     *enabled = (continuousSpellCheckingEnabled && continuousCheckingAllowed()) ? TRUE : FALSE;
4237     return S_OK;
4238 }
4239     
4240 HRESULT STDMETHODCALLTYPE WebView::spellCheckerDocumentTag( 
4241         /* [retval][out] */ int* tag)
4242 {
4243     // we just use this as a flag to indicate that we've spell checked the document
4244     // and need to close the spell checker out when the view closes.
4245     *tag = 0;
4246     m_hasSpellCheckerDocumentTag = true;
4247     return S_OK;
4248 }
4249
4250 static COMPtr<IWebEditingDelegate> spellingDelegateForTimer;
4251
4252 static void preflightSpellCheckerNow()
4253 {
4254     spellingDelegateForTimer->preflightChosenSpellServer();
4255     spellingDelegateForTimer = 0;
4256 }
4257
4258 static void CALLBACK preflightSpellCheckerTimerCallback(HWND, UINT, UINT_PTR id, DWORD)
4259 {
4260     ::KillTimer(0, id);
4261     preflightSpellCheckerNow();
4262 }
4263
4264 void WebView::preflightSpellChecker()
4265 {
4266     // As AppKit does, we wish to delay tickling the shared spellchecker into existence on application launch.
4267     if (!m_editingDelegate)
4268         return;
4269
4270     BOOL exists;
4271     spellingDelegateForTimer = m_editingDelegate;
4272     if (SUCCEEDED(m_editingDelegate->sharedSpellCheckerExists(&exists)) && exists)
4273         preflightSpellCheckerNow();
4274     else
4275         ::SetTimer(0, 0, 2000, preflightSpellCheckerTimerCallback);
4276 }
4277
4278 bool WebView::continuousCheckingAllowed()
4279 {
4280     static bool allowContinuousSpellChecking = true;
4281     static bool readAllowContinuousSpellCheckingDefault = false;
4282     if (!readAllowContinuousSpellCheckingDefault) {
4283         COMPtr<IWebPreferences> prefs;
4284         if (SUCCEEDED(preferences(&prefs))) {
4285             BOOL allowed;
4286             prefs->allowContinuousSpellChecking(&allowed);
4287             allowContinuousSpellChecking = !!allowed;
4288         }
4289         readAllowContinuousSpellCheckingDefault = true;
4290     }
4291     return allowContinuousSpellChecking;
4292 }
4293
4294 HRESULT STDMETHODCALLTYPE WebView::undoManager( 
4295         /* [retval][out] */ IWebUndoManager** /*manager*/)
4296 {
4297 &nb