Create MediaValuesCached and TokenPreloadScanner on the parser thread

third_party/WebKit/Source/core/css/MediaValuesCached.cpp

 // 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/MediaValuesCached.h"
 
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/dom/Document.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutObject.h"
 
 namespace blink {
 
+MediaValuesCached::MediaValuesCachedData::MediaValuesCachedData(Document& document)
+    : MediaValuesCached::MediaValuesCachedData()
+{
+    ASSERT(isMainThread());
+    LocalFrame* frame = MediaValues::frameFrom(document);
+    // FIXME - Added an assert here so we can better understand when a frame is present without its view().

[Yoav Weiss, 2016/02/01 09:29:30]

I think we can now safely conclude that this doesn't really happen, so the
frame->view() condition check can be eliminated. Maybe in a different CL though

[haraken, 2016/02/01 11:09:16]

FIXME => TODO(hiroshige)

[hiroshige, 2016/02/06 10:08:44]

Done. I'll create another CL.

Is this because Issues 367210 and 371084 are fixed?

+    ASSERT(!frame || frame->view());
+    if (frame && frame->view()) {
+        ASSERT(frame->document() && frame->document()->layoutView());
+
+        // In case that frame is missing (e.g. for images that their document does not have a frame)
+        // We simply leave the MediaValues object with the default MediaValuesCachedData values.
+        viewportWidth = MediaValues::calculateViewportWidth(frame);
+        viewportHeight = MediaValues::calculateViewportHeight(frame);
+        deviceWidth = MediaValues::calculateDeviceWidth(frame);
+        deviceHeight = MediaValues::calculateDeviceHeight(frame);
+        devicePixelRatio = MediaValues::calculateDevicePixelRatio(frame);
+        colorBitsPerComponent = MediaValues::calculateColorBitsPerComponent(frame);
+        monochromeBitsPerComponent = MediaValues::calculateMonochromeBitsPerComponent(frame);
+        primaryPointerType = MediaValues::calculatePrimaryPointerType(frame);
+        availablePointerTypes = MediaValues::calculateAvailablePointerTypes(frame);
+        primaryHoverType = MediaValues::calculatePrimaryHoverType(frame);
+        availableHoverTypes = MediaValues::calculateAvailableHoverTypes(frame);
+        defaultFontSize = MediaValues::calculateDefaultFontSize(frame);
+        threeDEnabled = MediaValues::calculateThreeDEnabled(frame);
+        strictMode = MediaValues::calculateStrictMode(frame);
+        displayMode = MediaValues::calculateDisplayMode(frame);
+        mediaType = MediaValues::calculateMediaType(frame);
+    }
+}
+
 PassRefPtrWillBeRawPtr<MediaValuesCached> MediaValuesCached::create()
 {
     return adoptRefWillBeNoop(new MediaValuesCached());
 }
 
-PassRefPtrWillBeRawPtr<MediaValuesCached> MediaValuesCached::create(MediaValuesCachedData& data)
+PassRefPtrWillBeRawPtr<MediaValuesCached> MediaValuesCached::create(const MediaValuesCachedData& data)
 {
     return adoptRefWillBeNoop(new MediaValuesCached(data));
 }
 
-PassRefPtrWillBeRawPtr<MediaValuesCached> MediaValuesCached::create(Document& document)
-{
-    return MediaValuesCached::create(frameFrom(document));
-}
-
-PassRefPtrWillBeRawPtr<MediaValuesCached> MediaValuesCached::create(LocalFrame* frame)
-{
-    // FIXME - Added an assert here so we can better understand when a frame is present without its view().
-    ASSERT(!frame || frame->view());
-    if (!frame || !frame->view())
-        return adoptRefWillBeNoop(new MediaValuesCached());
-    ASSERT(frame->document() && frame->document()->layoutView());
-    return adoptRefWillBeNoop(new MediaValuesCached(frame));
-}
-
 MediaValuesCached::MediaValuesCached()
 {
 }
 
-MediaValuesCached::MediaValuesCached(LocalFrame* frame)
-{
-    ASSERT(isMainThread());
-    ASSERT(frame);
-    // In case that frame is missing (e.g. for images that their document does not have a frame)
-    // We simply leave the MediaValues object with the default MediaValuesCachedData values.
-    m_data.viewportWidth = calculateViewportWidth(frame);
-    m_data.viewportHeight = calculateViewportHeight(frame);
-    m_data.deviceWidth = calculateDeviceWidth(frame);
-    m_data.deviceHeight = calculateDeviceHeight(frame);
-    m_data.devicePixelRatio = calculateDevicePixelRatio(frame);
-    m_data.colorBitsPerComponent = calculateColorBitsPerComponent(frame);
-    m_data.monochromeBitsPerComponent = calculateMonochromeBitsPerComponent(frame);
-    m_data.primaryPointerType = calculatePrimaryPointerType(frame);
-    m_data.availablePointerTypes = calculateAvailablePointerTypes(frame);
-    m_data.primaryHoverType = calculatePrimaryHoverType(frame);
-    m_data.availableHoverTypes = calculateAvailableHoverTypes(frame);
-    m_data.defaultFontSize = calculateDefaultFontSize(frame);
-    m_data.threeDEnabled = calculateThreeDEnabled(frame);
-    m_data.strictMode = calculateStrictMode(frame);
-    m_data.displayMode = calculateDisplayMode(frame);
-    const String mediaType = calculateMediaType(frame);
-    if (!mediaType.isEmpty())
-        m_data.mediaType = mediaType.isolatedCopy();
-}
-
 MediaValuesCached::MediaValuesCached(const MediaValuesCachedData& data)
     : m_data(data)
 {
 }
 
 PassRefPtrWillBeRawPtr<MediaValues> MediaValuesCached::copy() const
 {
     return adoptRefWillBeNoop(new MediaValuesCached(m_data));
 }
 
 bool MediaValuesCached::computeLength(double value, CSSPrimitiveValue::UnitType type, int& result) const
 {
     return MediaValues::computeLength(value, type, m_data.defaultFontSize, m_data.viewportWidth, m_data.viewportHeight, result);
 }
 
 bool MediaValuesCached::computeLength(double value, CSSPrimitiveValue::UnitType type, double& result) const
 {
     return MediaValues::computeLength(value, type, m_data.defaultFontSize, m_data.viewportWidth, m_data.viewportHeight, result);
 }
 
-bool MediaValuesCached::isSafeToSendToAnotherThread() const
-{
-#if ENABLE(OILPAN)
-    // Oilpan objects are safe to send to another thread as long as the thread
-    // does not outlive the thread used for creation. MediaValues are
-    // allocated on the main thread and may be passed to the parser thread,
-    // so this should be safe.
-    return true;
-#else
-    return hasOneRef();
-#endif
-}
-
 double MediaValuesCached::viewportWidth() const
 {
     return m_data.viewportWidth;
 }
 
 double MediaValuesCached::viewportHeight() const
 {
     return m_data.viewportHeight;
 }
 
@@ skipping 76 matching lines @@
 {
     m_data.viewportWidth = width;
 }
 
 void MediaValuesCached::setViewportHeight(double height)
 {
     m_data.viewportHeight = height;
 }
 
 } // namespace blink