Add some plumbing for the color management of canvases

third_party/WebKit/Source/core/html/canvas/CanvasRenderingContext.h

 /*
  * Copyright (C) 2009 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 11 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CanvasRenderingContext_h
 #define CanvasRenderingContext_h
 
 #include "core/CoreExport.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/offscreencanvas/OffscreenCanvas.h"
+#include "third_party/skia/include/core/SkColorSpace.h"
 #include "wtf/HashSet.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/text/StringHash.h"
 
 class SkCanvas;
 
-namespace blink { class WebLayer; }
-
 namespace blink {
 
 class CanvasImageSource;
 class HTMLCanvasElement;
 class ImageData;
 class ImageBitmap;
+class WebLayer;
+
+enum CanvasColorSpace {
+    kLegacyCanvasColorSpace,
+    kSRGBCanvasColorSpace,
+    kLinearRGBCanvasColorSpace,
+};
 
 class CORE_EXPORT CanvasRenderingContext : public GarbageCollectedFinalized<CanvasRenderingContext>, public ScriptWrappable {
     WTF_MAKE_NONCOPYABLE(CanvasRenderingContext);
     USING_PRE_FINALIZER(CanvasRenderingContext, dispose);
 public:
     virtual ~CanvasRenderingContext() { }
 
     // A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing
     // context is already 2D, just return that. If the existing context is WebGL, then destroy it
     // before creating a new 2D context. Vice versa when requesting a WebGL canvas. Requesting a
     // context with any other type string will destroy any existing context.
     enum ContextType {
         // Do not change assigned numbers of existing items: add new features to the end of the list.
         Context2d = 0,
         ContextExperimentalWebgl = 2,
         ContextWebgl = 3,
         ContextWebgl2 = 4,
         ContextImageBitmap = 5,
         ContextTypeCount,
     };
 
     static ContextType contextTypeFromId(const String& id);
     static ContextType resolveContextTypeAliases(ContextType);
 
     HTMLCanvasElement* canvas() const { return m_canvas; }
 
+    CanvasColorSpace colorSpace() const { return m_colorSpace; };
+    WTF::String colorSpaceAsString() const;
+    sk_sp<SkColorSpace> skColorSpace() const;
+
     virtual ContextType getContextType() const = 0;
     virtual bool isAccelerated() const { return false; }
     virtual bool shouldAntialias() const { return false; }
     virtual bool hasAlpha() const { return true; }
     virtual void setIsHidden(bool) = 0;
     virtual bool isContextLost() const { return true; }
     virtual void setCanvasGetContextResult(RenderingContext&) { NOTREACHED(); };
     virtual void setOffscreenCanvasGetContextResult(OffscreenRenderingContext&) { NOTREACHED(); }
 
     // Return true if the content is updated.
@@ skipping 45 matching lines @@
     bool wouldTaintOrigin(CanvasImageSource*, SecurityOrigin* = nullptr);
     void didMoveToNewDocument(Document*);
 
     // OffscreenCanvas-specific methods
     OffscreenCanvas* getOffscreenCanvas() const { return m_offscreenCanvas; }
     virtual ImageBitmap* transferToImageBitmap(ExceptionState&) { return nullptr; }
 
     void detachCanvas() { m_canvas = nullptr; }
 
 protected:
-    CanvasRenderingContext(HTMLCanvasElement* = nullptr, OffscreenCanvas* = nullptr);
+    CanvasRenderingContext(HTMLCanvasElement*, OffscreenCanvas*, const String& colorSpace);

[Stephen White, 2016/08/11 20:41:27]

As discussed, I think we should pass in (a ref to) the whole
CanvasContextCreationAttributes struct, and have the base class here pull out
the ones it's interested in. It'll keep the constructor args from ballooning in
the future, and allow us to centralize more attribute handling between 2D &
WebGL where that makes sense.

[Justin Novosad, 2016/08/12 17:40:18]

Done.  This was a bit more complicated than anticipated: I had to change all the
attribute plumbing on the WebGL side so that the generic attributes (not the
WebGL-specif ones) can be handed down to the base class constructor.  It's
better this way.

     DECLARE_VIRTUAL_TRACE();
     virtual void stop() = 0;
 
 private:
     void dispose();
 
     Member<HTMLCanvasElement> m_canvas;
     Member<OffscreenCanvas> m_offscreenCanvas;
     HashSet<String> m_cleanURLs;
     HashSet<String> m_dirtyURLs;
+    CanvasColorSpace m_colorSpace;
 };
 
 } // namespace blink
 
 #endif