cc: Fix multiple outstanding output surface requests

content/renderer/gpu/render_widget_compositor_unittest.cc

 // Copyright 2014 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/failure_output_surface.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/public/test/mock_render_thread.h"
@@ skipping 115 matching lines @@
         use_null_output_surface_(true) {}
 
   using RenderWidgetCompositor::Initialize;
 
   scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback) {
     EXPECT_EQ(num_requests_since_last_success_ >
                   OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK,
               fallback);
     last_create_was_fallback_ = fallback;
     bool success = num_failures_ >= num_failures_before_success_;
-    if (success)
-      return cc::FakeOutputSurface::Create3d();
+    if (success) {
+      scoped_ptr<cc::TestWebGraphicsContext3D> context =
+          cc::TestWebGraphicsContext3D::Create();
+      // Image support required for synchronous compositing.
+      context->set_support_image(true);
+      return cc::FakeOutputSurface::Create3d(context.Pass());
+    }
     return use_null_output_surface_
                ? nullptr
                : make_scoped_ptr(new cc::FailureOutputSurface(false));
   }
 
+  // Force a new output surface to be created.
+  void SynchronousComposite() {
+   layer_tree_host()->DidLoseOutputSurface();
+
+   base::TimeTicks some_time;
+   layer_tree_host()->Composite(some_time);
+  }
+
   void RequestNewOutputSurface() override {
     ++num_requests_;
     ++num_requests_since_last_success_;
     RenderWidgetCompositor::RequestNewOutputSurface();
   }
 
   void DidInitializeOutputSurface() override {
     if (last_create_was_fallback_)
       ++num_fallback_successes_;
     else
       ++num_successes_;
 
     if (num_requests_ == expected_requests_) {
       EndTest();
     } else {
       num_requests_since_last_success_ = 0;
       RenderWidgetCompositor::DidInitializeOutputSurface();
-      layer_tree_host()->DidLoseOutputSurface();
-      RequestNewOutputSurface();
+      // Post the synchronous composite task so that it is not called
+      // reentrantly as a part of RequestNewOutputSurface.
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&RenderWidgetCompositorOutputSurface::SynchronousComposite,
+                     base::Unretained(this)));
     }
   }
 
   void DidFailToInitializeOutputSurface() override {
     ++num_failures_;
     if (num_requests_ == expected_requests_) {
       EndTest();
       return;
     }
 
@@ skipping 34 matching lines @@
   bool last_create_was_fallback_;
   bool use_null_output_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorOutputSurface);
 };
 
 class RenderWidgetCompositorOutputSurfaceTest : public testing::Test {
  public:
   RenderWidgetCompositorOutputSurfaceTest()
       : render_widget_(make_scoped_refptr(new RenderWidgetOutputSurface)),
-        compositor_deps_(make_scoped_ptr(new FakeCompositorDependencies)),
-        render_widget_compositor_(make_scoped_ptr(
-            new RenderWidgetCompositorOutputSurface(render_widget_.get(),
-                                                    compositor_deps_.get()))) {
+        compositor_deps_(make_scoped_ptr(new FakeCompositorDependencies)) {
+    // Required in order to call the synchronous LayerTreeHost::Composite.
+    compositor_deps_->set_use_single_thread_scheduler(false);
+    render_widget_compositor_.reset(new RenderWidgetCompositorOutputSurface(
+        render_widget_.get(), compositor_deps_.get()));
     render_widget_compositor_->Initialize();
     render_widget_->SetCompositor(render_widget_compositor_.get());
   }
 
   void RunTest(bool use_null_output_surface,
                int num_failures_before_success,
                int expected_successes,
                int expected_fallback_succeses) {
     render_widget_compositor_->SetUp(
         use_null_output_surface, num_failures_before_success,
         expected_successes, expected_fallback_succeses);
+    render_widget_compositor_->StartCompositor();
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&RenderWidgetCompositor::RequestNewOutputSurface,
+        base::Bind(&RenderWidgetCompositorOutputSurface::SynchronousComposite,
                    base::Unretained(render_widget_compositor_.get())));
     base::MessageLoop::current()->Run();
     render_widget_compositor_->AfterTest();
   }
 
  protected:
   base::MessageLoop ye_olde_message_loope_;
   MockRenderThread render_thread_;
   scoped_refptr<RenderWidgetOutputSurface> render_widget_;
   scoped_ptr<FakeCompositorDependencies> compositor_deps_;
@@ skipping 46 matching lines @@
 }
 
 TEST_F(RenderWidgetCompositorOutputSurfaceTest, FallbackSuccessNormalSuccess) {
   // The first success is a fallback, but the next should not be a fallback.
   RunTest(false, RenderWidgetCompositor::OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK,
           1, 1);
 }
 
 }  // namespace
 }  // namespace content