cc: Remove code for drawing checkerboard quads, it's not used.

content/common/cc_messages_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 "content/common/cc_messages.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "cc/output/compositor_frame.h"
 #include "content/public/common/common_param_traits.h"
 #include "ipc/ipc_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #endif
 
-using cc::CheckerboardDrawQuad;
 using cc::DelegatedFrameData;
 using cc::DebugBorderDrawQuad;
 using cc::DrawQuad;
 using cc::FilterOperation;
 using cc::FilterOperations;
 using cc::IOSurfaceDrawQuad;
 using cc::PictureDrawQuad;
 using cc::RenderPass;
 using cc::RenderPassId;
 using cc::RenderPassDrawQuad;
@@ skipping 39 matching lines @@
     ASSERT_NE(DrawQuad::INVALID, a->material);
     ASSERT_EQ(a->material, b->material);
     EXPECT_EQ(a->rect.ToString(), b->rect.ToString());
     EXPECT_EQ(a->opaque_rect.ToString(), b->opaque_rect.ToString());
     EXPECT_EQ(a->visible_rect.ToString(), b->visible_rect.ToString());
     EXPECT_EQ(a->needs_blending, b->needs_blending);
 
     Compare(a->shared_quad_state, b->shared_quad_state);
 
     switch (a->material) {
-      case DrawQuad::CHECKERBOARD:
-        Compare(CheckerboardDrawQuad::MaterialCast(a),
-                CheckerboardDrawQuad::MaterialCast(b));
-        break;
       case DrawQuad::DEBUG_BORDER:
         Compare(DebugBorderDrawQuad::MaterialCast(a),
                 DebugBorderDrawQuad::MaterialCast(b));
         break;
       case DrawQuad::IO_SURFACE_CONTENT:
         Compare(IOSurfaceDrawQuad::MaterialCast(a),
                 IOSurfaceDrawQuad::MaterialCast(b));
         break;
       case DrawQuad::PICTURE_CONTENT:
         Compare(PictureDrawQuad::MaterialCast(a),
@@ skipping 25 matching lines @@
         break;
       case DrawQuad::YUV_VIDEO_CONTENT:
         Compare(YUVVideoDrawQuad::MaterialCast(a),
                 YUVVideoDrawQuad::MaterialCast(b));
         break;
       case DrawQuad::INVALID:
         break;
     }
   }
 
-  void Compare(const CheckerboardDrawQuad* a, const CheckerboardDrawQuad* b) {
-    EXPECT_EQ(a->color, b->color);
-    EXPECT_EQ(a->scale, b->scale);
-  }
-
   void Compare(const DebugBorderDrawQuad* a, const DebugBorderDrawQuad* b) {
     EXPECT_EQ(a->color, b->color);
     EXPECT_EQ(a->width, b->width);
   }
 
   void Compare(const IOSurfaceDrawQuad* a, const IOSurfaceDrawQuad* b) {
     EXPECT_EQ(a->io_surface_size.ToString(), b->io_surface_size.ToString());
     EXPECT_EQ(a->io_surface_resource_id(), b->io_surface_resource_id());
     EXPECT_EQ(a->orientation, b->orientation);
   }
@@ skipping 174 matching lines @@
                            arbitrary_blend_mode1, arbitrary_context_id1);
 
   scoped_ptr<RenderPass> pass_cmp = RenderPass::Create();
   pass_cmp->SetAll(root_id, arbitrary_rect1, arbitrary_rect2, arbitrary_matrix1,
                    arbitrary_bool1);
 
   SharedQuadState* shared_state1_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
   shared_state1_cmp->CopyFrom(shared_state1_in);
 
-  CheckerboardDrawQuad* checkerboard_in =
-      pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
-  checkerboard_in->SetAll(shared_state1_in, arbitrary_rect1,
-                          arbitrary_rect2_inside_rect1,
-                          arbitrary_rect1_inside_rect1, arbitrary_bool1,
-                          arbitrary_color, arbitrary_float1);
-  pass_cmp->CopyFromAndAppendDrawQuad(checkerboard_in,
-                                      checkerboard_in->shared_quad_state);
-
   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,
                          arbitrary_color,
                          arbitrary_int);
   pass_cmp->CopyFromAndAppendDrawQuad(debugborder_in,
@@ skipping 109 matching lines @@
       arbitrary_color_space);
   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());
-  ASSERT_EQ(10u, pass_in->quad_list.size());
+  ASSERT_EQ(9u, pass_in->quad_list.size());
   for (cc::SharedQuadStateList::ConstIterator
            cmp_iterator = pass_cmp->shared_quad_state_list.begin(),
            in_iterator = pass_in->shared_quad_state_list.begin();
        in_iterator != pass_in->shared_quad_state_list.end();
        ++cmp_iterator, ++in_iterator) {
     Compare(*cmp_iterator, *in_iterator);
   }
   for (auto in_iter = pass_in->quad_list.cbegin(),
             cmp_iter = pass_cmp->quad_list.cbegin();
        in_iter != pass_in->quad_list.cend();
@@ skipping 24 matching lines @@
   // Make sure the out and cmp RenderPasses match.
   scoped_ptr<RenderPass> child_pass_out =
       frame_out.render_pass_list.take(frame_out.render_pass_list.begin());
   Compare(child_pass_cmp.get(), child_pass_out.get());
   ASSERT_EQ(0u, child_pass_out->shared_quad_state_list.size());
   ASSERT_EQ(0u, child_pass_out->quad_list.size());
   scoped_ptr<RenderPass> pass_out =
       frame_out.render_pass_list.take(frame_out.render_pass_list.begin() + 1);
   Compare(pass_cmp.get(), pass_out.get());
   ASSERT_EQ(3u, pass_out->shared_quad_state_list.size());
-  ASSERT_EQ(10u, pass_out->quad_list.size());
+  ASSERT_EQ(9u, pass_out->quad_list.size());
   for (cc::SharedQuadStateList::ConstIterator
            cmp_iterator = pass_cmp->shared_quad_state_list.begin(),
            out_iterator = pass_out->shared_quad_state_list.begin();
        out_iterator != pass_out->shared_quad_state_list.end();
        ++cmp_iterator, ++out_iterator) {
     Compare(*cmp_iterator, *out_iterator);
   }
   for (auto out_iter = pass_out->quad_list.cbegin(),
             cmp_iter = pass_cmp->quad_list.cbegin();
        out_iter != pass_out->quad_list.cend();
@@ skipping 23 matching lines @@
   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state1_in->SetAll(gfx::Transform(),
                            gfx::Size(1, 1),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
                            0);
 
-  CheckerboardDrawQuad* quad1 =
-      pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
+  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, 1.f);
+                gfx::Rect(10, 10), false, SK_ColorRED, false);
 
   // The second and third SharedQuadStates are not used.
   SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state2_in->SetAll(gfx::Transform(),
                            gfx::Size(2, 2),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
@@ skipping 13 matching lines @@
   SharedQuadState* shared_state4_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state4_in->SetAll(gfx::Transform(),
                            gfx::Size(4, 4),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
                            0);
 
-  CheckerboardDrawQuad* quad2 =
-      pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
+  SolidColorDrawQuad* quad2 =
+      pass_in->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad2->SetAll(shared_state4_in, gfx::Rect(10, 10), gfx::Rect(10, 10),
-                gfx::Rect(10, 10), false, SK_ColorRED, 1.f);
+                gfx::Rect(10, 10), false, SK_ColorRED, false);
 
   // The fifth is not used again.
   SharedQuadState* shared_state5_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state5_in->SetAll(gfx::Transform(),
                            gfx::Size(5, 5),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
@@ skipping 147 matching lines @@
     SoftwareFrameData frame_out;
     base::PickleIterator iter(msg);
     EXPECT_EQ(
         expect_read,
         IPC::ParamTraits<SoftwareFrameData>::Read(&msg, &iter, &frame_out));
   }
 }
 
 }  // namespace
 }  // namespace content