cc: Allow DeferredInitialize to use DelegatingRenderer

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 <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/swap_promise.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/io_surface_layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/video_layer.h"
 #include "cc/output/begin_frame_args.h"
+#include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/output_surface.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/resources/prioritized_resource.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_update_queue.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
@@ skipping 2721 matching lines @@
     did_release_gl_ = false;
     last_source_frame_number_drawn_ = -1;  // Never drawn.
     PostSetNeedsCommitToMainThread();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
       OVERRIDE {
     scoped_ptr<TestWebGraphicsContext3D> context3d(
         TestWebGraphicsContext3D::Create());
 
-    return FakeOutputSurface::CreateDeferredGL(
-        scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice));
+    scoped_ptr<FakeOutputSurface> output_surface =
+        FakeOutputSurface::CreateDeferredGL(
+            scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
+            delegating_renderer());
+    output_surface->set_forced_draw_to_software_device(true);

[danakj, 2014/05/16 22:08:47]

Why are these set calls needed/correct?

[boliu, 2014/05/16 22:15:10]

To avoid failing this DCHECK in GetDrawMode:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/trees/layer_tre...

It is now totally possible for OutputSurface to have a both software device as
well as delegated_rendering capability. Webview will never produce real software
compositor frames, only the Resourceless kind by setting
force_draw_to_software_device, so the DCHECK should still hold technically.
These calls are mimicking this behavior in webview.

I supppose the DCHECK can be removed. But I'd also like the test reflect real
code.

[danakj, 2014/05/16 22:19:29]

We should update this DCHECK then, to allow this when deferred_gl is present?
(Look forward to being able to swap OutputSurfaces instead of having this mega
modal OutputSurface..)

[boliu, 2014/05/16 22:34:37]

Relaxed DCHECK to allow deferred_gl too. It should also check it's not using the
DelegatingRenderer, but I'm not sure what to check that.

Didn't change the test.
ForcedDrawToSoftwareDevice won't go away, but yes, OS won't need to set
delegated_rendering before DeferredInitialize, and can get rid of all this
"force_software_renderer" cruft.

+    return output_surface.Pass();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     ASSERT_TRUE(host_impl->RootLayer());
     FakePictureLayerImpl* layer_impl =
         static_cast<FakePictureLayerImpl*>(host_impl->RootLayer());
 
     // The same frame can be draw multiple times if new visible tiles are
     // rasterized. But we want to make sure we only post DeferredInitialize
     // and ReleaseGL once, so early out if the same frame is drawn again.
@@ skipping 27 matching lines @@
 
   void DeferredInitializeAndRedraw(LayerTreeHostImpl* host_impl) {
     EXPECT_FALSE(did_initialize_gl_);
     // SetAndInitializeContext3D calls SetNeedsCommit.
     FakeOutputSurface* fake_output_surface =
         static_cast<FakeOutputSurface*>(host_impl->output_surface());
     scoped_refptr<TestContextProvider> context_provider =
         TestContextProvider::Create();  // Not bound to thread.
     EXPECT_TRUE(
         fake_output_surface->InitializeAndSetContext3d(context_provider));
+    fake_output_surface->set_forced_draw_to_software_device(false);
     did_initialize_gl_ = true;
   }
 
   void ReleaseGLAndRedraw(LayerTreeHostImpl* host_impl) {
     EXPECT_TRUE(did_initialize_gl_);
     EXPECT_FALSE(did_release_gl_);
     // ReleaseGL calls SetNeedsCommit.
-    static_cast<FakeOutputSurface*>(host_impl->output_surface())->ReleaseGL();
+    FakeOutputSurface* output_surface =
+        static_cast<FakeOutputSurface*>(host_impl->output_surface());
+    output_surface->ReleaseGL();
+    output_surface->set_forced_draw_to_software_device(true);
     did_release_gl_ = true;
   }
 
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
+                                   bool result) OVERRIDE {
+    ASSERT_TRUE(result);
+    DelegatedFrameData* delegated_frame_data =
+        output_surface()->last_sent_frame().delegated_frame_data.get();
+    if (!delegated_frame_data)
+      return;
+
+    // Return all resources immediately.
+    TransferableResourceArray resources_to_return =
+        output_surface()->resources_held_by_parent();
+
+    CompositorFrameAck ack;
+    for (size_t i = 0; i < resources_to_return.size(); ++i)
+      output_surface()->ReturnResource(resources_to_return[i].id, &ack);
+    host_impl->ReclaimResources(&ack);
+  }
+
   virtual void AfterTest() OVERRIDE {
     EXPECT_TRUE(did_initialize_gl_);
     EXPECT_TRUE(did_release_gl_);
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> layer_;
   bool did_initialize_gl_;
   bool did_release_gl_;
   int last_source_frame_number_drawn_;
 };
 
-MULTI_THREAD_DIRECT_RENDERER_TEST_F(LayerTreeHostTestDeferredInitialize);
+MULTI_THREAD_TEST_F(LayerTreeHostTestDeferredInitialize);
 
 // Test for UI Resource management.
 class LayerTreeHostTestUIResource : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUIResource() : num_ui_resources_(0) {}
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->texture_id_allocation_chunk_size = 1;
   }
 
@@ skipping 2086 matching lines @@
   const gfx::Size bounds_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayerWithUpdateTracking> content_layer_;
   scoped_refptr<FakePictureLayer> picture_layer_;
   Layer* child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousPainting);
 
 }  // namespace cc