| /* |
| * Copyright (C) 2012 Google Inc. All rights reserved. |
| * Copyright (C) 2013 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 AND ITS CONTRIBUTORS "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 OR ITS 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 "core/testing/InternalSettings.h" |
| |
| #include "bindings/core/v8/ExceptionState.h" |
| #include "core/dom/ExceptionCode.h" |
| #include "core/frame/Settings.h" |
| #include "core/page/Page.h" |
| #include "platform/RuntimeEnabledFeatures.h" |
| #include "platform/Supplementable.h" |
| #include "platform/text/LocaleToScriptMapping.h" |
| |
| #define InternalSettingsGuardForSettingsReturn(returnValue) \ |
| if (!settings()) { \ |
| exceptionState.throwDOMException( \ |
| InvalidAccessError, "The settings object cannot be obtained."); \ |
| return returnValue; \ |
| } |
| |
| #define InternalSettingsGuardForSettings() \ |
| if (!GetSettings()) { \ |
| exception_state.ThrowDOMException( \ |
| kInvalidAccessError, "The settings object cannot be obtained."); \ |
| return; \ |
| } |
| |
| #define InternalSettingsGuardForPage() \ |
| if (!page()) { \ |
| exceptionState.throwDOMException(InvalidAccessError, \ |
| "The page object cannot be obtained."); \ |
| return; \ |
| } |
| |
| namespace blink { |
| |
| InternalSettings::Backup::Backup(Settings* settings) |
| : original_csp_(RuntimeEnabledFeatures:: |
| experimentalContentSecurityPolicyFeaturesEnabled()), |
| original_css_sticky_position_enabled_( |
| RuntimeEnabledFeatures::cssStickyPositionEnabled()), |
| original_overlay_scrollbars_enabled_( |
| RuntimeEnabledFeatures::overlayScrollbarsEnabled()), |
| original_editing_behavior_(settings->GetEditingBehaviorType()), |
| original_text_autosizing_enabled_(settings->TextAutosizingEnabled()), |
| original_text_autosizing_window_size_override_( |
| settings->TextAutosizingWindowSizeOverride()), |
| original_accessibility_font_scale_factor_( |
| settings->GetAccessibilityFontScaleFactor()), |
| original_media_type_override_(settings->GetMediaTypeOverride()), |
| original_display_mode_override_(settings->GetDisplayModeOverride()), |
| original_mock_scrollbars_enabled_(settings->MockScrollbarsEnabled()), |
| original_mock_gesture_tap_highlights_enabled_( |
| settings->GetMockGestureTapHighlightsEnabled()), |
| lang_attribute_aware_form_control_ui_enabled_( |
| RuntimeEnabledFeatures::langAttributeAwareFormControlUIEnabled()), |
| images_enabled_(settings->GetImagesEnabled()), |
| default_video_poster_url_(settings->GetDefaultVideoPosterURL()), |
| original_image_animation_policy_(settings->GetImageAnimationPolicy()), |
| original_scroll_top_left_interop_enabled_( |
| RuntimeEnabledFeatures::scrollTopLeftInteropEnabled()), |
| original_compositor_worker_enabled_( |
| RuntimeEnabledFeatures::compositorWorkerEnabled()) {} |
| |
| void InternalSettings::Backup::RestoreTo(Settings* settings) { |
| RuntimeEnabledFeatures::setExperimentalContentSecurityPolicyFeaturesEnabled( |
| original_csp_); |
| RuntimeEnabledFeatures::setCSSStickyPositionEnabled( |
| original_css_sticky_position_enabled_); |
| RuntimeEnabledFeatures::setOverlayScrollbarsEnabled( |
| original_overlay_scrollbars_enabled_); |
| settings->SetEditingBehaviorType(original_editing_behavior_); |
| settings->SetTextAutosizingEnabled(original_text_autosizing_enabled_); |
| settings->SetTextAutosizingWindowSizeOverride( |
| original_text_autosizing_window_size_override_); |
| settings->SetAccessibilityFontScaleFactor( |
| original_accessibility_font_scale_factor_); |
| settings->SetMediaTypeOverride(original_media_type_override_); |
| settings->SetDisplayModeOverride(original_display_mode_override_); |
| settings->SetMockScrollbarsEnabled(original_mock_scrollbars_enabled_); |
| settings->SetMockGestureTapHighlightsEnabled( |
| original_mock_gesture_tap_highlights_enabled_); |
| RuntimeEnabledFeatures::setLangAttributeAwareFormControlUIEnabled( |
| lang_attribute_aware_form_control_ui_enabled_); |
| settings->SetImagesEnabled(images_enabled_); |
| settings->SetDefaultVideoPosterURL(default_video_poster_url_); |
| settings->GetGenericFontFamilySettings().Reset(); |
| settings->SetImageAnimationPolicy(original_image_animation_policy_); |
| RuntimeEnabledFeatures::setScrollTopLeftInteropEnabled( |
| original_scroll_top_left_interop_enabled_); |
| RuntimeEnabledFeatures::setCompositorWorkerEnabled( |
| original_compositor_worker_enabled_); |
| } |
| |
| InternalSettings* InternalSettings::From(Page& page) { |
| if (!Supplement<Page>::From(page, SupplementName())) |
| Supplement<Page>::ProvideTo(page, SupplementName(), |
| new InternalSettings(page)); |
| return static_cast<InternalSettings*>( |
| Supplement<Page>::From(page, SupplementName())); |
| } |
| const char* InternalSettings::SupplementName() { |
| return "InternalSettings"; |
| } |
| |
| InternalSettings::~InternalSettings() {} |
| |
| InternalSettings::InternalSettings(Page& page) |
| : InternalSettingsGenerated(&page), |
| Supplement<Page>(page), |
| backup_(&page.GetSettings()) {} |
| |
| void InternalSettings::ResetToConsistentState() { |
| backup_.RestoreTo(GetSettings()); |
| backup_ = Backup(GetSettings()); |
| backup_.original_text_autosizing_enabled_ = |
| GetSettings()->TextAutosizingEnabled(); |
| |
| InternalSettingsGenerated::resetToConsistentState(); |
| } |
| |
| Settings* InternalSettings::GetSettings() const { |
| if (!GetPage()) |
| return 0; |
| return &GetPage()->GetSettings(); |
| } |
| |
| void InternalSettings::setMockScrollbarsEnabled( |
| bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetMockScrollbarsEnabled(enabled); |
| } |
| |
| void InternalSettings::setHideScrollbars(bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetHideScrollbars(enabled); |
| } |
| |
| void InternalSettings::setMockGestureTapHighlightsEnabled( |
| bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetMockGestureTapHighlightsEnabled(enabled); |
| } |
| |
| void InternalSettings::setCSSStickyPositionEnabled(bool enabled) { |
| RuntimeEnabledFeatures::setCSSStickyPositionEnabled(enabled); |
| } |
| |
| void InternalSettings::setExperimentalContentSecurityPolicyFeaturesEnabled( |
| bool enabled) { |
| RuntimeEnabledFeatures::setExperimentalContentSecurityPolicyFeaturesEnabled( |
| enabled); |
| } |
| |
| void InternalSettings::setOverlayScrollbarsEnabled(bool enabled) { |
| RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(enabled); |
| } |
| |
| void InternalSettings::setViewportEnabled(bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetViewportEnabled(enabled); |
| } |
| |
| void InternalSettings::setViewportMetaEnabled(bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetViewportMetaEnabled(enabled); |
| } |
| |
| void InternalSettings::setViewportStyle(const String& style, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| if (DeprecatedEqualIgnoringCase(style, "default")) |
| GetSettings()->SetViewportStyle(WebViewportStyle::kDefault); |
| else if (DeprecatedEqualIgnoringCase(style, "mobile")) |
| GetSettings()->SetViewportStyle(WebViewportStyle::kMobile); |
| else if (DeprecatedEqualIgnoringCase(style, "television")) |
| GetSettings()->SetViewportStyle(WebViewportStyle::kTelevision); |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, |
| "The viewport style type provided ('" + style + "') is invalid."); |
| } |
| |
| void InternalSettings::setStandardFontFamily(const AtomicString& family, |
| const String& script, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| UScriptCode code = ScriptNameToCode(script); |
| if (code == USCRIPT_INVALID_CODE) |
| return; |
| if (GetSettings()->GetGenericFontFamilySettings().UpdateStandard(family, |
| code)) |
| GetSettings()->NotifyGenericFontFamilyChange(); |
| } |
| |
| void InternalSettings::setSerifFontFamily(const AtomicString& family, |
| const String& script, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| UScriptCode code = ScriptNameToCode(script); |
| if (code == USCRIPT_INVALID_CODE) |
| return; |
| if (GetSettings()->GetGenericFontFamilySettings().UpdateSerif(family, code)) |
| GetSettings()->NotifyGenericFontFamilyChange(); |
| } |
| |
| void InternalSettings::setSansSerifFontFamily(const AtomicString& family, |
| const String& script, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| UScriptCode code = ScriptNameToCode(script); |
| if (code == USCRIPT_INVALID_CODE) |
| return; |
| if (GetSettings()->GetGenericFontFamilySettings().UpdateSansSerif(family, |
| code)) |
| GetSettings()->NotifyGenericFontFamilyChange(); |
| } |
| |
| void InternalSettings::setFixedFontFamily(const AtomicString& family, |
| const String& script, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| UScriptCode code = ScriptNameToCode(script); |
| if (code == USCRIPT_INVALID_CODE) |
| return; |
| if (GetSettings()->GetGenericFontFamilySettings().UpdateFixed(family, code)) |
| GetSettings()->NotifyGenericFontFamilyChange(); |
| } |
| |
| void InternalSettings::setCursiveFontFamily(const AtomicString& family, |
| const String& script, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| UScriptCode code = ScriptNameToCode(script); |
| if (code == USCRIPT_INVALID_CODE) |
| return; |
| if (GetSettings()->GetGenericFontFamilySettings().UpdateCursive(family, code)) |
| GetSettings()->NotifyGenericFontFamilyChange(); |
| } |
| |
| void InternalSettings::setFantasyFontFamily(const AtomicString& family, |
| const String& script, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| UScriptCode code = ScriptNameToCode(script); |
| if (code == USCRIPT_INVALID_CODE) |
| return; |
| if (GetSettings()->GetGenericFontFamilySettings().UpdateFantasy(family, code)) |
| GetSettings()->NotifyGenericFontFamilyChange(); |
| } |
| |
| void InternalSettings::setPictographFontFamily( |
| const AtomicString& family, |
| const String& script, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| UScriptCode code = ScriptNameToCode(script); |
| if (code == USCRIPT_INVALID_CODE) |
| return; |
| if (GetSettings()->GetGenericFontFamilySettings().UpdatePictograph(family, |
| code)) |
| GetSettings()->NotifyGenericFontFamilyChange(); |
| } |
| |
| void InternalSettings::setTextAutosizingEnabled( |
| bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetTextAutosizingEnabled(enabled); |
| } |
| |
| void InternalSettings::setTextAutosizingWindowSizeOverride( |
| int width, |
| int height, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetTextAutosizingWindowSizeOverride(IntSize(width, height)); |
| } |
| |
| void InternalSettings::setTextTrackKindUserPreference( |
| const String& preference, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| String token = preference.StripWhiteSpace(); |
| TextTrackKindUserPreference user_preference = |
| TextTrackKindUserPreference::kDefault; |
| if (token == "default") |
| user_preference = TextTrackKindUserPreference::kDefault; |
| else if (token == "captions") |
| user_preference = TextTrackKindUserPreference::kCaptions; |
| else if (token == "subtitles") |
| user_preference = TextTrackKindUserPreference::kSubtitles; |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, "The user preference for text track kind " + preference + |
| ")' is invalid."); |
| |
| GetSettings()->SetTextTrackKindUserPreference(user_preference); |
| } |
| |
| void InternalSettings::setMediaTypeOverride(const String& media_type, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetMediaTypeOverride(media_type); |
| } |
| |
| void InternalSettings::setAccessibilityFontScaleFactor( |
| float font_scale_factor, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetAccessibilityFontScaleFactor(font_scale_factor); |
| } |
| |
| void InternalSettings::setEditingBehavior(const String& editing_behavior, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| if (DeprecatedEqualIgnoringCase(editing_behavior, "win")) |
| GetSettings()->SetEditingBehaviorType(kEditingWindowsBehavior); |
| else if (DeprecatedEqualIgnoringCase(editing_behavior, "mac")) |
| GetSettings()->SetEditingBehaviorType(kEditingMacBehavior); |
| else if (DeprecatedEqualIgnoringCase(editing_behavior, "unix")) |
| GetSettings()->SetEditingBehaviorType(kEditingUnixBehavior); |
| else if (DeprecatedEqualIgnoringCase(editing_behavior, "android")) |
| GetSettings()->SetEditingBehaviorType(kEditingAndroidBehavior); |
| else |
| exception_state.ThrowDOMException(kSyntaxError, |
| "The editing behavior type provided ('" + |
| editing_behavior + "') is invalid."); |
| } |
| |
| void InternalSettings::setLangAttributeAwareFormControlUIEnabled(bool enabled) { |
| RuntimeEnabledFeatures::setLangAttributeAwareFormControlUIEnabled(enabled); |
| } |
| |
| void InternalSettings::setImagesEnabled(bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetImagesEnabled(enabled); |
| } |
| |
| void InternalSettings::setDefaultVideoPosterURL( |
| const String& url, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetDefaultVideoPosterURL(url); |
| } |
| |
| DEFINE_TRACE(InternalSettings) { |
| InternalSettingsGenerated::Trace(visitor); |
| Supplement<Page>::Trace(visitor); |
| } |
| |
| void InternalSettings::setAvailablePointerTypes( |
| const String& pointers, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| |
| // Allow setting multiple pointer types by passing comma seperated list |
| // ("coarse,fine"). |
| Vector<String> tokens; |
| pointers.Split(",", false, tokens); |
| |
| int pointer_types = 0; |
| for (size_t i = 0; i < tokens.size(); ++i) { |
| String token = tokens[i].StripWhiteSpace(); |
| |
| if (token == "coarse") |
| pointer_types |= kPointerTypeCoarse; |
| else if (token == "fine") |
| pointer_types |= kPointerTypeFine; |
| else if (token == "none") |
| pointer_types |= kPointerTypeNone; |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, "The pointer type token ('" + token + ")' is invalid."); |
| } |
| |
| GetSettings()->SetAvailablePointerTypes(pointer_types); |
| } |
| |
| void InternalSettings::setDisplayModeOverride(const String& display_mode, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| String token = display_mode.StripWhiteSpace(); |
| |
| WebDisplayMode mode = kWebDisplayModeBrowser; |
| if (token == "browser") |
| mode = kWebDisplayModeBrowser; |
| else if (token == "minimal-ui") |
| mode = kWebDisplayModeMinimalUi; |
| else if (token == "standalone") |
| mode = kWebDisplayModeStandalone; |
| else if (token == "fullscreen") |
| mode = kWebDisplayModeFullscreen; |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, "The display-mode token ('" + token + ")' is invalid."); |
| |
| GetSettings()->SetDisplayModeOverride(mode); |
| } |
| |
| void InternalSettings::setPrimaryPointerType(const String& pointer, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| String token = pointer.StripWhiteSpace(); |
| |
| PointerType type = kPointerTypeNone; |
| if (token == "coarse") |
| type = kPointerTypeCoarse; |
| else if (token == "fine") |
| type = kPointerTypeFine; |
| else if (token == "none") |
| type = kPointerTypeNone; |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, "The pointer type token ('" + token + ")' is invalid."); |
| |
| GetSettings()->SetPrimaryPointerType(type); |
| } |
| |
| void InternalSettings::setAvailableHoverTypes(const String& types, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| |
| // Allow setting multiple hover types by passing comma seperated list |
| // ("on-demand,none"). |
| Vector<String> tokens; |
| types.Split(",", false, tokens); |
| |
| int hover_types = 0; |
| for (size_t i = 0; i < tokens.size(); ++i) { |
| String token = tokens[i].StripWhiteSpace(); |
| |
| if (token == "none") |
| hover_types |= kHoverTypeNone; |
| else if (token == "hover") |
| hover_types |= kHoverTypeHover; |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, "The hover type token ('" + token + ")' is invalid."); |
| } |
| |
| GetSettings()->SetAvailableHoverTypes(hover_types); |
| } |
| |
| void InternalSettings::setPrimaryHoverType(const String& type, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| String token = type.StripWhiteSpace(); |
| |
| HoverType hover_type = kHoverTypeNone; |
| if (token == "none") |
| hover_type = kHoverTypeNone; |
| else if (token == "hover") |
| hover_type = kHoverTypeHover; |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, "The hover type token ('" + token + ")' is invalid."); |
| |
| GetSettings()->SetPrimaryHoverType(hover_type); |
| } |
| |
| void InternalSettings::setImageAnimationPolicy( |
| const String& policy, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| if (DeprecatedEqualIgnoringCase(policy, "allowed")) |
| GetSettings()->SetImageAnimationPolicy(kImageAnimationPolicyAllowed); |
| else if (DeprecatedEqualIgnoringCase(policy, "once")) |
| GetSettings()->SetImageAnimationPolicy(kImageAnimationPolicyAnimateOnce); |
| else if (DeprecatedEqualIgnoringCase(policy, "none")) |
| GetSettings()->SetImageAnimationPolicy(kImageAnimationPolicyNoAnimation); |
| else |
| exception_state.ThrowDOMException( |
| kSyntaxError, |
| "The image animation policy provided ('" + policy + "') is invalid."); |
| } |
| |
| void InternalSettings::setScrollTopLeftInteropEnabled(bool enabled) { |
| RuntimeEnabledFeatures::setScrollTopLeftInteropEnabled(enabled); |
| } |
| |
| void InternalSettings::SetDnsPrefetchLogging(bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetLogDnsPrefetchAndPreconnect(enabled); |
| } |
| |
| void InternalSettings::SetPreloadLogging(bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetLogPreload(enabled); |
| } |
| |
| void InternalSettings::setCompositorWorkerEnabled( |
| bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| RuntimeEnabledFeatures::setCompositorWorkerEnabled(enabled); |
| } |
| |
| void InternalSettings::setPresentationReceiver( |
| bool enabled, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| GetSettings()->SetPresentationReceiver(enabled); |
| } |
| |
| void InternalSettings::setAutoplayPolicy(const String& policy_str, |
| ExceptionState& exception_state) { |
| InternalSettingsGuardForSettings(); |
| |
| AutoplayPolicy::Type policy = AutoplayPolicy::Type::kNoUserGestureRequired; |
| if (policy_str == "no-user-gesture-required") { |
| policy = AutoplayPolicy::Type::kNoUserGestureRequired; |
| } else if (policy_str == "user-gesture-required") { |
| policy = AutoplayPolicy::Type::kUserGestureRequired; |
| } else if (policy_str == "user-gesture-required-for-cross-origin") { |
| policy = AutoplayPolicy::Type::kUserGestureRequiredForCrossOrigin; |
| } else if (policy_str == "document-user-activation-required") { |
| policy = AutoplayPolicy::Type::kDocumentUserActivationRequired; |
| } else { |
| exception_state.ThrowDOMException( |
| kSyntaxError, "The autoplay policy ('" + policy_str + ")' is invalid."); |
| } |
| |
| GetSettings()->SetAutoplayPolicy(policy); |
| } |
| |
| } // namespace blink |
