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