cc: Remove opaque rect from cc::Picture.

cc/resources/picture_unittest.cc

 // Copyright 2013 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 "cc/resources/picture.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/test/fake_content_layer_client.h"
@@ skipping 55 matching lines @@
     EXPECT_TRUE(!!one_rect_picture_check.get());
 
     // Check for equivalence.
     unsigned char one_rect_buffer[4 * 100 * 100] = {0};
     DrawPicture(one_rect_buffer, layer_rect, one_rect_picture);
     unsigned char one_rect_buffer_check[4 * 100 * 100] = {0};
     DrawPicture(one_rect_buffer_check, layer_rect, one_rect_picture_check);
 
     EXPECT_EQ(one_rect_picture->LayerRect(),
               one_rect_picture_check->LayerRect());
-    EXPECT_EQ(one_rect_picture->OpaqueRect(),
-              one_rect_picture_check->OpaqueRect());
     EXPECT_EQ(0, memcmp(one_rect_buffer, one_rect_buffer_check, 4 * 100 * 100));
   }
 
   // Two rect picture.
   content_layer_client.add_draw_rect(gfx::Rect(25, 25, 50, 50), green_paint);
 
   for (size_t i = 0; i < arraysize(kRecordingModes); ++i) {
     scoped_refptr<Picture> two_rect_picture =
         Picture::Create(layer_rect,
                         &content_layer_client,
                         tile_grid_info,
                         false,
                         Picture::RECORD_NORMALLY);
 
     scoped_ptr<base::Value> serialized_two_rect(two_rect_picture->AsValue());
 
     // Reconstruct the picture.
     scoped_refptr<Picture> two_rect_picture_check =
         Picture::CreateFromValue(serialized_two_rect.get());
     EXPECT_TRUE(!!two_rect_picture_check.get());
 
     // Check for equivalence.
     unsigned char two_rect_buffer[4 * 100 * 100] = {0};
     DrawPicture(two_rect_buffer, layer_rect, two_rect_picture);
     unsigned char two_rect_buffer_check[4 * 100 * 100] = {0};
     DrawPicture(two_rect_buffer_check, layer_rect, two_rect_picture_check);
 
     EXPECT_EQ(two_rect_picture->LayerRect(),
               two_rect_picture_check->LayerRect());
-    EXPECT_EQ(two_rect_picture->OpaqueRect(),
-              two_rect_picture_check->OpaqueRect());
     EXPECT_EQ(0, memcmp(two_rect_buffer, two_rect_buffer_check, 4 * 100 * 100));
   }
 }
 
 TEST(PictureTest, PixelRefIterator) {
   gfx::Rect layer_rect(2048, 2048);
 
   SkTileGridFactory::TileGridInfo tile_grid_info;
   tile_grid_info.fTileInterval = SkISize::Make(512, 512);
   tile_grid_info.fMargin.setEmpty();
@@ skipping 312 matching lines @@
   const base::Value* skp_value;
   EXPECT_TRUE(value->Get("skp64", &skp_value));
 
   // Reconstruct the picture.
   scoped_refptr<Picture> one_rect_picture_check =
       Picture::CreateFromSkpValue(skp_value);
   EXPECT_TRUE(!!one_rect_picture_check.get());
 
   EXPECT_EQ(100, one_rect_picture_check->LayerRect().width());
   EXPECT_EQ(200, one_rect_picture_check->LayerRect().height());
-  EXPECT_EQ(100, one_rect_picture_check->OpaqueRect().width());
-  EXPECT_EQ(200, one_rect_picture_check->OpaqueRect().height());
 }
 
 TEST(PictureTest, RecordingModes) {
   SkGraphics::Init();
 
   gfx::Rect layer_rect(100, 200);
 
   SkTileGridFactory::TileGridInfo tile_grid_info;
   tile_grid_info.fTileInterval = SkISize::Make(100, 200);
   tile_grid_info.fMargin.setEmpty();
@@ skipping 38 matching lines @@
                             false,
                             Picture::RECORD_WITH_SKRECORD);
   EXPECT_TRUE(content_layer_client.last_canvas() != NULL);
   EXPECT_TRUE(picture.get());
 
   EXPECT_EQ(4, Picture::RECORDING_MODE_COUNT);
 }
 
 }  // namespace
 }  // namespace cc