cc: Support on demand raster with ganesh

cc/trees/layer_tree_host_pixeltest_on_demand_raster.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/append_quads_data.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/test/layer_tree_pixel_test.h"
@@ skipping 36 matching lines @@
 
     AppendQuadsData data;
     picture_layer->AppendQuads(&quad_culler, &data);
 
     for (size_t i = 0; i < render_pass->quad_list.size(); ++i)
       EXPECT_EQ(render_pass->quad_list[i]->material, DrawQuad::PICTURE_CONTENT);
 
     // Triggers pixel readback and ends the test.
     LayerTreePixelTest::SwapBuffersOnThread(host_impl, result);
   }
+
+  void RunOnDemandRasterPixelTest();
 };
 
 class BlueYellowLayerClient : public ContentLayerClient {
  public:
   explicit BlueYellowLayerClient(gfx::Rect layer_rect)
       : layer_rect_(layer_rect) {}
 
   virtual void DidChangeLayerCanUseLCDText() OVERRIDE { }
 
   virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
@@ skipping 17 matching lines @@
                          layer_rect_.height() / 2,
                          layer_rect_.width(),
                          layer_rect_.height() / 2),
         paint);
   }
 
  private:
   gfx::Rect layer_rect_;
 };
 
-TEST_F(LayerTreeHostOnDemandRasterPixelTest, RasterPictureLayer) {
+void LayerTreeHostOnDemandRasterPixelTest::RunOnDemandRasterPixelTest() {
   // Use multiple colors in a single layer to prevent bypassing on-demand
   // rasterization if a single solid color is detected in picture analysis.
   gfx::Rect layer_rect(200, 200);
   BlueYellowLayerClient client(layer_rect);
   scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
 
   layer->SetIsDrawable(true);
   layer->SetBounds(layer_rect.size());
   layer->SetPosition(layer_rect.origin());
 
   RunPixelTest(GL_WITH_BITMAP,
                layer,
                base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")));
 }
 
+TEST_F(LayerTreeHostOnDemandRasterPixelTest, RasterPictureLayer) {
+  RunOnDemandRasterPixelTest();
+}
+
+class LayerTreeHostOnDemandRasterPixelTestWithoutTaskGraphRunner

[reveman, 2014/06/20 00:38:41]

s/WithoutTaskGraphRunner/WithGpuRasterizationForced/ as "WithoutTaskGraphRunner"
is making assumptions about the implementation that I don't think should be done
here.

[boliu, 2014/06/20 00:43:39]

Any thoughts on the crash in the global TaskGraphRunner when running these two
tests consecutively. Copying from #13.

"""
Also found that I can no longer repeat LayerTreeHostOnDemandRasterPixelTest in
the same process, since those tests creates and tears down a new compositor
thread each time, but then the OnDemandRasterTaskImpl asks for the thread id
from the same global RasterWorkerPool. In the second test, this fails because
the RasterWorkerPool is neither created nor run on that new compositor thread. I
guess this is a separate issue that's exposed only exposed by this though...
"""

I think have the test clean up the global TaskGraphRunner at the end would work,
but wanted to get your thoughts.

[reveman, 2014/06/20 01:01:38]

Do you mean that the TaskGraphRunner instance is created on a different thread
than the cc thread used in the second test and this causes the TLS not to be set
correctly?

Maybe use index 0 when TLS is not set instead of setting it to 0 for origin
thread. Not sure we can rely on it to be NULL initially though. This picture
cloning stuff is annoying, I hope we can remove it soon...

[boliu, 2014/06/20 01:27:06]

Yep. The cc thread in the two threads are not the same one and it's the same
TaskGraphRunner instance that's created on in first cc thread, then used again
on the second cc thread.
Using 0 is fine at least for the test. It's not an issue in pratice because
compositor thread is always the same one in chrome.

+    : public LayerTreeHostOnDemandRasterPixelTest {
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    LayerTreeHostOnDemandRasterPixelTest::InitializeSettings(settings);
+    settings->gpu_rasterization_forced = true;
+  }
+};
+
+TEST_F(LayerTreeHostOnDemandRasterPixelTestWithoutTaskGraphRunner,
+       RasterPictureLayer) {
+  RunOnDemandRasterPixelTest();
+}
+
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID