HDR: Do nonlinear blending in the compositor

ui/compositor/compositor.cc

Index: ui/compositor/compositor.cc
diff --git a/ui/compositor/compositor.cc b/ui/compositor/compositor.cc
index 7b49226117e98b6404fd73ce160cc5eb36c579d5..f438b216f1d17ee15a8929d81267630ef372030d 100644
--- a/ui/compositor/compositor.cc
+++ b/ui/compositor/compositor.cc
@@ -163,10 +163,10 @@ Compositor::Compositor(const cc::FrameSinkId& frame_sink_id,
 
   settings.enable_color_correct_rendering =
       command_line->HasSwitch(cc::switches::kEnableColorCorrectRendering) ||
-      command_line->HasSwitch(cc::switches::kEnableTrueColorRendering) ||
-      command_line->HasSwitch(switches::kEnableHDROutput);
+      command_line->HasSwitch(cc::switches::kEnableTrueColorRendering);

[ccameron, 2017/03/05 21:08:48]

This makes it so that HDR doesn't opt us into doing color-aware rasterization
(just compositing).

Color-aware rasterization won't be ready as early as HDR. We'll probably want to
limit rasterization to sRGB gamut in HDR mode, since that's the only way to get
colors to match.

[enne (OOO), 2017/03/06 19:56:12]

Sorry to be confused, I'm a little lost in the sea of settings we have now. 
There's now three command line flags (color correct, true color, hdr output) and
two settings (LayerTreeSetting, RendererSettings).  This is my understanding:

color correct switch = raster is done in output color space (but "legacy"
blending), all resources converted at compositor at draw time (draw time also
uses legacy blending, I think?)

true color switch = same as color correct switch, but with correct blending at
both raster and draw (this is not what we're planning to ship, so maybe will get
removed?)

hdr output switch = (requires one of the above? maybe it should CHECK that
somewhere if so?) changes the backbuffer format to floating point, so draw-time
blending has more precision

color correct LayerTreeSetting = turns on and off raster-time color conversion

color correct RendererSetting = turns on and off draw-time color conversion

[ccameron, 2017/03/07 00:13:51]

So, I complicated this a lot. Eventually all the flags will go away... but in
the mean time they're multiplying.

This part that you wrote is the key part:
The "--enable-color-correct-rendering" flag turns on both of these.

The "--enable-hdr-output" will turn on just the RendererSetting (because the
rasterization APIs aren't stable enough to use). This is sort-of-hacky because
the rasterization results that we're compositing aren't in a coherent color
space ... we (will) work around this by rasterizing to sRGB all the time.

The "--enable-true-color-rendering" will enable linear blending as well (in
fact, we should just call it --enable-linear-blending), and is mostly being
ignored for now.

   settings.renderer_settings.enable_color_correct_rendering =
-      settings.enable_color_correct_rendering;
+      settings.enable_color_correct_rendering ||
+      command_line->HasSwitch(switches::kEnableHDROutput);
 
   // UI compositor always uses partial raster if not using zero-copy. Zero copy
   // doesn't currently support partial raster.
@@ -282,7 +282,8 @@ void Compositor::SetCompositorFrameSink(
   // to match the Compositor's.
   if (context_factory_private_) {
     context_factory_private_->SetDisplayVisible(this, host_->IsVisible());
-    context_factory_private_->SetDisplayColorSpace(this, color_space_);
+    context_factory_private_->SetDisplayColorSpace(this, blending_color_space_,
+                                                   output_color_space_);
   }
 }
 
@@ -354,19 +355,21 @@ void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
 }
 
 void Compositor::SetDisplayColorSpace(const gfx::ColorSpace& color_space) {
+  blending_color_space_ = color_space;
+  output_color_space_ = color_space;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableHDROutput)) {
-    color_space_ = gfx::ColorSpace::CreateSCRGBLinear();
-  } else {
-    color_space_ = color_space;
+    blending_color_space_ = gfx::ColorSpace::CreateExtendedSRGB();
+    output_color_space_ = gfx::ColorSpace::CreateSCRGBLinear();
   }
-  // TODO(Hubbe): Should maybe be color_space_, but currently that crashes skia.
-  host_->SetDeviceColorSpace(color_space);
+  host_->SetDeviceColorSpace(blending_color_space_);
   // Color space is reset when the output surface is lost, so this must also be
   // updated then.
   // TODO(fsamuel): Get rid of this.
-  if (context_factory_private_)
-    context_factory_private_->SetDisplayColorSpace(this, color_space_);
+  if (context_factory_private_) {
+    context_factory_private_->SetDisplayColorSpace(this, blending_color_space_,
+                                                   output_color_space_);
+  }
 }
 
 void Compositor::SetBackgroundColor(SkColor color) {