Use the solid color detection to create solid layers

cc/layers/picture_layer_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/layers/picture_layer.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/resource_update_queue.h"
+#include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/impl_side_painting_settings.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
@@ skipping 39 matching lines @@
         ImplSidePaintingSettings(), &proxy, &shared_bitmap_manager);
     host_impl.CreatePendingTree();
     scoped_ptr<FakePictureLayerImpl> layer_impl =
         FakePictureLayerImpl::Create(host_impl.pending_tree(), 1);
 
     layer->PushPropertiesTo(layer_impl.get());
     EXPECT_FALSE(layer_impl->CanHaveTilings());
     EXPECT_TRUE(layer_impl->bounds() == gfx::Size(0, 0));
     EXPECT_EQ(gfx::Size(), layer_impl->pile()->tiling_size());
     EXPECT_FALSE(layer_impl->pile()->HasRecordings());
+    EXPECT_TRUE(layer_impl->IsSolidColor());
   }
 }
 
 TEST(PictureLayerTest, SuitableForGpuRasterization) {
   MockContentLayerClient client;
   scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
   PicturePile* pile = layer->GetPicturePileForTesting();
 
   // Layer is suitable for gpu rasterization by default.
   EXPECT_TRUE(pile->is_suitable_for_gpu_rasterization());
@@ skipping 13 matching lines @@
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(settings);
   host->SetRootLayer(layer);
   EXPECT_EQ(Picture::RECORD_NORMALLY, layer->RecordingMode());
 
   settings.recording_mode = LayerTreeSettings::RecordWithSkRecord;
   host = FakeLayerTreeHost::Create(settings);
   host->SetRootLayer(layer);
   EXPECT_EQ(Picture::RECORD_WITH_SKRECORD, layer->RecordingMode());
 }
 
+TEST(PictureLayerTest, SolidColorAnalysisForPictureLayer) {
+  FakeContentLayerClient client;
+  scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
+  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  host->SetRootLayer(layer);
+  PicturePile* pile = layer->GetPicturePileForTesting();
+  pile->SetMinContentsScale(0.125);
+  pile->SetTileGridSize(gfx::Size(1000, 1000));
+  pile->tiling().SetTilingSize(pile->tiling().max_texture_size());
+
+  FakeProxy proxy;
+  DebugScopedSetImplThread impl_thread(&proxy);
+
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(
+      ImplSidePaintingSettings(), &proxy, &shared_bitmap_manager);
+  host_impl.CreatePendingTree();
+  scoped_ptr<FakePictureLayerImpl> layer_impl =
+      FakePictureLayerImpl::Create(host_impl.pending_tree(), 1);
+
+  gfx::Size tiling_size = pile->tiling_size();
+  gfx::Rect tiling_rect = gfx::Rect(tiling_size);
+  int frame_number = 0;
+  FakeRenderingStatsInstrumentation stats_instrumentation;
+
+  Region invalidation1(tiling_rect);
+  pile->UpdateAndExpandInvalidation(&client,
+                                    &invalidation1,
+                                    SK_ColorWHITE,
+                                    false,
+                                    false,
+                                    tiling_size,
+                                    tiling_rect,
+                                    frame_number++,
+                                    Picture::RECORD_NORMALLY,
+                                    &stats_instrumentation);
+
+  // We haven't drawn anything yet, so it should be solid.
+  EXPECT_TRUE(pile->IsSolidColor());
+  layer->PushPropertiesTo(layer_impl.get());
+  EXPECT_TRUE(layer_impl->IsSolidColor());
+
+  // Draw a rectangle that doesn't cover the viewport.
+  gfx::Rect smallRect = tiling_rect;
+  smallRect.Inset(10, 10, 10, 10);
+  SkPaint paint;
+  paint.setColor(SK_ColorCYAN);
+  client.add_draw_rect(smallRect, paint);
+  Region invalidation2(tiling_rect);
+  pile->UpdateAndExpandInvalidation(&client,
+                                    &invalidation2,
+                                    SK_ColorWHITE,
+                                    false,
+                                    false,
+                                    tiling_size,
+                                    tiling_rect,
+                                    frame_number++,
+                                    Picture::RECORD_NORMALLY,
+                                    &stats_instrumentation);
+
+  // Since the rectangle doesn't cover the entire layer, we should no be solid
+  EXPECT_FALSE(pile->IsSolidColor());
+  layer->PushPropertiesTo(layer_impl.get());
+  EXPECT_FALSE(layer_impl->IsSolidColor());
+}
+
 }  // namespace
 }  // namespace cc