HDR: Do nonlinear blending in the compositor

ui/compositor/compositor.cc

 // Copyright (c) 2012 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 "ui/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 145 matching lines @@
   settings.use_zero_copy = IsUIZeroCopyEnabled();
 
   if (command_line->HasSwitch(switches::kUIEnableRGBA4444Textures))
     settings.renderer_settings.preferred_tile_format = cc::RGBA_4444;
 
   settings.use_layer_lists =
       command_line->HasSwitch(cc::switches::kUIEnableLayerLists);
 
   settings.enable_color_correct_rendering =
       command_line->HasSwitch(cc::switches::kEnableColorCorrectRendering) ||
-      command_line->HasSwitch(cc::switches::kEnableTrueColorRendering) ||
+      command_line->HasSwitch(cc::switches::kEnableTrueColorRendering);
+  settings.renderer_settings.enable_color_correct_rendering =
+      settings.enable_color_correct_rendering ||
       command_line->HasSwitch(switches::kEnableHDROutput);
-  settings.renderer_settings.enable_color_correct_rendering =
-      settings.enable_color_correct_rendering;
 
   // UI compositor always uses partial raster if not using zero-copy. Zero copy
   // doesn't currently support partial raster.
   settings.use_partial_raster = !settings.use_zero_copy;
 
   // Populate buffer_to_texture_target_map for all buffer usage/formats.
   for (int usage_idx = 0; usage_idx <= static_cast<int>(gfx::BufferUsage::LAST);
        ++usage_idx) {
     gfx::BufferUsage usage = static_cast<gfx::BufferUsage>(usage_idx);
     for (int format_idx = 0;
@@ skipping 95 matching lines @@
 }
 
 void Compositor::SetCompositorFrameSink(
     std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink) {
   compositor_frame_sink_requested_ = false;
   host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
   // Display properties are reset when the output surface is lost, so update it
   // 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_);
   }
 }
 
 void Compositor::ScheduleDraw() {
   host_->SetNeedsCommit();
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
   if (root_layer_ == root_layer)
     return;
@@ skipping 51 matching lines @@
   }
   if (device_scale_factor_ != scale) {
     device_scale_factor_ = scale;
     host_->SetDeviceScaleFactor(scale);
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
   }
 }
 
 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) {
   host_->set_background_color(color);
   ScheduleDraw();
 }
 
 void Compositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
   // Visibility is reset when the output surface is lost, so this must also be
@@ skipping 187 matching lines @@
   for (auto& observer : observer_list_)
     observer.OnCompositingLockStateChanged(this);
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui