Enable Media query evaluation in the preload scanner

Source/core/css/MediaQueryEvaluator.h

 /*
  * CSS Media Query Evaluator
  *
  * Copyright (C) 2006 Kimmo Kinnunen <kimmo.t.kinnunen@nokia.com>.
  *
  * 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.
@@ skipping 22 matching lines @@
 
 namespace WebCore {
 class LocalFrame;
 class MediaQueryExp;
 class MediaQueryResult;
 class MediaQuerySet;
 class RenderStyle;
 
 typedef WillBeHeapVector<RefPtrWillBeMember<MediaQueryResult> > MediaQueryResultList;
 typedef WillBePersistentHeapVector<RefPtrWillBeMember<MediaQueryResult> > WillBePersistentMediaQueryResultList;
+class Document;
+
+class MediaValues : public RefCountedWillBeGarbageCollected<MediaValues> {

[Mads Ager (chromium), 2014/03/22 09:33:54]

As far as I can tell, there is no need to worry about Oilpan transition types in
this code yet. I would just make this RefCounted. I don't think any of the
objects that hold on to MediaValues are GarbageCollected yet and therefore the
oilpan build should continue to work without worrying about it for this one and
we will take care of it when we get there. :)

There are multiple things that would have to change in this code if you want to
keep this garbage collected. I don't want to spam this code review line by line
(since this is not needed right now) so I will just list a couple of things
here:

1. This needs to be GarbageCollectedFinalized because it needs the destructor of
the object to be called because it has a String field (which derefs a string
impl in its destructor).

2. For something that is GarbageCollected(Finalized) the create methods should
return raw pointers. So the create methods should use
PassRefPtrWillBeRawPtr<MediaValues> and the body should use adoptRefWillBeNoop.

3. The places where you hold on to a MediaValues pointer you are using a RefPtr.
With oilpan that translates to either a Persistent or a Member. Use a Persistent
if the object holding the pointer is *not* in the oilpan heap. A Persistent is a
root for the garbage collection and will keep the object pointed to alive. Use a
Member if the object holding the pointer *is* in the oilpan heap. You then need
to tell the garbage collector about the Member in the trace method of the object
containing the Member.

There is a very brief cheat sheet about how to transition here:
http://www.chromium.org/blink/blink-gc

All of the above would make the oilpan build fail. Most of them because of
normal compilation errors. And the rest will fail the verification of our clang
plugin.

+public:
+    // Should return a pointer that auto destructs when copied
+    static PassRefPtr<MediaValues> create(Document*);
+    static PassRefPtr<MediaValues> copy(const MediaValues*);
+
+    int getViewportWidth() { return m_viewportWidth; }
+    int getViewportHeight() { return m_viewportHeight; }
+    int getDeviceWidth() { return m_deviceWidth; }
+    int getDeviceHeight() { return m_deviceHeight; }
+    float getPixelRatio() { return m_pixelRatio; }
+    int getColorBitsPerComponent() { return m_colorBitsPerComponent; }
+    int getMonochromeBitsPerComponent() { return m_monochromeBitsPerComponent; }
+    int getPointer() { return m_pointer; }
+    int getDefaultFontSize() { return m_defaultFontSize; }
+    bool getThreeDEnabled() { return m_threeDEnabled; }
+    String getMediaType() { return m_mediaType; }
+
+private:
+    MediaValues(int viewportWidth,
+        int viewportHeight,
+        int deviceWidth,
+        int deviceHeight,
+        float pixelRatio,
+        int colorBitsPerComponent,
+        int monochromeBitsPerComponent,
+        int pointer,
+        int defaultFontSize,
+        int threeDEnabled,
+        String mediaType)
+        : m_viewportWidth(viewportWidth)
+        , m_viewportHeight(viewportHeight)
+        , m_deviceWidth(deviceWidth)
+        , m_deviceHeight(deviceHeight)
+        , m_pixelRatio(pixelRatio)
+        , m_colorBitsPerComponent(colorBitsPerComponent)
+        , m_monochromeBitsPerComponent(monochromeBitsPerComponent)
+        , m_pointer(pointer)
+        , m_defaultFontSize(defaultFontSize)
+        , m_threeDEnabled(threeDEnabled)
+        , m_mediaType(mediaType.isolatedCopy())
+    {
+    }
+
+    int m_viewportWidth;
+    int m_viewportHeight;
+    int m_deviceWidth;
+    int m_deviceHeight;
+    float m_pixelRatio;
+    int m_colorBitsPerComponent;
+    int m_monochromeBitsPerComponent;
+    int m_pointer;
+    int m_defaultFontSize;
+    bool m_threeDEnabled;
+    String m_mediaType;
+};
 
 /**
  * Class that evaluates css media queries as defined in
  * CSS3 Module "Media Queries" (http://www.w3.org/TR/css3-mediaqueries/)
  * Special constructors are needed, if simple media queries are to be
  * evaluated without knowledge of the medium features. This can happen
  * for example when parsing UA stylesheets, if evaluation is done
  * right after parsing.
  *
  * the boolean parameter is used to approximate results of evaluation, if
@@ skipping 12 matching lines @@
     /** Creates evaluator which evaluates only simple media queries
      *  Evaluator  returns true for acceptedMediaType and returns value of \mediafeatureResult
      *  for any media features
      */
     MediaQueryEvaluator(const String& acceptedMediaType, bool mediaFeatureResult = false);
     MediaQueryEvaluator(const char* acceptedMediaType, bool mediaFeatureResult = false);
 
     /** Creates evaluator which evaluates full media queries */
     MediaQueryEvaluator(const String& acceptedMediaType, LocalFrame*, RenderStyle*);
 
+    /** Creates evaluator which evaluates in a thread-safe manner a subset of media values
+     */
+    MediaQueryEvaluator(const String& acceptedMediaType, const MediaValues* , bool mediaFeatureResult);
+
     ~MediaQueryEvaluator();
 
     bool mediaTypeMatch(const String& mediaTypeToMatch) const;
     bool mediaTypeMatchSpecific(const char* mediaTypeToMatch) const;
 
     /** Evaluates a list of media queries */
     bool eval(const MediaQuerySet*, MediaQueryResultList* = 0) const;
 
     /** Evaluates media query subexpression, ie "and (media-feature: value)" part */
     bool eval(const MediaQueryExp*) const;
 
 private:
     String m_mediaType;
     LocalFrame* m_frame; // Not owned.
     RefPtr<RenderStyle> m_style;
     bool m_expResult;
+    RefPtr<MediaValues> m_mediaValues;
 };
 
 } // namespace
 #endif