--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebKit/win/WebPreferences.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,1180 @@
+/*
+ * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+#include "WebKitDLL.h"
+#include "WebPreferences.h"
+
+#include "WebNotificationCenter.h"
+#include "WebPreferenceKeysPrivate.h"
+
+#pragma warning( push, 0 )
+#include <WebCore/Font.h>
+#include <WebCore/PlatformString.h>
+#include <WebCore/StringHash.h>
+#include "WebLocalizableStrings.h"
+#pragma warning( pop )
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <shlobj.h>
+#include <shfolder.h>
+#include <tchar.h>
+#include <WebKitSystemInterface/WebKitSystemInterface.h>
+#include <wtf/HashMap.h>
+#include <wtf/OwnPtr.h>
+#include <wtf/Vector.h>
+
+#include <initguid.h>
+// {A20B5645-692D-4147-BF80-E8CD84BE82A1}
+DEFINE_GUID(IID_WebPreferences, 0xa20b5645, 0x692d, 0x4147, 0xbf, 0x80, 0xe8, 0xcd, 0x84, 0xbe, 0x82, 0xa1);
+
+static unsigned long long WebSystemMainMemory()
+{
+    MEMORYSTATUSEX statex;
+    
+    statex.dwLength = sizeof(statex);
+    GlobalMemoryStatusEx(&statex);
+    return statex.ullTotalPhys;
+}
+
+// WebPreferences ----------------------------------------------------------------
+
+CFDictionaryRef WebPreferences::s_defaultSettings = 0;
+
+static HashMap<WebCore::String, WebPreferences*> webPreferencesInstances;
+
+WebPreferences* WebPreferences::sharedStandardPreferences()
+{
+    static WebPreferences* standardPreferences;
+    if (!standardPreferences) {
+        standardPreferences = WebPreferences::createInstance();
+        standardPreferences->load();
+        standardPreferences->setAutosaves(TRUE);
+        standardPreferences->postPreferencesChangesNotification();
+    }
+
+    return standardPreferences;
+}
+
+WebPreferences::WebPreferences()
+: m_refCount(0)
+, m_autoSaves(0)
+{
+    gClassCount++;
+}
+
+WebPreferences::~WebPreferences()
+{
+    gClassCount--;
+}
+
+WebPreferences* WebPreferences::createInstance()
+{
+    WebPreferences* instance = new WebPreferences();
+    instance->AddRef();
+    return instance;
+}
+
+HRESULT WebPreferences::postPreferencesChangesNotification()
+{
+    IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal();
+    HRESULT hr = nc->postNotificationName(webPreferencesChangedNotification(), static_cast<IWebPreferences*>(this), 0);
+    if (FAILED(hr))
+        return hr;
+
+    return S_OK;
+}
+
+WebPreferences* WebPreferences::getInstanceForIdentifier(BSTR identifier)
+{
+    if (!identifier)
+        return sharedStandardPreferences();
+
+    WebCore::String identifierString(identifier, SysStringLen(identifier));
+    return webPreferencesInstances.get(identifierString);
+}
+
+void WebPreferences::setInstance(WebPreferences* instance, BSTR identifier)
+{
+    if (!identifier || !instance)
+        return;
+    WebCore::String identifierString(identifier, SysStringLen(identifier));
+    webPreferencesInstances.add(identifierString, instance);
+}
+
+void WebPreferences::removeReferenceForIdentifier(BSTR identifier)
+{
+    if (!identifier || webPreferencesInstances.isEmpty())
+        return;
+
+    WebCore::String identifierString(identifier, SysStringLen(identifier));
+    WebPreferences* webPreference = webPreferencesInstances.get(identifierString);
+    if (webPreference && webPreference->m_refCount == 1)
+        webPreferencesInstances.remove(identifierString);
+}
+
+void WebPreferences::initializeDefaultSettings()
+{
+    if (s_defaultSettings)
+        return;
+
+    CFMutableDictionaryRef defaults = CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+
+    // As a fudge factor, use 1000 instead of 1024, in case the reported memory doesn't align exactly to a megabyte boundary.
+    unsigned long long memSize = WebSystemMainMemory() / 1024 / 1000;
+
+    // Page cache size (in pages)
+    int pageCacheSize;
+    if (memSize >= 1024)
+        pageCacheSize = 10;
+    else if (memSize >= 512)
+        pageCacheSize = 5;
+    else if (memSize >= 384)
+        pageCacheSize = 4;
+    else if (memSize >= 256)
+        pageCacheSize = 3;
+    else if (memSize >= 128)
+        pageCacheSize = 2;
+    else if (memSize >= 64)
+        pageCacheSize = 1;
+    else
+        pageCacheSize = 0;
+
+    // Object cache size (in bytes)
+    int objectCacheSize;
+    if (memSize >= 2048)
+        objectCacheSize = 128 * 1024 * 1024;
+    else if (memSize >= 1024)
+        objectCacheSize = 64 * 1024 * 1024;
+    else if (memSize >= 512)
+        objectCacheSize = 32 * 1024 * 1024;
+    else
+        objectCacheSize = 24 * 1024 * 1024; 
+
+    CFDictionaryAddValue(defaults, CFSTR(WebKitStandardFontPreferenceKey), CFSTR("Times New Roman"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitFixedFontPreferenceKey), CFSTR("Courier New"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitSerifFontPreferenceKey), CFSTR("Times New Roman"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitSansSerifFontPreferenceKey), CFSTR("Arial"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitCursiveFontPreferenceKey), CFSTR("Comic Sans MS"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitFantasyFontPreferenceKey), CFSTR("Comic Sans MS"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitMinimumFontSizePreferenceKey), CFSTR("1"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitMinimumLogicalFontSizePreferenceKey), CFSTR("9"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitDefaultFontSizePreferenceKey), CFSTR("16"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitDefaultFixedFontSizePreferenceKey), CFSTR("13"));
+    WebCore::String defaultDefaultEncoding(LPCTSTR_UI_STRING("ISO-8859-1", "The default, default character encoding"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitDefaultTextEncodingNamePreferenceKey), defaultDefaultEncoding.createCFString());
+
+    RetainPtr<CFStringRef> pageCacheSizeString(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), pageCacheSize));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitPageCacheSizePreferenceKey), pageCacheSizeString.get());
+
+    RetainPtr<CFStringRef> objectCacheSizeString(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), objectCacheSize));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitObjectCacheSizePreferenceKey), objectCacheSizeString.get());
+
+    CFDictionaryAddValue(defaults, CFSTR(WebKitUserStyleSheetEnabledPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitUserStyleSheetLocationPreferenceKey), CFSTR(""));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitShouldPrintBackgroundsPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitTextAreasAreResizablePreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitJavaEnabledPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitJavaScriptEnabledPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitPluginsEnabledPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitAllowAnimatedImagesPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitAllowAnimatedImageLoopingPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitDisplayImagesKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitBackForwardCacheExpirationIntervalKey), CFSTR("1800"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitTabToLinksPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitPrivateBrowsingEnabledPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitRespectStandardStyleKeyEquivalentsPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitShowsURLsInToolTipsPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitPDFDisplayModePreferenceKey), CFSTR("1"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitPDFScaleFactorPreferenceKey), CFSTR("0"));
+
+    RetainPtr<CFStringRef> linkBehaviorStringRef(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), WebKitEditableLinkDefaultBehavior));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitEditableLinkBehaviorPreferenceKey), linkBehaviorStringRef.get());
+
+    CFDictionaryAddValue(defaults, CFSTR(WebKitHistoryItemLimitKey), CFSTR("1000"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitHistoryAgeInDaysLimitKey), CFSTR("7"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitIconDatabaseLocationKey), CFSTR(""));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitIconDatabaseEnabledPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitFontSmothingTypePreferenceKey), CFSTR("2"));
+    CFDictionaryAddValue(defaults, CFSTR(WebKitCookieStorageAcceptPolicyPreferenceKey), CFSTR("2"));
+    CFDictionaryAddValue(defaults, CFSTR(WebContinuousSpellCheckingEnabledPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(WebGrammarCheckingEnabledPreferenceKey), kCFBooleanFalse);
+    CFDictionaryAddValue(defaults, CFSTR(AllowContinuousSpellCheckingPreferenceKey), kCFBooleanTrue);
+    CFDictionaryAddValue(defaults, CFSTR(WebKitUsesPageCachePreferenceKey), kCFBooleanTrue);
+
+    s_defaultSettings = defaults;
+}
+
+const void* WebPreferences::valueForKey(CFStringRef key)
+{
+    const void* value = CFDictionaryGetValue(m_privatePrefs.get(), key);
+    if (!value)
+        value = CFDictionaryGetValue(s_defaultSettings, key);
+
+    return value;
+}
+
+BSTR WebPreferences::stringValueForKey(CFStringRef key)
+{
+    CFStringRef str = (CFStringRef)valueForKey(key);
+    
+    if (!str || (CFGetTypeID(str) != CFStringGetTypeID()))
+        return 0;
+
+    CFIndex length = CFStringGetLength(str);
+    const UniChar* uniChars = CFStringGetCharactersPtr(str);
+    if (uniChars)
+        return SysAllocStringLen((LPCTSTR)uniChars, length);
+
+    BSTR bstr = SysAllocStringLen(0, length);
+    if (!bstr)
+        return 0;
+
+    if (!CFStringGetCString(str, (char*)bstr, (length+1)*sizeof(WCHAR), kCFStringEncodingUTF16)) {
+        SysFreeString(bstr);
+        return 0;
+    }
+        
+    bstr[length] = 0;
+    return bstr;
+}
+
+int WebPreferences::integerValueForKey(CFStringRef key)
+{
+    CFTypeRef cfVal = (CFStringRef)valueForKey(key);
+    if (!cfVal)
+        return 0;
+
+    CFTypeID cfType = CFGetTypeID(cfVal);
+    if (cfType == CFStringGetTypeID())
+        return CFStringGetIntValue((CFStringRef)cfVal);
+    else if (cfType == CFBooleanGetTypeID()) {
+        Boolean boolVal = CFBooleanGetValue((CFBooleanRef)cfVal);
+        return (boolVal) ? 1 : 0;
+    }
+    else if (cfType == CFNumberGetTypeID()) {
+        int val = 0;
+        CFNumberGetValue((CFNumberRef)cfVal, kCFNumberSInt32Type, &val);
+        return val;
+    }
+
+    return 0;
+}
+
+BOOL WebPreferences::boolValueForKey(CFStringRef key)
+{
+    return (integerValueForKey(key) != 0);
+}
+
+float WebPreferences::floatValueForKey(CFStringRef key)
+{
+    CFTypeRef cfVal = (CFStringRef)valueForKey(key);
+    if (!cfVal)
+        return 0.0;
+
+    CFTypeID cfType = CFGetTypeID(cfVal);
+    if (cfType == CFStringGetTypeID())
+        return (float)CFStringGetDoubleValue((CFStringRef)cfVal);
+    else if (cfType == CFBooleanGetTypeID()) {
+        Boolean boolVal = CFBooleanGetValue((CFBooleanRef)cfVal);
+        return (boolVal) ? 1.0f : 0.0f;
+    }
+    else if (cfType == CFNumberGetTypeID()) {
+        float val = 0.0;
+        CFNumberGetValue((CFNumberRef)cfVal, kCFNumberFloatType, &val);
+        return val;
+    }
+
+    return 0.0;
+}
+
+void WebPreferences::setStringValue(CFStringRef key, LPCTSTR value)
+{
+    BSTR val = stringValueForKey(key);
+    if (val && !_tcscmp(val, value))
+        return;
+    SysFreeString(val);
+    
+    RetainPtr<CFStringRef> valueRef(AdoptCF,
+        CFStringCreateWithCharactersNoCopy(0, (UniChar*)_wcsdup(value), (CFIndex)_tcslen(value), kCFAllocatorMalloc));
+    CFDictionarySetValue(m_privatePrefs.get(), key, valueRef.get());
+    if (m_autoSaves)
+        save();
+
+    postPreferencesChangesNotification();
+}
+
+BSTR WebPreferences::webPreferencesChangedNotification()
+{
+    static BSTR webPreferencesChangedNotification = SysAllocString(WebPreferencesChangedNotification);
+    return webPreferencesChangedNotification;
+}
+
+void WebPreferences::setIntegerValue(CFStringRef key, int value)
+{
+    if (integerValueForKey(key) == value)
+        return;
+
+    RetainPtr<CFNumberRef> valueRef(AdoptCF, CFNumberCreate(0, kCFNumberSInt32Type, &value));
+    CFDictionarySetValue(m_privatePrefs.get(), key, valueRef.get());
+    if (m_autoSaves)
+        save();
+
+    postPreferencesChangesNotification();
+}
+
+void WebPreferences::setBoolValue(CFStringRef key, BOOL value)
+{
+    if (boolValueForKey(key) == value)
+        return;
+
+    CFDictionarySetValue(m_privatePrefs.get(), key, value ? kCFBooleanTrue : kCFBooleanFalse);
+    if (m_autoSaves)
+        save();
+
+    postPreferencesChangesNotification();
+}
+
+void WebPreferences::save()
+{
+    TCHAR appDataPath[MAX_PATH];
+    if (FAILED(preferencesPath(appDataPath, MAX_PATH)))
+        return;
+
+    RetainPtr<CFWriteStreamRef> stream(AdoptCF,
+        CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault)); 
+    if (!stream)
+        return;
+
+    if (!CFWriteStreamOpen(stream.get()))
+        return;
+
+    if (!CFPropertyListWriteToStream(m_privatePrefs.get(), stream.get(), kCFPropertyListXMLFormat_v1_0, 0)) {
+        CFWriteStreamClose(stream.get());
+        return;
+    }
+    CFWriteStreamClose(stream.get());
+
+    RetainPtr<CFDataRef> dataRef(AdoptCF,
+        (CFDataRef)CFWriteStreamCopyProperty(stream.get(), kCFStreamPropertyDataWritten));
+    if (!dataRef)
+        return;
+
+    void* bytes = (void*)CFDataGetBytePtr(dataRef.get());
+    size_t length = CFDataGetLength(dataRef.get());
+    safeCreateFileWithData(appDataPath, bytes, length);
+}
+
+void WebPreferences::load()
+{
+    initializeDefaultSettings();
+
+    TCHAR appDataPath[MAX_PATH];
+    if (FAILED(preferencesPath(appDataPath, MAX_PATH)))
+        return;
+
+    DWORD appDataPathLength = (DWORD) _tcslen(appDataPath)+1;
+    int result = WideCharToMultiByte(CP_UTF8, 0, appDataPath, appDataPathLength, 0, 0, 0, 0);
+    Vector<UInt8> utf8Path(result);
+    if (!WideCharToMultiByte(CP_UTF8, 0, appDataPath, appDataPathLength, (LPSTR)utf8Path.data(), result, 0, 0))
+        return;
+
+    RetainPtr<CFURLRef> urlRef(AdoptCF, CFURLCreateFromFileSystemRepresentation(0, utf8Path.data(), result-1, false));
+    if (!urlRef)
+        return;
+
+    RetainPtr<CFReadStreamRef> stream(AdoptCF, CFReadStreamCreateWithFile(0, urlRef.get()));
+    if (!stream) 
+        return;
+
+    if (CFReadStreamOpen(stream.get())) {
+        CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0 | kCFPropertyListXMLFormat_v1_0;
+        RetainPtr<CFPropertyListRef> plist(AdoptCF, CFPropertyListCreateFromStream(0, stream.get(), 0, kCFPropertyListMutableContainersAndLeaves, &format, 0));
+        CFReadStreamClose(stream.get());
+
+        if (CFGetTypeID(plist.get()) == CFDictionaryGetTypeID())
+            m_privatePrefs.adoptCF(const_cast<CFMutableDictionaryRef>(reinterpret_cast<CFDictionaryRef>(plist.releaseRef())));
+    }
+
+    if (!m_privatePrefs)
+        m_privatePrefs.adoptCF(CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
+
+    migrateDefaultSettingsFromSafari3Beta();
+}
+
+void WebPreferences::migrateDefaultSettingsFromSafari3Beta()
+{
+    // The "migration" happening here is a one-time removal of any default values
+    // that were stored in the user's preferences due to <rdar://problem/5214504>.
+
+    ASSERT(s_defaultSettings);
+    if (!m_privatePrefs)
+        return;
+
+    CFStringRef didMigrateKey = CFSTR(WebKitDidMigrateDefaultSettingsFromSafari3BetaPreferenceKey);
+    if (boolValueForKey(didMigrateKey))
+        return;
+
+    removeValuesMatchingDefaultSettings();
+
+    bool oldValue = m_autoSaves;
+    m_autoSaves = true;
+    setBoolValue(didMigrateKey, TRUE);
+    m_autoSaves = oldValue;
+}
+
+void WebPreferences::removeValuesMatchingDefaultSettings()
+{
+    ASSERT(m_privatePrefs);
+
+    int count = CFDictionaryGetCount(m_privatePrefs.get());
+    if (count <= 0)
+        return;
+
+    Vector<CFTypeRef> keys(count);
+    Vector<CFTypeRef> values(count);
+    CFDictionaryGetKeysAndValues(m_privatePrefs.get(), keys.data(), values.data());
+
+    for (int i = 0; i < count; ++i) {
+        if (!values[i])
+            continue;
+
+        CFTypeRef defaultValue = CFDictionaryGetValue(s_defaultSettings, keys[i]);
+        if (!defaultValue)
+            continue;
+
+        if (CFEqual(values[i], defaultValue))
+            CFDictionaryRemoveValue(m_privatePrefs.get(), keys[i]);
+    }
+}
+
+HRESULT WebPreferences::preferencesPath(LPTSTR path, size_t cchPath)
+{
+    // get the path to the user's Application Data folder (Example: C:\Documents and Settings\{username}\Application Data\Apple Computer\WebKit)
+    HRESULT hr = SHGetFolderPath(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0, 0, path);
+    if (FAILED(hr))
+        return hr;
+
+    if (_tcscat_s(path, cchPath, TEXT("\\Apple Computer\\")))
+        return E_FAIL;
+
+    WebCore::String appName = "WebKit";
+    CFBundleRef bundle = CFBundleGetMainBundle();
+    if (bundle) {
+        CFStringRef bundleExecutable = (CFStringRef)CFBundleGetValueForInfoDictionaryKey(bundle, kCFBundleExecutableKey);
+        if (bundleExecutable)
+            appName = bundleExecutable;
+    }
+    if (_tcscat_s(path, cchPath, appName.charactersWithNullTermination()))
+        return E_FAIL;
+
+    int err = SHCreateDirectoryEx(0, path, 0);
+    if (err != ERROR_SUCCESS && err != ERROR_ALREADY_EXISTS)
+        return E_FAIL;
+
+    if (_tcscat_s(path, cchPath, TEXT("\\WebKitPreferences.plist")))
+        return E_FAIL;
+
+    return S_OK;
+}
+
+HRESULT WebPreferences::safeCreateFileWithData(LPCTSTR path, void* data, size_t length)
+{
+    TCHAR tempDirPath[MAX_PATH];
+    TCHAR tempPath[MAX_PATH];
+    HANDLE tempFileHandle = INVALID_HANDLE_VALUE;
+    HRESULT hr = S_OK;
+    tempPath[0] = 0;
+
+    // create a temporary file
+    if (!GetTempPath(sizeof(tempDirPath)/sizeof(tempDirPath[0]), tempDirPath)) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        goto exit;
+    }
+    if (!GetTempFileName(tempDirPath, TEXT("WEBKIT"), 0, tempPath))
+        return HRESULT_FROM_WIN32(GetLastError());
+    tempFileHandle = CreateFile(tempPath, GENERIC_READ|GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+    if (tempFileHandle == INVALID_HANDLE_VALUE) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        goto exit;
+    }
+
+    // write the data to this temp file
+    DWORD written;
+    if (!WriteFile(tempFileHandle, data, (DWORD)length, &written, 0)) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        goto exit;
+    }
+
+    // copy the temp file to the destination file
+    CloseHandle(tempFileHandle);
+    tempFileHandle = INVALID_HANDLE_VALUE;
+    if (!MoveFileEx(tempPath, path, MOVEFILE_REPLACE_EXISTING)) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        goto exit;
+    }
+
+exit:
+    if (tempFileHandle != INVALID_HANDLE_VALUE)
+        CloseHandle(tempFileHandle);
+    if (tempPath[0])
+        DeleteFile(tempPath);
+
+    return hr;
+}
+
+// IUnknown -------------------------------------------------------------------
+
+HRESULT STDMETHODCALLTYPE WebPreferences::QueryInterface(REFIID riid, void** ppvObject)
+{
+    *ppvObject = 0;
+    if (IsEqualGUID(riid, IID_IUnknown))
+        *ppvObject = static_cast<IWebPreferences*>(this);
+    else if (IsEqualGUID(riid, IID_IWebPreferences))
+        *ppvObject = static_cast<IWebPreferences*>(this);
+    else if (IsEqualGUID(riid, IID_IWebPreferencesPrivate))
+        *ppvObject = static_cast<IWebPreferencesPrivate*>(this);
+    else if (IsEqualGUID(riid, IID_WebPreferences))
+        *ppvObject = static_cast<WebPreferences*>(this);
+    else
+        return E_NOINTERFACE;
+
+    AddRef();
+    return S_OK;
+}
+
+ULONG STDMETHODCALLTYPE WebPreferences::AddRef(void)
+{
+    return ++m_refCount;
+}
+
+ULONG STDMETHODCALLTYPE WebPreferences::Release(void)
+{
+    ULONG newRef = --m_refCount;
+    if (!newRef)
+        delete(this);
+
+    return newRef;
+}
+
+// IWebPreferences ------------------------------------------------------------
+
+HRESULT STDMETHODCALLTYPE WebPreferences::standardPreferences( 
+    /* [retval][out] */ IWebPreferences** standardPreferences)
+{
+    if (!standardPreferences)
+        return E_POINTER;
+    *standardPreferences = sharedStandardPreferences();
+    (*standardPreferences)->AddRef();
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::initWithIdentifier( 
+        /* [in] */ BSTR anIdentifier,
+        /* [retval][out] */ IWebPreferences** preferences)
+{
+    WebPreferences *instance = getInstanceForIdentifier(anIdentifier);
+    if (instance) {
+        *preferences = instance;
+        instance->AddRef();
+        return S_OK;
+    }
+
+    load();
+
+    *preferences = this;
+    AddRef();
+
+    if (anIdentifier) {
+        m_identifier = anIdentifier;
+        setInstance(this, m_identifier);
+    }
+
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::identifier( 
+    /* [retval][out] */ BSTR* ident)
+{
+    if (!ident)
+        return E_POINTER;
+    *ident = m_identifier ? SysAllocString(m_identifier) : 0;
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::standardFontFamily( 
+    /* [retval][out] */ BSTR* family)
+{
+    *family = stringValueForKey(CFSTR(WebKitStandardFontPreferenceKey));
+    return (*family) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setStandardFontFamily( 
+    /* [in] */ BSTR family)
+{
+    setStringValue(CFSTR(WebKitStandardFontPreferenceKey), family);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::fixedFontFamily( 
+    /* [retval][out] */ BSTR* family)
+{
+    *family = stringValueForKey(CFSTR(WebKitFixedFontPreferenceKey));
+    return (*family) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setFixedFontFamily( 
+    /* [in] */ BSTR family)
+{
+    setStringValue(CFSTR(WebKitFixedFontPreferenceKey), family);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::serifFontFamily( 
+    /* [retval][out] */ BSTR* fontFamily)
+{
+    *fontFamily = stringValueForKey(CFSTR(WebKitSerifFontPreferenceKey));
+    return (*fontFamily) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setSerifFontFamily( 
+    /* [in] */ BSTR family)
+{
+    setStringValue(CFSTR(WebKitSerifFontPreferenceKey), family);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::sansSerifFontFamily( 
+    /* [retval][out] */ BSTR* family)
+{
+    *family = stringValueForKey(CFSTR(WebKitSansSerifFontPreferenceKey));
+    return (*family) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setSansSerifFontFamily( 
+    /* [in] */ BSTR family)
+{
+    setStringValue(CFSTR(WebKitSansSerifFontPreferenceKey), family);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::cursiveFontFamily( 
+    /* [retval][out] */ BSTR* family)
+{
+    *family = stringValueForKey(CFSTR(WebKitCursiveFontPreferenceKey));
+    return (*family) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setCursiveFontFamily( 
+    /* [in] */ BSTR family)
+{
+    setStringValue(CFSTR(WebKitCursiveFontPreferenceKey), family);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::fantasyFontFamily( 
+    /* [retval][out] */ BSTR* family)
+{
+    *family = stringValueForKey(CFSTR(WebKitFantasyFontPreferenceKey));
+    return (*family) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setFantasyFontFamily( 
+    /* [in] */ BSTR family)
+{
+    setStringValue(CFSTR(WebKitFantasyFontPreferenceKey), family);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::defaultFontSize( 
+    /* [retval][out] */ int* fontSize)
+{
+    *fontSize = integerValueForKey(CFSTR(WebKitDefaultFontSizePreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setDefaultFontSize( 
+    /* [in] */ int fontSize)
+{
+    setIntegerValue(CFSTR(WebKitDefaultFontSizePreferenceKey), fontSize);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::defaultFixedFontSize( 
+    /* [retval][out] */ int* fontSize)
+{
+    *fontSize = integerValueForKey(CFSTR(WebKitDefaultFixedFontSizePreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setDefaultFixedFontSize( 
+    /* [in] */ int fontSize)
+{
+    setIntegerValue(CFSTR(WebKitDefaultFixedFontSizePreferenceKey), fontSize);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::minimumFontSize( 
+    /* [retval][out] */ int* fontSize)
+{
+    *fontSize = integerValueForKey(CFSTR(WebKitMinimumFontSizePreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setMinimumFontSize( 
+    /* [in] */ int fontSize)
+{
+    setIntegerValue(CFSTR(WebKitMinimumFontSizePreferenceKey), fontSize);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::minimumLogicalFontSize( 
+    /* [retval][out] */ int* fontSize)
+{
+    *fontSize = integerValueForKey(CFSTR(WebKitMinimumLogicalFontSizePreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setMinimumLogicalFontSize( 
+    /* [in] */ int fontSize)
+{
+    setIntegerValue(CFSTR(WebKitMinimumLogicalFontSizePreferenceKey), fontSize);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::defaultTextEncodingName( 
+    /* [retval][out] */ BSTR* name)
+{
+    *name = stringValueForKey(CFSTR(WebKitDefaultTextEncodingNamePreferenceKey));
+    return (*name) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setDefaultTextEncodingName( 
+    /* [in] */ BSTR name)
+{
+    setStringValue(CFSTR(WebKitDefaultTextEncodingNamePreferenceKey), name);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::userStyleSheetEnabled( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitUserStyleSheetEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setUserStyleSheetEnabled( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitUserStyleSheetEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::userStyleSheetLocation( 
+    /* [retval][out] */ BSTR* location)
+{
+    *location = stringValueForKey(CFSTR(WebKitUserStyleSheetLocationPreferenceKey));
+    return (*location) ? S_OK : E_FAIL;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setUserStyleSheetLocation( 
+    /* [in] */ BSTR location)
+{
+    setStringValue(CFSTR(WebKitUserStyleSheetLocationPreferenceKey), location);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::isJavaEnabled( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitJavaEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setJavaEnabled( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitJavaEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::isJavaScriptEnabled( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitJavaScriptEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setJavaScriptEnabled( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitJavaScriptEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::javaScriptCanOpenWindowsAutomatically( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setJavaScriptCanOpenWindowsAutomatically( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::arePlugInsEnabled( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitPluginsEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setPlugInsEnabled( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitPluginsEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::allowsAnimatedImages( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitAllowAnimatedImagesPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setAllowsAnimatedImages( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitAllowAnimatedImagesPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::allowAnimatedImageLooping( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitAllowAnimatedImageLoopingPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setAllowAnimatedImageLooping( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitAllowAnimatedImageLoopingPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setLoadsImagesAutomatically( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitDisplayImagesKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::loadsImagesAutomatically( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitDisplayImagesKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setAutosaves( 
+    /* [in] */ BOOL enabled)
+{
+    m_autoSaves = !!enabled;
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::autosaves( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = m_autoSaves ? TRUE : FALSE;
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setShouldPrintBackgrounds( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitShouldPrintBackgroundsPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::shouldPrintBackgrounds( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitShouldPrintBackgroundsPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setPrivateBrowsingEnabled( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitPrivateBrowsingEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::privateBrowsingEnabled( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitPrivateBrowsingEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setTabsToLinks( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitTabToLinksPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::tabsToLinks( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitTabToLinksPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setUsesPageCache( 
+        /* [in] */ BOOL usesPageCache)
+{
+    setBoolValue(CFSTR(WebKitUsesPageCachePreferenceKey), usesPageCache);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::usesPageCache( 
+    /* [retval][out] */ BOOL* usesPageCache)
+{
+    *usesPageCache = boolValueForKey(CFSTR(WebKitUsesPageCachePreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::textAreasAreResizable( 
+    /* [retval][out] */ BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitTextAreasAreResizablePreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setTextAreasAreResizable( 
+    /* [in] */ BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitTextAreasAreResizablePreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT WebPreferences::historyItemLimit(int* limit)
+{
+    *limit = integerValueForKey(CFSTR(WebKitHistoryItemLimitKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::setHistoryItemLimit(int limit)
+{
+    setIntegerValue(CFSTR(WebKitHistoryItemLimitKey), limit);
+    return S_OK;
+}
+
+HRESULT WebPreferences::historyAgeInDaysLimit(int* limit)
+{
+    *limit = integerValueForKey(CFSTR(WebKitHistoryAgeInDaysLimitKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::setHistoryAgeInDaysLimit(int limit)
+{
+    setIntegerValue(CFSTR(WebKitHistoryAgeInDaysLimitKey), limit);
+    return S_OK;
+}
+
+HRESULT WebPreferences::pageCacheSize(unsigned int* limit)
+{
+    *limit = integerValueForKey(CFSTR(WebKitPageCacheSizePreferenceKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::objectCacheSize(unsigned int* limit)
+{
+    *limit = integerValueForKey(CFSTR(WebKitObjectCacheSizePreferenceKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::iconDatabaseLocation(
+    /* [out] */ BSTR* location)
+{
+    *location = stringValueForKey(CFSTR(WebKitIconDatabaseLocationKey));
+    return (*location) ? S_OK : E_FAIL;
+}
+
+HRESULT WebPreferences::setIconDatabaseLocation(
+    /* [in] */ BSTR location)
+{
+    setStringValue(CFSTR(WebKitIconDatabaseLocationKey), location);
+    return S_OK;
+}
+
+HRESULT WebPreferences::iconDatabaseEnabled(BOOL* enabled)//location)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitIconDatabaseEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::setIconDatabaseEnabled(BOOL enabled )//location)
+{
+    setBoolValue(CFSTR(WebKitIconDatabaseEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::fontSmoothing( 
+    /* [retval][out] */ FontSmoothingType* smoothingType)
+{
+    *smoothingType = (FontSmoothingType) integerValueForKey(CFSTR(WebKitFontSmothingTypePreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setFontSmoothing( 
+    /* [in] */ FontSmoothingType smoothingType)
+{
+    setIntegerValue(CFSTR(WebKitFontSmothingTypePreferenceKey), smoothingType);
+    wkSetFontSmoothingLevel((int)smoothingType);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::editableLinkBehavior(
+    /* [out, retval] */ WebKitEditableLinkBehavior* editableLinkBehavior)
+{
+    WebKitEditableLinkBehavior value = (WebKitEditableLinkBehavior) integerValueForKey(CFSTR(WebKitEditableLinkBehaviorPreferenceKey));
+    switch (value) {
+        case WebKitEditableLinkDefaultBehavior:
+        case WebKitEditableLinkAlwaysLive:
+        case WebKitEditableLinkOnlyLiveWithShiftKey:
+        case WebKitEditableLinkLiveWhenNotFocused:
+        case WebKitEditableLinkNeverLive:
+            *editableLinkBehavior = value;
+            break;
+        default: // ensure that a valid result is returned
+            *editableLinkBehavior = WebKitEditableLinkDefaultBehavior;
+            break;
+    }
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setEditableLinkBehavior(
+    /* [in] */ WebKitEditableLinkBehavior behavior)
+{
+    setIntegerValue(CFSTR(WebKitEditableLinkBehaviorPreferenceKey), behavior);
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::cookieStorageAcceptPolicy( 
+        /* [retval][out] */ WebKitCookieStorageAcceptPolicy *acceptPolicy )
+{
+    if (!acceptPolicy)
+        return E_POINTER;
+
+    *acceptPolicy = (WebKitCookieStorageAcceptPolicy)integerValueForKey(CFSTR(WebKitCookieStorageAcceptPolicyPreferenceKey));
+    return S_OK;
+}
+
+HRESULT STDMETHODCALLTYPE WebPreferences::setCookieStorageAcceptPolicy( 
+        /* [in] */ WebKitCookieStorageAcceptPolicy acceptPolicy)
+{
+    setIntegerValue(CFSTR(WebKitCookieStorageAcceptPolicyPreferenceKey), acceptPolicy);
+    return S_OK;
+}
+
+
+HRESULT WebPreferences::continuousSpellCheckingEnabled(BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebContinuousSpellCheckingEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::setContinuousSpellCheckingEnabled(BOOL enabled)
+{
+    setBoolValue(CFSTR(WebContinuousSpellCheckingEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT WebPreferences::grammarCheckingEnabled(BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebGrammarCheckingEnabledPreferenceKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::setGrammarCheckingEnabled(BOOL enabled)
+{
+    setBoolValue(CFSTR(WebGrammarCheckingEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT WebPreferences::allowContinuousSpellChecking(BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(AllowContinuousSpellCheckingPreferenceKey));
+    return S_OK;
+}
+
+HRESULT WebPreferences::setAllowContinuousSpellChecking(BOOL enabled)
+{
+    setBoolValue(CFSTR(AllowContinuousSpellCheckingPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT WebPreferences::isDOMPasteAllowed(BOOL* enabled)
+{
+    *enabled = boolValueForKey(CFSTR(WebKitDOMPasteAllowedPreferenceKey));
+    return S_OK;
+}
+    
+HRESULT WebPreferences::setDOMPasteAllowed(BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitDOMPasteAllowedPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT WebPreferences::setDeveloperExtrasEnabled(BOOL enabled)
+{
+    setBoolValue(CFSTR(WebKitDeveloperExtrasEnabledPreferenceKey), enabled);
+    return S_OK;
+}
+
+HRESULT WebPreferences::developerExtrasEnabled(BOOL* enabled)
+{
+    if (!enabled)
+        return E_POINTER;
+
+    *enabled = boolValueForKey(CFSTR(WebKitDeveloperExtrasEnabledPreferenceKey));
+    return S_OK;
+}
+
+bool WebPreferences::developerExtrasDisabledByOverride()
+{
+    return !!boolValueForKey(CFSTR(DisableWebKitDeveloperExtrasPreferenceKey));
+}