cc: Plumb device color space through to rasterization

cc/trees/layer_tree_impl.cc

Index: cc/trees/layer_tree_impl.cc
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 1376cdf6b5ec4b19aebd7f1168b88c25d401f620..2cbf36af8684c823f30790830d9b28424588f0f1 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -441,6 +441,7 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
                                             max_page_scale_factor());
   target_tree->SetDeviceScaleFactor(device_scale_factor());
   target_tree->set_painted_device_scale_factor(painted_device_scale_factor());
+  target_tree->SetDeviceColorSpace(device_color_space_);
   target_tree->elastic_overscroll()->PushPendingToActive();
 
   target_tree->pending_page_scale_animation_ =
@@ -850,6 +851,19 @@ void LayerTreeImpl::SetDeviceScaleFactor(float device_scale_factor) {
     layer_tree_host_impl_->SetFullViewportDamage();
 }
 
+void LayerTreeImpl::SetDeviceColorSpace(
+    const gfx::ColorSpace& device_color_space) {
+  if (device_color_space == device_color_space_)
+    return;
+  device_color_space_ = device_color_space;
+
+  ReleaseResources();

[vmpstr, 2016/09/15 18:44:40]

Hmm...

Have you tested this with something like a very basic page switching monitors?

My concern is that on the pending tree, we currently have only sparse tiles.
That is, when we first create a pending tree it shouldn't have any tiles on it.
So, this call kinda double makes sure of that. However, it doesn't say anything
about which tiles we should be creating on the pending tree. That's still
dictated by the invalidation.

On the active tree, this would happen on activation (right?), which means that
we'll remove all active tree tiles and then apply the pending tree tiles, which
are located where the invalidation is. That is, it won't necessarily be the full
viewport. In turn that means that we're risking a frame of checkers until tile
manager panics and figures out that it actually doesn't have ready tiles on the
active tree.

Does that reasoning make sense?

If so, I'd prefer this being something along the lines of when we create a
pending tree (sync tree) and we set a new color space, then we add an
invalidation for the full region. PictureLayer has SetNeedsDisplay which should
invalidate everything... I'm not sure how where to call that though. When we
then set the color space on the active tree during commit, we _can_ blow away
all tiles, since we know that because we're activating we're going to get the
full viewport of tiles (everything was invalidated - every tile that's needed
exists on the pending tree)

+  RecreateResources();
+
+  if (IsActiveTree())
+    layer_tree_host_impl_->SetFullViewportDamage();
+}
+
 SyncedProperty<ScaleGroup>* LayerTreeImpl::page_scale_factor() {
   return page_scale_factor_.get();
 }