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->pile()->is_solid_color());
   }
 }
 
 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));

[vmpstr, 2014/09/15 15:45:07]

Is this and the previous line required? I'd prefer not to have them unless the
actual code also sets them to these values (just so we're testing the thing that
we're actually running).

[hendrikw, 2014/09/15 16:59:40]

Acknowledged.

+  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->is_solid_color());
+  layer->PushPropertiesTo(layer_impl.get());
+  EXPECT_TRUE(layer_impl->pile()->is_solid_color());
+
+  // 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->is_solid_color());
+  layer->PushPropertiesTo(layer_impl.get());
+  EXPECT_FALSE(layer_impl->pile()->is_solid_color());
+}
+
 }  // namespace
 }  // namespace cc