[poc] curve-filter

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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
@@ skipping 42 matching lines @@
 #include "core/paint/PaintLayerStackingNodeIterator.h"
 #include "core/paint/PaintTiming.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "core/paint/TransformRecorder.h"
 #include "core/plugins/PluginView.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/BitmapImage.h"
+#include "platform/graphics/ColorSpaceFilter.h"
 #include "platform/graphics/GraphicsContext.h"
+#include "platform/graphics/GraphicsScreen.h"
 #include "platform/graphics/paint/ClipDisplayItem.h"
 #include "platform/graphics/paint/CullRect.h"
 #include "platform/graphics/paint/PaintController.h"
 #include "platform/graphics/paint/TransformDisplayItem.h"
 #include "public/platform/WebCompositorMutableProperties.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static IntRect clipBox(LayoutBox* layoutObject);
 
 static IntRect contentsRect(const LayoutObject* layoutObject)
@@ skipping 320 matching lines @@
     updateCompositedBounds();
 
     if (PaintLayerReflectionInfo* reflection = m_owningLayer.reflectionInfo()) {
         if (reflection->reflectionLayer()->hasCompositedLayerMapping())
             reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds();
     }
 
     PaintLayerCompositor* compositor = this->compositor();
     LayoutObject* layoutObject = this->layoutObject();
 
+    WillPaintForDevice device(Page::screenId(layoutObject->frame()->page()));
+
     bool layerConfigChanged = false;
     setBackgroundLayerPaintsFixedRootBackground(compositor->needsFixedRootBackgroundLayer(&m_owningLayer));
 
     // The background layer is currently only used for fixed root backgrounds.
     if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground))
         layerConfigChanged = true;
 
     if (updateForegroundLayer(compositor->needsContentsCompositingLayer(&m_owningLayer)))
         layerConfigChanged = true;
 
@@ skipping 105 matching lines @@
     updateBackgroundColor();
 
     if (layoutObject->isImage()) {
         if (isDirectlyCompositedImage()) {
             updateImageContents();
         } else if (m_graphicsLayer->hasContentsLayer()) {
             m_graphicsLayer->setContentsToImage(nullptr);
         }
     }
 
+    RefPtr<SkColorFilter> transform;
+
     if (WebLayer* layer = platformLayerForPlugin(layoutObject)) {
         m_graphicsLayer->setContentsToPlatformLayer(layer);
+        if (imageColorProfilesEnabled()) {
+            transform = createColorSpaceFilter(screenColorProfile(ScreenDevice::sRGB).get(), screenColorProfile(currentScreenId()).get());
+            m_graphicsLayer->setContentsLayerColorTransform(colorSpaceFlattenableFilter(transform.get()));
+            fprintf(stderr, "drawing plugin layer\n");
+            fflush(stderr);
+        }
     } else if (layoutObject->node() && layoutObject->node()->isFrameOwnerElement() && toHTMLFrameOwnerElement(layoutObject->node())->contentFrame()) {
         Frame* frame = toHTMLFrameOwnerElement(layoutObject->node())->contentFrame();
         if (frame->isRemoteFrame()) {
             WebLayer* layer = toRemoteFrame(frame)->remotePlatformLayer();
             m_graphicsLayer->setContentsToPlatformLayer(layer);
         }
     } else if (layoutObject->isVideo()) {
         HTMLMediaElement* mediaElement = toHTMLMediaElement(layoutObject->node());
         m_graphicsLayer->setContentsToPlatformLayer(mediaElement->platformLayer());
+        // FIXME: correctly handle the video element source color space rather than assuming sRGB as is done here.
+        if (imageColorProfilesEnabled()) {
+            transform = createColorSpaceFilter(screenColorProfile(ScreenDevice::sRGB).get(), screenColorProfile(currentScreenId()).get());
+            m_graphicsLayer->setContentsLayerColorTransform(colorSpaceFlattenableFilter(transform.get()));
+            fprintf(stderr, "drawing video layer\n");
+            fflush(stderr);
+        }
     } else if (isAcceleratedCanvas(layoutObject)) {
         HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject->node());
-        if (CanvasRenderingContext* context = canvas->renderingContext())
+        if (CanvasRenderingContext* context = canvas->renderingContext()) {
             m_graphicsLayer->setContentsToPlatformLayer(context->platformLayer());
+            if (imageColorProfilesEnabled()) {
+                transform = createColorSpaceFilter(screenColorProfile(ScreenDevice::sRGB).get(), screenColorProfile(currentScreenId()).get());
+                m_graphicsLayer->setContentsLayerColorTransform(colorSpaceFlattenableFilter(transform.get()));
+                fprintf(stderr, "drawing canvas layer\n");
+                fflush(stderr);
+            }
+        }
         layerConfigChanged = true;
     }
     if (layoutObject->isLayoutPart()) {
         if (PaintLayerCompositor::attachFrameContentLayersToIframeLayer(toLayoutPart(layoutObject)))
             layerConfigChanged = true;
     }
 
     // Changes to either the internal hierarchy or the mask layer have an impact
     // on painting phases, so we need to update when either are updated.
     if (layerConfigChanged || maskLayerChanged)
@@ skipping 1389 matching lines @@
     LayoutImage* imageLayoutObject = toLayoutImage(layoutObject());
 
     ImageResource* cachedImage = imageLayoutObject->cachedImage();
     if (!cachedImage)
         return;
 
     Image* image = cachedImage->image();
     if (!image)
         return;
 
+    WillPaintForDevice device(Page::screenId(layoutObject()->frame()->page()));
+
     // This is a no-op if the layer doesn't have an inner layer for the image.
     m_graphicsLayer->setContentsToImage(image, LayoutObject::shouldRespectImageOrientation(imageLayoutObject));
 
     m_graphicsLayer->setFilterQuality(layoutObject()->style()->imageRendering() == ImageRenderingPixelated ? kNone_SkFilterQuality : kLow_SkFilterQuality);
 
     // Prevent double-drawing: https://bugs.webkit.org/show_bug.cgi?id=58632
     updateDrawsContent();
 
     // Image animation is "lazy", in that it automatically stops unless someone is drawing
     // the image. So we have to kick the animation each time; this has the downside that the
@@ skipping 367 matching lines @@
 
 bool CompositedLayerMapping::needsRepaint() const
 {
     return m_owningLayer.needsRepaint();
 }
 
 void CompositedLayerMapping::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase graphicsLayerPaintingPhase, const IntRect& interestRect) const
 {
     // https://code.google.com/p/chromium/issues/detail?id=343772
     DisableCompositingQueryAsserts disabler;
+
+    WillPaintForDevice device(Page::screenId(layoutObject()->frame()->page()));
+
 #if ENABLE(ASSERT)
     // FIXME: once the state machine is ready, this can be removed and we can refer to that instead.
     if (Page* page = layoutObject()->frame()->page())
         page->setIsPainting(true);
 #endif
 
     TRACE_EVENT1("devtools.timeline", "Paint", "data", InspectorPaintEvent::data(m_owningLayer.layoutObject(), LayoutRect(interestRect), graphicsLayer));
 
     PaintLayerFlags paintLayerFlags = 0;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintBackground)
@@ skipping 35 matching lines @@
     } else if (graphicsLayer == layerForHorizontalScrollbar()) {
         paintScrollbar(m_owningLayer.scrollableArea()->horizontalScrollbar(), context, interestRect);
     } else if (graphicsLayer == layerForVerticalScrollbar()) {
         paintScrollbar(m_owningLayer.scrollableArea()->verticalScrollbar(), context, interestRect);
     } else if (graphicsLayer == layerForScrollCorner()) {
         IntPoint scrollCornerAndResizerLocation = m_owningLayer.scrollableArea()->scrollCornerAndResizerRect().location();
         CullRect cullRect(enclosingIntRect(interestRect));
         ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintScrollCorner(context, -scrollCornerAndResizerLocation, cullRect);
         ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintResizer(context, -scrollCornerAndResizerLocation, cullRect);
     }
+
     InspectorInstrumentation::didPaint(m_owningLayer.layoutObject(), graphicsLayer, context, LayoutRect(interestRect));
+
 #if ENABLE(ASSERT)
     if (Page* page = layoutObject()->frame()->page())
         page->setIsPainting(false);
 #endif
 }
 
 bool CompositedLayerMapping::isTrackingPaintInvalidations() const
 {
     GraphicsLayerClient* client = compositor();
     return client ? client->isTrackingPaintInvalidations() : false;
@@ skipping 171 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink