| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "core/css/MediaValues.h" |
| |
| #include "core/css/CSSHelper.h" |
| #include "core/css/MediaValuesCached.h" |
| #include "core/css/MediaValuesDynamic.h" |
| #include "core/dom/Document.h" |
| #include "core/dom/Element.h" |
| #include "core/frame/FrameView.h" |
| #include "core/frame/LocalFrame.h" |
| #include "core/frame/Settings.h" |
| #include "core/html/imports/HTMLImportsController.h" |
| #include "core/layout/LayoutObject.h" |
| #include "core/layout/api/LayoutViewItem.h" |
| #include "core/layout/compositing/PaintLayerCompositor.h" |
| #include "core/page/ChromeClient.h" |
| #include "core/page/Page.h" |
| #include "core/style/ComputedStyle.h" |
| #include "platform/graphics/ColorSpace.h" |
| #include "public/platform/WebScreenInfo.h" |
| |
| namespace blink { |
| |
| MediaValues* MediaValues::createDynamicIfFrameExists(LocalFrame* frame) { |
| if (frame) |
| return MediaValuesDynamic::create(frame); |
| return MediaValuesCached::create(); |
| } |
| |
| double MediaValues::calculateViewportWidth(LocalFrame* frame) { |
| ASSERT(frame && frame->view() && frame->document()); |
| return frame->view()->viewportSizeForMediaQueries().width(); |
| } |
| |
| double MediaValues::calculateViewportHeight(LocalFrame* frame) { |
| ASSERT(frame && frame->view() && frame->document()); |
| return frame->view()->viewportSizeForMediaQueries().height(); |
| } |
| |
| int MediaValues::calculateDeviceWidth(LocalFrame* frame) { |
| DCHECK(frame && frame->view() && frame->settings() && frame->page()); |
| blink::WebScreenInfo screenInfo = frame->page()->chromeClient().screenInfo(); |
| int deviceWidth = screenInfo.rect.width; |
| if (frame->settings()->getReportScreenSizeInPhysicalPixelsQuirk()) |
| deviceWidth = lroundf(deviceWidth * screenInfo.deviceScaleFactor); |
| return deviceWidth; |
| } |
| |
| int MediaValues::calculateDeviceHeight(LocalFrame* frame) { |
| DCHECK(frame && frame->view() && frame->settings() && frame->page()); |
| blink::WebScreenInfo screenInfo = frame->page()->chromeClient().screenInfo(); |
| int deviceHeight = screenInfo.rect.height; |
| if (frame->settings()->getReportScreenSizeInPhysicalPixelsQuirk()) |
| deviceHeight = lroundf(deviceHeight * screenInfo.deviceScaleFactor); |
| return deviceHeight; |
| } |
| |
| bool MediaValues::calculateStrictMode(LocalFrame* frame) { |
| ASSERT(frame && frame->document()); |
| return !frame->document()->inQuirksMode(); |
| } |
| |
| float MediaValues::calculateDevicePixelRatio(LocalFrame* frame) { |
| return frame->devicePixelRatio(); |
| } |
| |
| int MediaValues::calculateColorBitsPerComponent(LocalFrame* frame) { |
| ASSERT(frame && frame->page() && frame->page()->mainFrame()); |
| if (!frame->page()->mainFrame()->isLocalFrame() || |
| frame->page()->chromeClient().screenInfo().isMonochrome) |
| return 0; |
| return frame->page()->chromeClient().screenInfo().depthPerComponent; |
| } |
| |
| int MediaValues::calculateMonochromeBitsPerComponent(LocalFrame* frame) { |
| ASSERT(frame && frame->page() && frame->page()->mainFrame()); |
| if (!frame->page()->mainFrame()->isLocalFrame() || |
| !frame->page()->chromeClient().screenInfo().isMonochrome) |
| return 0; |
| return frame->page()->chromeClient().screenInfo().depthPerComponent; |
| } |
| |
| int MediaValues::calculateDefaultFontSize(LocalFrame* frame) { |
| return frame->page()->settings().getDefaultFontSize(); |
| } |
| |
| const String MediaValues::calculateMediaType(LocalFrame* frame) { |
| ASSERT(frame); |
| if (!frame->view()) |
| return emptyAtom; |
| return frame->view()->mediaType(); |
| } |
| |
| WebDisplayMode MediaValues::calculateDisplayMode(LocalFrame* frame) { |
| ASSERT(frame); |
| WebDisplayMode mode = frame->page()->settings().getDisplayModeOverride(); |
| |
| if (mode != WebDisplayModeUndefined) |
| return mode; |
| |
| if (!frame->view()) |
| return WebDisplayModeBrowser; |
| |
| return frame->view()->displayMode(); |
| } |
| |
| bool MediaValues::calculateThreeDEnabled(LocalFrame* frame) { |
| ASSERT(frame && !frame->contentLayoutItem().isNull() && |
| frame->contentLayoutItem().compositor()); |
| bool threeDEnabled = false; |
| if (LayoutViewItem view = frame->contentLayoutItem()) |
| threeDEnabled = view.compositor()->hasAcceleratedCompositing(); |
| return threeDEnabled; |
| } |
| |
| PointerType MediaValues::calculatePrimaryPointerType(LocalFrame* frame) { |
| ASSERT(frame && frame->settings()); |
| return frame->settings()->getPrimaryPointerType(); |
| } |
| |
| int MediaValues::calculateAvailablePointerTypes(LocalFrame* frame) { |
| ASSERT(frame && frame->settings()); |
| return frame->settings()->getAvailablePointerTypes(); |
| } |
| |
| HoverType MediaValues::calculatePrimaryHoverType(LocalFrame* frame) { |
| ASSERT(frame && frame->settings()); |
| return frame->settings()->getPrimaryHoverType(); |
| } |
| |
| int MediaValues::calculateAvailableHoverTypes(LocalFrame* frame) { |
| ASSERT(frame && frame->settings()); |
| return frame->settings()->getAvailableHoverTypes(); |
| } |
| |
| DisplayShape MediaValues::calculateDisplayShape(LocalFrame* frame) { |
| DCHECK(frame && frame->page()); |
| return frame->page()->chromeClient().screenInfo().displayShape; |
| } |
| |
| ColorSpaceGamut MediaValues::calculateColorGamut(LocalFrame* frame) { |
| DCHECK(frame && frame->page()); |
| return ColorSpaceUtilities::getColorSpaceGamut( |
| frame->page()->chromeClient().screenInfo()); |
| } |
| |
| bool MediaValues::computeLengthImpl(double value, |
| CSSPrimitiveValue::UnitType type, |
| unsigned defaultFontSize, |
| double viewportWidth, |
| double viewportHeight, |
| double& result) { |
| // The logic in this function is duplicated from |
| // CSSToLengthConversionData::zoomedComputedPixels() because |
| // MediaValues::computeLength() needs nearly identical logic, but we haven't |
| // found a way to make CSSToLengthConversionData::zoomedComputedPixels() more |
| // generic (to solve both cases) without hurting performance. |
| // FIXME - Unite the logic here with CSSToLengthConversionData in a performant |
| // way. |
| switch (type) { |
| case CSSPrimitiveValue::UnitType::Ems: |
| case CSSPrimitiveValue::UnitType::Rems: |
| result = value * defaultFontSize; |
| return true; |
| case CSSPrimitiveValue::UnitType::Pixels: |
| case CSSPrimitiveValue::UnitType::UserUnits: |
| result = value; |
| return true; |
| case CSSPrimitiveValue::UnitType::Exs: |
| // FIXME: We have a bug right now where the zoom will be applied twice to EX |
| // units. |
| case CSSPrimitiveValue::UnitType::Chs: |
| // FIXME: We don't seem to be able to cache fontMetrics related values. |
| // Trying to access them is triggering some sort of microtask. Serving the |
| // spec's default instead. |
| result = (value * defaultFontSize) / 2.0; |
| return true; |
| case CSSPrimitiveValue::UnitType::ViewportWidth: |
| result = (value * viewportWidth) / 100.0; |
| return true; |
| case CSSPrimitiveValue::UnitType::ViewportHeight: |
| result = (value * viewportHeight) / 100.0; |
| return true; |
| case CSSPrimitiveValue::UnitType::ViewportMin: |
| result = (value * std::min(viewportWidth, viewportHeight)) / 100.0; |
| return true; |
| case CSSPrimitiveValue::UnitType::ViewportMax: |
| result = (value * std::max(viewportWidth, viewportHeight)) / 100.0; |
| return true; |
| case CSSPrimitiveValue::UnitType::Centimeters: |
| result = value * cssPixelsPerCentimeter; |
| return true; |
| case CSSPrimitiveValue::UnitType::Millimeters: |
| result = value * cssPixelsPerMillimeter; |
| return true; |
| case CSSPrimitiveValue::UnitType::Inches: |
| result = value * cssPixelsPerInch; |
| return true; |
| case CSSPrimitiveValue::UnitType::Points: |
| result = value * cssPixelsPerPoint; |
| return true; |
| case CSSPrimitiveValue::UnitType::Picas: |
| result = value * cssPixelsPerPica; |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| LocalFrame* MediaValues::frameFrom(Document& document) { |
| Document* executingDocument = document.importsController() |
| ? document.importsController()->master() |
| : &document; |
| ASSERT(executingDocument); |
| return executingDocument->frame(); |
| } |
| |
| } // namespace blink |