Remove unused RenderPassDrawQuad fields

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>
 
@@ skipping 125 matching lines @@
   }
 
   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);
   }
 
   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
     EXPECT_EQ(a->render_pass_id, b->render_pass_id);
-    EXPECT_EQ(a->is_replica, b->is_replica);
     EXPECT_EQ(a->mask_resource_id, b->mask_resource_id);
-    EXPECT_EQ(a->contents_changed_since_last_frame,
-              b->contents_changed_since_last_frame);
     EXPECT_EQ(a->mask_uv_rect.ToString(), b->mask_uv_rect.ToString());
     EXPECT_EQ(a->filters.size(), b->filters.size());
     for (size_t i = 0; i < a->filters.size(); ++i) {
       if (a->filters.at(i).type() != cc::FilterOperation::REFERENCE) {
         EXPECT_EQ(a->filters.at(i), b->filters.at(i));
       } else {
         EXPECT_EQ(b->filters.at(i).type(), cc::FilterOperation::REFERENCE);
         EXPECT_EQ(a->filters.at(i).image_filter()->countInputs(),
                   b->filters.at(i).image_filter()->countInputs());
       }
@@ skipping 198 matching lines @@
   shared_state2_cmp->CopyFrom(shared_state2_in);
 
   RenderPassDrawQuad* renderpass_in =
       pass_in->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   renderpass_in->SetAll(shared_state2_in,
                         arbitrary_rect1,
                         arbitrary_rect2_inside_rect1,
                         arbitrary_rect1_inside_rect1,
                         arbitrary_bool1,
                         arbitrary_id,
-                        arbitrary_bool2,
                         arbitrary_resourceid2,
-                        arbitrary_rect1,
                         arbitrary_rectf1,
                         arbitrary_filters1,
                         arbitrary_filters2);
   pass_cmp->CopyFromAndAppendRenderPassDrawQuad(
       renderpass_in,
       renderpass_in->shared_quad_state,
       renderpass_in->render_pass_id);
 
   SharedQuadState* shared_state3_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state3_in->SetAll(arbitrary_matrix,
@@ skipping 301 matching lines @@
   DelegatedFrameData frame_out;
   PickleIterator iter(msg);
   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::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]);
 }
 
-TEST_F(CCMessagesTest, LargestQuadType) {
-  size_t largest = 0;
-
-  bool done = false;
-  for (int i = 0; !done; ++i) {
-    switch (static_cast<DrawQuad::Material>(i)) {
-      case cc::DrawQuad::CHECKERBOARD:
-        largest = std::max(largest, sizeof(cc::CheckerboardDrawQuad));
-        break;
-      case cc::DrawQuad::DEBUG_BORDER:
-        largest = std::max(largest, sizeof(cc::DebugBorderDrawQuad));
-        break;
-      case cc::DrawQuad::IO_SURFACE_CONTENT:
-        largest = std::max(largest, sizeof(cc::IOSurfaceDrawQuad));
-        break;
-      case cc::DrawQuad::PICTURE_CONTENT:
-        largest = std::max(largest, sizeof(cc::PictureDrawQuad));
-        break;
-      case cc::DrawQuad::TEXTURE_CONTENT:
-        largest = std::max(largest, sizeof(cc::TextureDrawQuad));
-        break;
-      case cc::DrawQuad::RENDER_PASS:
-        largest = std::max(largest, sizeof(cc::RenderPassDrawQuad));
-        break;
-      case cc::DrawQuad::SOLID_COLOR:
-        largest = std::max(largest, sizeof(cc::SolidColorDrawQuad));
-        break;
-      case cc::DrawQuad::SURFACE_CONTENT:
-        largest = std::max(largest, sizeof(cc::SurfaceDrawQuad));
-        break;
-      case cc::DrawQuad::TILED_CONTENT:
-        largest = std::max(largest, sizeof(cc::TileDrawQuad));
-        break;
-      case cc::DrawQuad::STREAM_VIDEO_CONTENT:
-        largest = std::max(largest, sizeof(cc::StreamVideoDrawQuad));
-        break;
-      case cc::DrawQuad::YUV_VIDEO_CONTENT:
-        largest = std::max(largest, sizeof(cc::YUVVideoDrawQuad));
-        break;
-      case cc::DrawQuad::INVALID:
-        break;
-      default:
-        done = true;
-    }
-  }
-
-  // Verify the largest DrawQuad type is RenderPassDrawQuad. If this ever
-  // changes, then the ReserveSizeForRenderPassWrite() method needs to be
-  // updated as well to use the new largest quad.
-  EXPECT_EQ(sizeof(RenderPassDrawQuad), largest);
-}
-
 TEST_F(CCMessagesTest, SoftwareFrameData) {
   cc::SoftwareFrameData frame_in;
   frame_in.id = 3;
   frame_in.size = gfx::Size(40, 20);
   frame_in.damage_rect = gfx::Rect(5, 18, 31, 44);
   frame_in.bitmap_id = cc::SharedBitmap::GenerateId();
 
   // Write the frame.
   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
   IPC::ParamTraits<cc::SoftwareFrameData>::Write(&msg, frame_in);
@@ skipping 47 matching lines @@
     SoftwareFrameData frame_out;
     PickleIterator iter(msg);
     EXPECT_EQ(
         expect_read,
         IPC::ParamTraits<SoftwareFrameData>::Read(&msg, &iter, &frame_out));
   }
 }
 
 }  // namespace
 }  // namespace content