WebKit/win/WebView.cpp

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