Fix MultiPictureDraw issues with GpuImageDecodeController

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 29 matching lines @@
 #include "cc/test/fake_painted_scrollbar_layer.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/fake_scoped_ui_resource.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_internals_for_test.h"
 #include "cc/test/layer_tree_test.h"
+#include "cc/test/skia_common.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/transform_node.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/khronos/GLES2/gl2.h"
@@ skipping 6716 matching lines @@
     EXPECT_EQ(2.0f, host_impl->active_tree()->painted_device_scale_factor());
     EXPECT_EQ(1.0f, host_impl->active_tree()->device_scale_factor());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
+// The GPU image decode controller hands images off to Skia for rasterization.
+// When used with large images, the images in question could be deleted before
+// Skia was done with them, causing a crash. This test performs an end-to-end
+// check of large image rasterization to ensure we do not hit this crash.
+// Note that this code path won't always hit the crash, even when incorrect
+// behavior occurs, so this is more of a sanity check.
+// TODO(ericrk): We should improve this so that we can reliably detect the
+// crash.
+class GpuRasterizationSucceedsWithLargeImage : public LayerTreeHostTest {
+ protected:
+  GpuRasterizationSucceedsWithLargeImage() : viewport_size_(1024, 2048) {}
+
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->gpu_rasterization_enabled = true;
+    settings->gpu_rasterization_forced = true;
+
+    /// Set to 0 to force at-raster GPU image decode.
+    settings->gpu_decoded_image_budget_bytes = 0;
+  }
+
+  void SetupTree() override {
+    client_.set_fill_with_nonsolid_color(true);
+
+    std::unique_ptr<FakeRecordingSource> recording =
+        FakeRecordingSource::CreateFilledRecordingSource(
+            gfx::Size(10000, 10000));
+    // Add an image that will be larger than max texture size.

[vmpstr, 2016/07/14 22:07:48]

Is there a way to assert that this size is bigger than max texture size?

[ericrk, 2016/07/14 23:15:46]

Added.

+    recording->add_draw_image(CreateDiscardableImage(gfx::Size(20000, 10)),
+                              gfx::Point(0, 0));
+    recording->SetGenerateDiscardableImagesMetadata(true);
+    recording->Rerecord();
+
+    scoped_refptr<FakePictureLayer> root =
+        FakePictureLayer::CreateWithRecordingSource(&client_,
+                                                    std::move(recording));
+    root->SetBounds(gfx::Size(10000, 10000));
+    client_.set_bounds(root->bounds());
+    root->SetContentsOpaque(true);
+
+    layer_tree_host()->SetRootLayer(root);
+    LayerTreeHostTest::SetupTree();
+    layer_tree_host()->SetViewportSize(viewport_size_);
+    client_.set_bounds(root->bounds());
+  }
+
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void DidCommit() override { EndTest(); }
+
+  void AfterTest() override {}
+
+ private:
+  FakeContentLayerClient client_;
+  gfx::Size viewport_size_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(GpuRasterizationSucceedsWithLargeImage);
+
 }  // namespace
 }  // namespace cc