diff -r 000000000000 -r 4f2f89ce4247 WebKit/win/WebPreferences.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/WebKit/win/WebPreferences.cpp Fri Sep 17 09:02:29 2010 +0300 @@ -0,0 +1,1514 @@ +/* + * Copyright (C) 2006, 2007, 2008, 2009, 2010 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 "WebKit.h" +#include "WebKitDLL.h" +#include "WebPreferences.h" + +#include "COMPtr.h" +#include "WebNotificationCenter.h" +#include "WebPreferenceKeysPrivate.h" + +#include +#include +#include +#include +#include +#include "WebLocalizableStrings.h" + +#include +#include +#include +#include +#include +#include +#include + +#if PLATFORM(CG) +#include +#include +#endif + +using namespace WebCore; +using std::numeric_limits; + +static const String& oldPreferencesPath() +{ + static String path = pathByAppendingComponent(roamingUserSpecificStorageDirectory(), "WebKitPreferences.plist"); + return path; +} + +template struct CFNumberTraits { static const unsigned Type; }; +template<> struct CFNumberTraits { static const unsigned Type = kCFNumberSInt32Type; }; +template<> struct CFNumberTraits { static const unsigned Type = kCFNumberLongLongType; }; +template<> struct CFNumberTraits { static const unsigned Type = kCFNumberFloat32Type; }; + +template +static NumberType numberValueForPreferencesValue(CFPropertyListRef value) +{ + if (!value) + return 0; + + CFTypeID cfType = CFGetTypeID(value); + if (cfType == CFStringGetTypeID()) + return static_cast(CFStringGetIntValue(static_cast(value))); + else if (cfType == CFBooleanGetTypeID()) { + Boolean boolVal = CFBooleanGetValue(static_cast(value)); + return boolVal ? 1 : 0; + } else if (cfType == CFNumberGetTypeID()) { + NumberType val = 0; + CFNumberGetValue(static_cast(value), CFNumberTraits::Type, &val); + return val; + } + + return 0; +} + +template +static RetainPtr cfNumber(NumberType value) +{ + return RetainPtr(AdoptCF, CFNumberCreate(0, CFNumberTraits::Type, &value)); +} + +static bool booleanValueForPreferencesValue(CFPropertyListRef value) +{ + return numberValueForPreferencesValue(value); +} + +// WebPreferences ---------------------------------------------------------------- + +static CFDictionaryRef defaultSettings; + +static HashMap > webPreferencesInstances; + +WebPreferences* WebPreferences::sharedStandardPreferences() +{ + static WebPreferences* standardPreferences; + if (!standardPreferences) { + standardPreferences = WebPreferences::createInstance(); + standardPreferences->setAutosaves(TRUE); + standardPreferences->load(); + } + + return standardPreferences; +} + +WebPreferences::WebPreferences() + : m_refCount(0) + , m_autoSaves(0) + , m_automaticallyDetectsCacheModel(true) + , m_numWebViews(0) +{ + gClassCount++; + gClassNameCount.add("WebPreferences"); +} + +WebPreferences::~WebPreferences() +{ + gClassCount--; + gClassNameCount.remove("WebPreferences"); +} + +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(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).get(); +} + +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).get(); + if (webPreference && webPreference->m_refCount == 1) + webPreferencesInstances.remove(identifierString); +} + +void WebPreferences::initializeDefaultSettings() +{ + if (defaultSettings) + return; + + CFMutableDictionaryRef defaults = CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); + + 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()); + + 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(WebKitWebSecurityEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitAllowUniversalAccessFromFileURLsPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitAllowFileAccessFromFileURLsPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitJavaScriptCanAccessClipboardPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitXSSAuditorEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitFrameFlatteningEnabledPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitJavaScriptCanOpenWindowsAutomaticallyPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitPluginsEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitDatabasesEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitLocalStorageEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitExperimentalNotificationsEnabledPreferenceKey), kCFBooleanFalse); + CFDictionaryAddValue(defaults, CFSTR(WebKitZoomsTextOnlyPreferenceKey), 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 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(WebKitFontSmoothingTypePreferenceKey), CFSTR("2")); + CFDictionaryAddValue(defaults, CFSTR(WebKitFontSmoothingContrastPreferenceKey), 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); + CFDictionaryAddValue(defaults, CFSTR(WebKitLocalStorageDatabasePathPreferenceKey), CFSTR("")); + + RetainPtr cacheModelRef(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%d"), WebCacheModelDocumentViewer)); + CFDictionaryAddValue(defaults, CFSTR(WebKitCacheModelPreferenceKey), cacheModelRef.get()); + + CFDictionaryAddValue(defaults, CFSTR(WebKitAuthorAndUserStylesEnabledPreferenceKey), kCFBooleanTrue); + CFDictionaryAddValue(defaults, CFSTR(WebKitApplicationChromeModePreferenceKey), kCFBooleanFalse); + + CFDictionaryAddValue(defaults, CFSTR(WebKitOfflineWebApplicationCacheEnabledPreferenceKey), kCFBooleanFalse); + + CFDictionaryAddValue(defaults, CFSTR(WebKitPaintNativeControlsPreferenceKey), kCFBooleanTrue); + + CFDictionaryAddValue(defaults, CFSTR(WebKitUseHighResolutionTimersPreferenceKey), kCFBooleanTrue); + + RetainPtr pluginAllowedRunTime(AdoptCF, CFStringCreateWithFormat(0, 0, CFSTR("%u"), numeric_limits::max())); + CFDictionaryAddValue(defaults, CFSTR(WebKitPluginAllowedRunTimePreferenceKey), pluginAllowedRunTime.get()); + + CFDictionaryAddValue(defaults, CFSTR(WebKitAcceleratedCompositingEnabledPreferenceKey), kCFBooleanFalse); + + CFDictionaryAddValue(defaults, CFSTR(WebKitShowDebugBordersPreferenceKey), kCFBooleanFalse); + + CFDictionaryAddValue(defaults, CFSTR(WebKitDNSPrefetchingEnabledPreferenceKey), kCFBooleanTrue); + + CFDictionaryAddValue(defaults, CFSTR(WebKitMemoryInfoEnabledPreferenceKey), kCFBooleanFalse); + + defaultSettings = defaults; +} + +RetainPtr WebPreferences::valueForKey(CFStringRef key) +{ + RetainPtr value = CFDictionaryGetValue(m_privatePrefs.get(), key); + if (value) + return value; + + value.adoptCF(CFPreferencesCopyAppValue(key, kCFPreferencesCurrentApplication)); + if (value) + return value; + + return CFDictionaryGetValue(defaultSettings, key); +} + +void WebPreferences::setValueForKey(CFStringRef key, CFPropertyListRef value) +{ + CFDictionarySetValue(m_privatePrefs.get(), key, value); + if (m_autoSaves) { + CFPreferencesSetAppValue(key, value, kCFPreferencesCurrentApplication); + save(); + } +} + +BSTR WebPreferences::stringValueForKey(CFStringRef key) +{ + RetainPtr value = valueForKey(key); + + if (!value || (CFGetTypeID(value.get()) != CFStringGetTypeID())) + return 0; + + CFStringRef str = static_cast(value.get()); + + 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) +{ + return numberValueForPreferencesValue(valueForKey(key).get()); +} + +BOOL WebPreferences::boolValueForKey(CFStringRef key) +{ + return booleanValueForPreferencesValue(valueForKey(key).get()); +} + +float WebPreferences::floatValueForKey(CFStringRef key) +{ + return numberValueForPreferencesValue(valueForKey(key).get()); +} + +LONGLONG WebPreferences::longlongValueForKey(CFStringRef key) +{ + return numberValueForPreferencesValue(valueForKey(key).get()); +} + +void WebPreferences::setStringValue(CFStringRef key, LPCTSTR value) +{ + BSTR val = stringValueForKey(key); + if (val && !_tcscmp(val, value)) + return; + SysFreeString(val); + + RetainPtr valueRef(AdoptCF, + CFStringCreateWithCharactersNoCopy(0, (UniChar*)_wcsdup(value), (CFIndex)_tcslen(value), kCFAllocatorMalloc)); + setValueForKey(key, valueRef.get()); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setIntegerValue(CFStringRef key, int value) +{ + if (integerValueForKey(key) == value) + return; + + setValueForKey(key, cfNumber(value).get()); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setFloatValue(CFStringRef key, float value) +{ + if (floatValueForKey(key) == value) + return; + + setValueForKey(key, cfNumber(value).get()); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setBoolValue(CFStringRef key, BOOL value) +{ + if (boolValueForKey(key) == value) + return; + + setValueForKey(key, value ? kCFBooleanTrue : kCFBooleanFalse); + + postPreferencesChangesNotification(); +} + +void WebPreferences::setLongLongValue(CFStringRef key, LONGLONG value) +{ + if (longlongValueForKey(key) == value) + return; + + setValueForKey(key, cfNumber(value).get()); + + postPreferencesChangesNotification(); +} + +BSTR WebPreferences::webPreferencesChangedNotification() +{ + static BSTR webPreferencesChangedNotification = SysAllocString(WebPreferencesChangedNotification); + return webPreferencesChangedNotification; +} + +BSTR WebPreferences::webPreferencesRemovedNotification() +{ + static BSTR webPreferencesRemovedNotification = SysAllocString(WebPreferencesRemovedNotification); + return webPreferencesRemovedNotification; +} + +void WebPreferences::save() +{ + CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication); +} + +void WebPreferences::load() +{ + initializeDefaultSettings(); + + m_privatePrefs.adoptCF(CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)); + + migrateWebKitPreferencesToCFPreferences(); +} + +void WebPreferences::migrateWebKitPreferencesToCFPreferences() +{ + CFStringRef didMigrateKey = CFSTR(WebKitDidMigrateWebKitPreferencesToCFPreferencesPreferenceKey); + if (boolValueForKey(didMigrateKey)) + return; + bool oldValue = m_autoSaves; + m_autoSaves = true; + setBoolValue(didMigrateKey, TRUE); + m_autoSaves = oldValue; + + WTF::CString path = oldPreferencesPath().utf8(); + + RetainPtr urlRef(AdoptCF, CFURLCreateFromFileSystemRepresentation(0, reinterpret_cast(path.data()), path.length(), false)); + if (!urlRef) + return; + + RetainPtr stream(AdoptCF, CFReadStreamCreateWithFile(0, urlRef.get())); + if (!stream) + return; + + if (!CFReadStreamOpen(stream.get())) + return; + + CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0 | kCFPropertyListXMLFormat_v1_0; + RetainPtr plist(AdoptCF, CFPropertyListCreateFromStream(0, stream.get(), 0, kCFPropertyListMutableContainersAndLeaves, &format, 0)); + CFReadStreamClose(stream.get()); + + if (!plist || CFGetTypeID(plist.get()) != CFDictionaryGetTypeID()) + return; + + copyWebKitPreferencesToCFPreferences(static_cast(plist.get())); + + deleteFile(oldPreferencesPath()); +} + +void WebPreferences::copyWebKitPreferencesToCFPreferences(CFDictionaryRef dict) +{ + ASSERT_ARG(dict, dict); + + int count = CFDictionaryGetCount(dict); + if (count <= 0) + return; + + CFStringRef didRemoveDefaultsKey = CFSTR(WebKitDidMigrateDefaultSettingsFromSafari3BetaPreferenceKey); + bool omitDefaults = !booleanValueForPreferencesValue(CFDictionaryGetValue(dict, didRemoveDefaultsKey)); + + OwnArrayPtr keys(new CFTypeRef[count]); + OwnArrayPtr values(new CFTypeRef[count]); + CFDictionaryGetKeysAndValues(dict, keys.get(), values.get()); + + for (int i = 0; i < count; ++i) { + if (!keys[i] || !values[i] || CFGetTypeID(keys[i]) != CFStringGetTypeID()) + continue; + + if (omitDefaults) { + CFTypeRef defaultValue = CFDictionaryGetValue(defaultSettings, keys[i]); + if (defaultValue && CFEqual(defaultValue, values[i])) + continue; + } + + setValueForKey(static_cast(keys[i]), values[i]); + } +} + +// IUnknown ------------------------------------------------------------------- + +HRESULT STDMETHODCALLTYPE WebPreferences::QueryInterface(REFIID riid, void** ppvObject) +{ + *ppvObject = 0; + if (IsEqualGUID(riid, IID_IUnknown)) + *ppvObject = static_cast(this); + else if (IsEqualGUID(riid, IID_IWebPreferences)) + *ppvObject = static_cast(this); + else if (IsEqualGUID(riid, IID_IWebPreferencesPrivate)) + *ppvObject = static_cast(this); + else if (IsEqualGUID(riid, CLSID_WebPreferences)) + *ppvObject = 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); + } + + this->postPreferencesChangesNotification(); + + 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::isWebSecurityEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitWebSecurityEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setWebSecurityEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitWebSecurityEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::allowUniversalAccessFromFileURLs( + /* [retval][out] */ BOOL* allowAccess) +{ + *allowAccess = boolValueForKey(CFSTR(WebKitAllowUniversalAccessFromFileURLsPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setAllowUniversalAccessFromFileURLs( + /* [in] */ BOOL allowAccess) +{ + setBoolValue(CFSTR(WebKitAllowUniversalAccessFromFileURLsPreferenceKey), allowAccess); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::allowFileAccessFromFileURLs( + /* [retval][out] */ BOOL* allowAccess) +{ + *allowAccess = boolValueForKey(CFSTR(WebKitAllowFileAccessFromFileURLsPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setAllowFileAccessFromFileURLs( + /* [in] */ BOOL allowAccess) +{ + setBoolValue(CFSTR(WebKitAllowFileAccessFromFileURLsPreferenceKey), allowAccess); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::javaScriptCanAccessClipboard( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitJavaScriptCanAccessClipboardPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setJavaScriptCanAccessClipboard( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitJavaScriptCanAccessClipboardPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::isXSSAuditorEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitXSSAuditorEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setXSSAuditorEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitXSSAuditorEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::isFrameFlatteningEnabled( + /* [retval][out] */ BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitFrameFlatteningEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setFrameFlatteningEnabled( + /* [in] */ BOOL enabled) +{ + setBoolValue(CFSTR(WebKitFrameFlatteningEnabledPreferenceKey), 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::unused1() +{ + ASSERT_NOT_REACHED(); + return E_FAIL; +} + +HRESULT WebPreferences::unused2() +{ + ASSERT_NOT_REACHED(); + return E_FAIL; +} + +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(WebKitFontSmoothingTypePreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setFontSmoothing( + /* [in] */ FontSmoothingType smoothingType) +{ + setIntegerValue(CFSTR(WebKitFontSmoothingTypePreferenceKey), smoothingType); + if (smoothingType == FontSmoothingTypeWindows) + smoothingType = FontSmoothingTypeMedium; +#if PLATFORM(CG) + wkSetFontSmoothingLevel((int)smoothingType); +#endif + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::fontSmoothingContrast( + /* [retval][out] */ float* contrast) +{ + *contrast = floatValueForKey(CFSTR(WebKitFontSmoothingContrastPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setFontSmoothingContrast( + /* [in] */ float contrast) +{ + setFloatValue(CFSTR(WebKitFontSmoothingContrastPreferenceKey), contrast); +#if PLATFORM(CG) + wkSetFontSmoothingContrast(contrast); +#endif + 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::editingBehavior( + /* [out, retval] */ WebKitEditingBehavior* editingBehavior) +{ + *editingBehavior = (WebKitEditingBehavior) integerValueForKey(CFSTR(WebKitEditingBehaviorPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setEditingBehavior( + /* [in] */ WebKitEditingBehavior behavior) +{ + setIntegerValue(CFSTR(WebKitEditingBehaviorPreferenceKey), 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::cacheModel(WebCacheModel* cacheModel) +{ + if (!cacheModel) + return E_POINTER; + + *cacheModel = (WebCacheModel)integerValueForKey(CFSTR(WebKitCacheModelPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setCacheModel(WebCacheModel cacheModel) +{ + setIntegerValue(CFSTR(WebKitCacheModelPreferenceKey), cacheModel); + return S_OK; +} + +HRESULT WebPreferences::setShouldPaintCustomScrollbars(BOOL shouldPaint) +{ + setBoolValue(CFSTR(WebKitPaintCustomScrollbarsPreferenceKey), shouldPaint); + return S_OK; +} + +HRESULT WebPreferences::shouldPaintCustomScrollbars(BOOL* shouldPaint) +{ + *shouldPaint = boolValueForKey(CFSTR(WebKitPaintCustomScrollbarsPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::shouldPaintNativeControls(BOOL* shouldPaint) +{ + *shouldPaint = boolValueForKey(CFSTR(WebKitPaintNativeControlsPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setShouldPaintNativeControls(BOOL shouldPaint) +{ + setBoolValue(CFSTR(WebKitPaintNativeControlsPreferenceKey), shouldPaint); + 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)); +} + +HRESULT WebPreferences::setAutomaticallyDetectsCacheModel(BOOL automaticallyDetectsCacheModel) +{ + m_automaticallyDetectsCacheModel = !!automaticallyDetectsCacheModel; + return S_OK; +} + +HRESULT WebPreferences::automaticallyDetectsCacheModel(BOOL* automaticallyDetectsCacheModel) +{ + if (!automaticallyDetectsCacheModel) + return E_POINTER; + + *automaticallyDetectsCacheModel = m_automaticallyDetectsCacheModel; + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setAuthorAndUserStylesEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitAuthorAndUserStylesEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::authorAndUserStylesEnabled(BOOL* enabled) +{ + if (!enabled) + return E_POINTER; + + *enabled = boolValueForKey(CFSTR(WebKitAuthorAndUserStylesEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::inApplicationChromeMode(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitApplicationChromeModePreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setApplicationChromeMode(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitApplicationChromeModePreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setOfflineWebApplicationCacheEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitOfflineWebApplicationCacheEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::offlineWebApplicationCacheEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitOfflineWebApplicationCacheEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setDatabasesEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitDatabasesEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::databasesEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitDatabasesEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setLocalStorageEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitLocalStorageEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::localStorageEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitLocalStorageEnabledPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::localStorageDatabasePath(BSTR* location) +{ + *location = stringValueForKey(CFSTR(WebKitLocalStorageDatabasePathPreferenceKey)); + return (*location) ? S_OK : E_FAIL; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setLocalStorageDatabasePath(BSTR location) +{ + setStringValue(CFSTR(WebKitLocalStorageDatabasePathPreferenceKey), location); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setExperimentalNotificationsEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitExperimentalNotificationsEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::experimentalNotificationsEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitExperimentalNotificationsEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setZoomsTextOnly(BOOL zoomsTextOnly) +{ + setBoolValue(CFSTR(WebKitZoomsTextOnlyPreferenceKey), zoomsTextOnly); + return S_OK; +} + +HRESULT WebPreferences::zoomsTextOnly(BOOL* zoomsTextOnly) +{ + *zoomsTextOnly = boolValueForKey(CFSTR(WebKitZoomsTextOnlyPreferenceKey)); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::setShouldUseHighResolutionTimers(BOOL useHighResolutionTimers) +{ + setBoolValue(CFSTR(WebKitUseHighResolutionTimersPreferenceKey), useHighResolutionTimers); + return S_OK; +} + +HRESULT STDMETHODCALLTYPE WebPreferences::shouldUseHighResolutionTimers(BOOL* useHighResolutionTimers) +{ + *useHighResolutionTimers = boolValueForKey(CFSTR(WebKitUseHighResolutionTimersPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setPluginAllowedRunTime(UINT allowedRunTime) +{ + setIntegerValue(CFSTR(WebKitPluginAllowedRunTimePreferenceKey), allowedRunTime); + return S_OK; +} + +HRESULT WebPreferences::pluginAllowedRunTime(UINT* allowedRunTime) +{ + *allowedRunTime = integerValueForKey(CFSTR(WebKitPluginAllowedRunTimePreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setPreferenceForTest(BSTR key, BSTR value) +{ + if (!SysStringLen(key) || !SysStringLen(value)) + return E_FAIL; + RetainPtr keyString(AdoptCF, CFStringCreateWithCharacters(0, reinterpret_cast(key), SysStringLen(key))); + RetainPtr valueString(AdoptCF, CFStringCreateWithCharacters(0, reinterpret_cast(value), SysStringLen(value))); + setValueForKey(keyString.get(), valueString.get()); + postPreferencesChangesNotification(); + return S_OK; +} + +HRESULT WebPreferences::setAcceleratedCompositingEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitAcceleratedCompositingEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::acceleratedCompositingEnabled(BOOL* enabled) +{ +#if USE(ACCELERATED_COMPOSITING) + *enabled = WKCACFLayerRenderer::acceleratedCompositingAvailable() && boolValueForKey(CFSTR(WebKitAcceleratedCompositingEnabledPreferenceKey)); +#else + *enabled = FALSE; +#endif + return S_OK; +} + +HRESULT WebPreferences::showDebugBorders(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitShowDebugBordersPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setShowDebugBorders(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitShowDebugBordersPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::showRepaintCounter(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitShowRepaintCounterPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setShowRepaintCounter(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitShowRepaintCounterPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::setCustomDragCursorsEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitCustomDragCursorsEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::customDragCursorsEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitCustomDragCursorsEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setDNSPrefetchingEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitDNSPrefetchingEnabledPreferenceKey), enabled); + return S_OK; +} + +HRESULT WebPreferences::isDNSPrefetchingEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitDNSPrefetchingEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::memoryInfoEnabled(BOOL* enabled) +{ + *enabled = boolValueForKey(CFSTR(WebKitMemoryInfoEnabledPreferenceKey)); + return S_OK; +} + +HRESULT WebPreferences::setMemoryInfoEnabled(BOOL enabled) +{ + setBoolValue(CFSTR(WebKitMemoryInfoEnabledPreferenceKey), enabled); + return S_OK; +} + +void WebPreferences::willAddToWebView() +{ + ++m_numWebViews; +} + +void WebPreferences::didRemoveFromWebView() +{ + ASSERT(m_numWebViews); + if (--m_numWebViews == 0) { + IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal(); + nc->postNotificationName(webPreferencesRemovedNotification(), static_cast(this), 0); + } +}