cc: Move output color space from DrawingFrame to RenderPass

cc/ipc/cc_param_traits_unittest.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 <stddef.h>
 #include <string.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 57 matching lines @@
       if (a->background_filters.at(i).type() !=
           cc::FilterOperation::REFERENCE) {
         EXPECT_EQ(a->background_filters.at(i), b->background_filters.at(i));
       } else {
         EXPECT_EQ(b->background_filters.at(i).type(),
                   cc::FilterOperation::REFERENCE);
         EXPECT_EQ(a->background_filters.at(i).image_filter()->countInputs(),
                   b->background_filters.at(i).image_filter()->countInputs());
       }
     }
+    EXPECT_EQ(a->color_space, b->color_space);
     EXPECT_EQ(a->has_transparent_background, b->has_transparent_background);
   }
 
   void Compare(const SharedQuadState* a, const SharedQuadState* b) {
     EXPECT_EQ(a->quad_to_target_transform, b->quad_to_target_transform);
     EXPECT_EQ(a->quad_layer_bounds, b->quad_layer_bounds);
     EXPECT_EQ(a->visible_quad_layer_rect, b->visible_quad_layer_rect);
     EXPECT_EQ(a->clip_rect, b->clip_rect);
     EXPECT_EQ(a->is_clipped, b->is_clipped);
     EXPECT_EQ(a->opacity, b->opacity);
@@ skipping 183 matching lines @@
   int arbitrary_int = 13;
   SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
   SkBlendMode arbitrary_blend_mode1 = SkBlendMode::kScreen;
   SkBlendMode arbitrary_blend_mode2 = SkBlendMode::kLighten;
   SkBlendMode arbitrary_blend_mode3 = SkBlendMode::kOverlay;
   ResourceId arbitrary_resourceid1 = 55;
   ResourceId arbitrary_resourceid2 = 47;
   ResourceId arbitrary_resourceid3 = 23;
   ResourceId arbitrary_resourceid4 = 16;
   SkScalar arbitrary_sigma = SkFloatToScalar(2.0f);
-  YUVVideoDrawQuad::ColorSpace arbitrary_color_space =
+  gfx::ColorSpace arbitrary_color_space = gfx::ColorSpace::CreateREC601();
+  YUVVideoDrawQuad::ColorSpace arbitrary_video_color_space =
       YUVVideoDrawQuad::REC_601;
-  gfx::ColorSpace arbitrary_video_color_space = gfx::ColorSpace::CreateREC601();
 
   int child_id = 30;
   int root_id = 14;
 
   FilterOperations arbitrary_filters1;
   arbitrary_filters1.Append(
       FilterOperation::CreateGrayscaleFilter(arbitrary_float1));
   arbitrary_filters1.Append(cc::FilterOperation::CreateReferenceFilter(
       SkBlurImageFilter::Make(arbitrary_sigma, arbitrary_sigma, nullptr)));
 
   FilterOperations arbitrary_filters2;
   arbitrary_filters2.Append(
       FilterOperation::CreateBrightnessFilter(arbitrary_float2));
 
   std::unique_ptr<RenderPass> child_pass_in = RenderPass::Create();
   child_pass_in->SetAll(child_id, arbitrary_rect2, arbitrary_rect3,
                         arbitrary_matrix2, arbitrary_filters1,
-                        arbitrary_filters2, arbitrary_bool2);
+                        arbitrary_filters2, arbitrary_color_space,
+                        arbitrary_bool2);
 
   std::unique_ptr<RenderPass> child_pass_cmp = RenderPass::Create();
   child_pass_cmp->SetAll(child_id, arbitrary_rect2, arbitrary_rect3,
                          arbitrary_matrix2, arbitrary_filters1,
-                         arbitrary_filters2, arbitrary_bool2);
+                         arbitrary_filters2, arbitrary_color_space,
+                         arbitrary_bool2);
 
   std::unique_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(root_id, arbitrary_rect1, arbitrary_rect2, arbitrary_matrix1,
-                  arbitrary_filters2, arbitrary_filters1, arbitrary_bool1);
+                  arbitrary_filters2, arbitrary_filters1, arbitrary_color_space,
+                  arbitrary_bool1);
 
   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state1_in->SetAll(arbitrary_matrix1, arbitrary_size1, arbitrary_rect1,
                            arbitrary_rect2, arbitrary_bool1, arbitrary_float1,
                            arbitrary_blend_mode1, arbitrary_context_id1);
 
   std::unique_ptr<RenderPass> pass_cmp = RenderPass::Create();
   pass_cmp->SetAll(root_id, arbitrary_rect1, arbitrary_rect2, arbitrary_matrix1,
-                   arbitrary_filters2, arbitrary_filters1, arbitrary_bool1);
+                   arbitrary_filters2, arbitrary_filters1,
+                   arbitrary_color_space, arbitrary_bool1);
 
   SharedQuadState* shared_state1_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
   *shared_state1_cmp = *shared_state1_in;
 
   DebugBorderDrawQuad* debugborder_in =
       pass_in->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
   debugborder_in->SetAll(shared_state1_in, arbitrary_rect3,
                          arbitrary_rect1_inside_rect3,
                          arbitrary_rect2_inside_rect3, arbitrary_bool1,
@@ skipping 75 matching lines @@
                   arbitrary_size1, arbitrary_bool2, arbitrary_bool3);
   pass_cmp->CopyFromAndAppendDrawQuad(tile_in, tile_in->shared_quad_state);
 
   YUVVideoDrawQuad* yuvvideo_in =
       pass_in->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
   yuvvideo_in->SetAll(
       shared_state3_in, arbitrary_rect1, arbitrary_rect2_inside_rect1,
       arbitrary_rect1_inside_rect1, arbitrary_bool1, arbitrary_rectf1,
       arbitrary_rectf2, arbitrary_size1, arbitrary_size2, arbitrary_resourceid1,
       arbitrary_resourceid2, arbitrary_resourceid3, arbitrary_resourceid4,
-      arbitrary_color_space, arbitrary_video_color_space, arbitrary_float1,
+      arbitrary_video_color_space, arbitrary_color_space, arbitrary_float1,
       arbitrary_float2, arbitrary_int);
   pass_cmp->CopyFromAndAppendDrawQuad(yuvvideo_in,
                                       yuvvideo_in->shared_quad_state);
 
   // Make sure the in and cmp RenderPasses match.
   Compare(child_pass_cmp.get(), child_pass_in.get());
   ASSERT_EQ(0u, child_pass_in->shared_quad_state_list.size());
   ASSERT_EQ(0u, child_pass_in->quad_list.size());
   Compare(pass_cmp.get(), pass_in.get());
   ASSERT_EQ(3u, pass_in->shared_quad_state_list.size());
@@ skipping 60 matching lines @@
     bool same_shared_quad_state_out =
         pass_out->quad_list.ElementAt(i)->shared_quad_state ==
         pass_out->quad_list.ElementAt(i - 1)->shared_quad_state;
     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out);
   }
 }
 
 TEST_F(CCParamTraitsTest, UnusedSharedQuadStates) {
   std::unique_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(1, gfx::Rect(100, 100), gfx::Rect(), gfx::Transform(),
-                  FilterOperations(), FilterOperations(), false);
+                  FilterOperations(), FilterOperations(),
+                  gfx::ColorSpace::CreateSRGB(), false);
 
   // The first SharedQuadState is used.
   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state1_in->SetAll(gfx::Transform(), gfx::Size(1, 1), gfx::Rect(),
                            gfx::Rect(), false, 1.f, SkBlendMode::kSrcOver, 0);
 
   SolidColorDrawQuad* quad1 =
       pass_in->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad1->SetAll(shared_state1_in, gfx::Rect(10, 10), gfx::Rect(10, 10),
                 gfx::Rect(10, 10), false, SK_ColorRED, false);
@@ skipping 112 matching lines @@
   base::PickleIterator iter(msg);
   EXPECT_TRUE(IPC::ParamTraits<CompositorFrame>::Read(&msg, &iter, &frame_out));
 
   ASSERT_EQ(2u, frame_out.resource_list.size());
   Compare(arbitrary_resource1, frame_out.resource_list[0]);
   Compare(arbitrary_resource2, frame_out.resource_list[1]);
 }
 
 }  // namespace
 }  // namespace content