cc: Make LayerTreeHostImpl unittests use a delegating output surface.

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 39 matching lines @@
 #include "cc/test/fake_mask_layer_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_raster_source.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/gpu_rasterization_enabled_settings.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/layer_tree_test.h"
+#include "cc/test/test_delegating_output_surface.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/effect_node.h"
+#include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/transform_node.h"
 #include "media/base/media.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
@@ skipping 374 matching lines @@
     std::unique_ptr<ScrollState> scroll_state(
         new ScrollState(scroll_state_data));
     return scroll_state;
   }
 
   void DrawFrame() {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
+    host_impl_->SwapBuffers(frame);
   }
 
   void pinch_zoom_pan_viewport_forces_commit_redraw(float device_scale_factor);
   void pinch_zoom_pan_viewport_test(float device_scale_factor);
   void pinch_zoom_pan_viewport_and_scroll_test(float device_scale_factor);
   void pinch_zoom_pan_viewport_and_scroll_boundary_test(
       float device_scale_factor);
 
   void SetupMouseMoveAtWithDeviceScale(float device_scale_factor);
 
   scoped_refptr<AnimationTimeline> timeline() { return timeline_; }
 
  protected:
   virtual std::unique_ptr<OutputSurface> CreateOutputSurface() {
-    return FakeOutputSurface::Create3d();
+    return FakeOutputSurface::CreateDelegating3d();
   }
 
   void DrawOneFrame() {
     LayerTreeHostImpl::FrameData frame_data;
     host_impl_->PrepareToDraw(&frame_data);
     host_impl_->DidDrawAllLayers(frame_data);
   }
 
   static void SetScrollOffsetDelta(LayerImpl* layer_impl,
                                    const gfx::Vector2dF& delta) {
@@ skipping 79 matching lines @@
   on_can_draw_state_changed_called_ = false;
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
   EXPECT_TRUE(host_impl_->CanDraw());
   EXPECT_TRUE(on_can_draw_state_changed_called_);
   on_can_draw_state_changed_called_ = false;
 }
 
 TEST_F(LayerTreeHostImplTest, ResourcelessDrawWithEmptyViewport) {
   CreateHostImpl(DefaultSettings(),
-                 FakeOutputSurface::CreateSoftware(
+                 FakeOutputSurface::CreateDelegatingSoftware(
                      base::WrapUnique(new SoftwareOutputDevice())));
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   EXPECT_TRUE(host_impl_->CanDraw());
   host_impl_->SetViewportSize(gfx::Size());
   EXPECT_FALSE(host_impl_->CanDraw());
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
@@ skipping 142 matching lines @@
   EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer,
             status.main_thread_scrolling_reasons);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutRenderer) {
   std::unique_ptr<TestWebGraphicsContext3D> context_owned =
       TestWebGraphicsContext3D::Create();
   context_owned->set_context_lost(true);
 
   // Initialization will fail.
-  EXPECT_FALSE(
-      CreateHostImpl(DefaultSettings(),
-                     FakeOutputSurface::Create3d(std::move(context_owned))));
+  EXPECT_FALSE(CreateHostImpl(
+      DefaultSettings(),
+      FakeOutputSurface::CreateDelegating3d(std::move(context_owned))));
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // We should not crash when trying to scroll after the renderer initialization
   // fails.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point()).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain,
             status.main_thread_scrolling_reasons);
@@ skipping 2672 matching lines @@
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   root->test_properties()->force_render_surface = true;
   DidDrawCheckLayer* layer =
       static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     host_impl_->DrawLayers(&frame);
+    host_impl_->SwapBuffers(frame);
     host_impl_->DidDrawAllLayers(frame);
 
     EXPECT_TRUE(layer->will_draw_called());
     EXPECT_TRUE(layer->append_quads_called());
     EXPECT_TRUE(layer->did_draw_called());
   }
 
   host_impl_->SetViewportDamage(gfx::Rect(10, 10));
 
   {
     LayerTreeHostImpl::FrameData frame;
 
     layer->set_will_draw_returns_false();
     layer->ClearDidDrawCheck();
 
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     host_impl_->DrawLayers(&frame);
+    host_impl_->SwapBuffers(frame);
     host_impl_->DidDrawAllLayers(frame);
 
     EXPECT_TRUE(layer->will_draw_called());
     EXPECT_FALSE(layer->append_quads_called());
     EXPECT_FALSE(layer->did_draw_called());
   }
 }
 
 TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   // The root layer is always drawn, so run this test on a child layer that
@@ skipping 13 matching lines @@
   layer->SetBounds(gfx::Size(10, 10));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
   EXPECT_TRUE(layer->visible_layer_rect().IsEmpty());
 
   // Ensure visible_layer_rect for layer is not empty
   layer->SetPosition(gfx::PointF());
   layer->NoteLayerPropertyChanged();
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_TRUE(layer->will_draw_called());
   EXPECT_TRUE(layer->did_draw_called());
 
   EXPECT_FALSE(layer->visible_layer_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) {
   gfx::Size big_size(1000, 1000);
@@ skipping 22 matching lines @@
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(occluded_layer->will_draw_called());
   EXPECT_FALSE(occluded_layer->did_draw_called());
   EXPECT_FALSE(top_layer->will_draw_called());
   EXPECT_FALSE(top_layer->did_draw_called());
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_FALSE(occluded_layer->will_draw_called());
   EXPECT_FALSE(occluded_layer->did_draw_called());
   EXPECT_TRUE(top_layer->will_draw_called());
   EXPECT_TRUE(top_layer->did_draw_called());
 }
 
 TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) {
   host_impl_->active_tree()->SetRootLayerForTesting(
@@ skipping 18 matching lines @@
 
   EXPECT_FALSE(root->did_draw_called());
   EXPECT_FALSE(layer1->did_draw_called());
   EXPECT_FALSE(layer2->did_draw_called());
 
   LayerTreeHostImpl::FrameData frame;
   FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
       *host_impl_->active_tree()->begin());
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_TRUE(root->did_draw_called());
   EXPECT_TRUE(layer1->did_draw_called());
   EXPECT_TRUE(layer2->did_draw_called());
 
   EXPECT_NE(root->render_surface(), layer1->render_surface());
   EXPECT_TRUE(layer1->render_surface());
 }
 
@@ skipping 196 matching lines @@
     EXPECT_EQ(testcase.expected_result, host_impl_->PrepareToDraw(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
     host_impl_->SwapBuffers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest,
        PrepareToDrawWhenDrawAndSwapFullViewportEveryFrame) {
   CreateHostImpl(DefaultSettings(),
-                 FakeOutputSurface::CreateSoftware(
+                 FakeOutputSurface::CreateDelegatingSoftware(
                      base::WrapUnique(new SoftwareOutputDevice())));
 
   const gfx::Transform external_transform;
   const gfx::Rect external_viewport;
   const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
   std::vector<PrepareToDrawSuccessTestCase> cases;
@@ skipping 2661 matching lines @@
 
   // Opaque layer, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
+  host_impl_->SwapBuffers(frame);
 
   // Layer with translucent content and painting, so drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with translucent opacity, drawn with blending.
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 0.5f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with translucent opacity and painting, drawn with blending.
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 0.5f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   layer1->test_properties()->AddChild(BlendStateCheckLayer::Create(
       host_impl_->active_tree(), 3, host_impl_->resource_provider()));
   BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(
       layer1->test_properties()->children[0]);
   layer2->SetPosition(gfx::PointF(4.f, 4.f));
 
   // 2 opaque layers, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 1.f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetContentsOpaque(true);
   layer2->test_properties()->opacity = 1.f;
   layer2->NoteLayerPropertyChanged();
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Parent layer with translucent content, drawn with blending.
   // Child layer with opaque content, drawn without blending.
   layer1->SetContentsOpaque(false);
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Parent layer with translucent content but opaque painting, drawn without
   // blending.
   // Child layer with opaque content, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Parent layer with translucent opacity and opaque content. Since it has a
   // drawing child, it's drawn to a render surface which carries the opacity,
   // so it's itself drawn without blending.
   // Child layer with opaque content, drawn without blending (parent surface
   // carries the inherited opacity).
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 0.5f;
   layer1->NoteLayerPropertyChanged();
   layer1->test_properties()->force_render_surface = true;
   layer1->SetExpectation(false, true);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
       host_impl_->active_tree()->root_layer_for_testing());
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
   layer1->test_properties()->force_render_surface = false;
 
   // Draw again, but with child non-opaque, to make sure
   // layer1 not culled.
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 1.f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetContentsOpaque(true);
   layer2->test_properties()->opacity = 0.5f;
   layer2->NoteLayerPropertyChanged();
   layer2->SetExpectation(true, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // A second way of making the child non-opaque.
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 1.f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetContentsOpaque(false);
   layer2->test_properties()->opacity = 1.f;
   layer2->NoteLayerPropertyChanged();
   layer2->SetExpectation(true, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // And when the layer says its not opaque but is painted opaque, it is not
   // blended.
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 1.f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetContentsOpaque(true);
   layer2->test_properties()->opacity = 1.f;
   layer2->NoteLayerPropertyChanged();
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents, drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents partially culled, drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(5, 5, 5, 2));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents culled, drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(7, 5, 3, 5));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents and translucent contents culled, drawn
   // without blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
+  host_impl_->SwapBuffers(frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
  protected:
   LayerTreeHostImplViewportCoveredTest() :
       gutter_quad_material_(DrawQuad::SOLID_COLOR),
       child_(NULL),
       did_activate_pending_tree_(false) {}
 
   std::unique_ptr<OutputSurface> CreateFakeOutputSurface(bool software) {
     if (software) {
-      return FakeOutputSurface::CreateSoftware(
+      return FakeOutputSurface::CreateDelegatingSoftware(
           base::WrapUnique(new SoftwareOutputDevice()));
     }
-    return FakeOutputSurface::Create3d();
+    return FakeOutputSurface::CreateDelegating3d();
   }
 
   void SetupActiveTreeLayers() {
     host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
     host_impl_->active_tree()->SetRootLayerForTesting(
         LayerImpl::Create(host_impl_->active_tree(), 1));
     host_impl_->active_tree()
         ->root_layer_for_testing()
         ->test_properties()
         ->force_render_surface = true;
@@ skipping 279 matching lines @@
 class FakeDrawableLayerImpl: public LayerImpl {
  public:
   static std::unique_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return base::WrapUnique(new FakeDrawableLayerImpl(tree_impl, id));
   }
  protected:
   FakeDrawableLayerImpl(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id) {}
 };
 
-// Only reshape when we know we are going to draw. Otherwise, the reshape
-// can leave the window at the wrong size if we never draw and the proper
-// viewport size is never set.
-TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {

[enne (OOO), 2016/07/19 23:00:50]

I think this is fine to delete as preparing to draw but not drawing is a
renderer only problem.

-  scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
-  std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(provider));
-  CreateHostImpl(DefaultSettings(), std::move(output_surface));
-
-  std::unique_ptr<LayerImpl> root =
-      FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetBounds(gfx::Size(10, 10));
-  root->SetDrawsContent(true);
-  root->test_properties()->force_render_surface = true;
-  host_impl_->active_tree()->SetRootLayerForTesting(std::move(root));
-  host_impl_->active_tree()->BuildPropertyTreesForTesting();
-
-  EXPECT_FALSE(provider->TestContext3d()->reshape_called());
-  provider->TestContext3d()->clear_reshape_called();
-
-  LayerTreeHostImpl::FrameData frame;
-  host_impl_->SetViewportSize(gfx::Size(10, 10));
-  host_impl_->active_tree()->SetDeviceScaleFactor(1.f);
-  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-  host_impl_->DrawLayers(&frame);
-  EXPECT_TRUE(provider->TestContext3d()->reshape_called());
-  EXPECT_EQ(provider->TestContext3d()->width(), 10);
-  EXPECT_EQ(provider->TestContext3d()->height(), 10);
-  EXPECT_EQ(provider->TestContext3d()->scale_factor(), 1.f);
-  host_impl_->DidDrawAllLayers(frame);
-  provider->TestContext3d()->clear_reshape_called();
-
-  host_impl_->SetViewportSize(gfx::Size(20, 30));
-  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-  host_impl_->DrawLayers(&frame);
-  EXPECT_TRUE(provider->TestContext3d()->reshape_called());
-  EXPECT_EQ(provider->TestContext3d()->width(), 20);
-  EXPECT_EQ(provider->TestContext3d()->height(), 30);
-  EXPECT_EQ(provider->TestContext3d()->scale_factor(), 1.f);
-  host_impl_->DidDrawAllLayers(frame);
-  provider->TestContext3d()->clear_reshape_called();
-
-  host_impl_->active_tree()->SetDeviceScaleFactor(2.f);
-  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-  host_impl_->DrawLayers(&frame);
-  EXPECT_TRUE(provider->TestContext3d()->reshape_called());
-  EXPECT_EQ(provider->TestContext3d()->width(), 20);
-  EXPECT_EQ(provider->TestContext3d()->height(), 30);
-  EXPECT_EQ(provider->TestContext3d()->scale_factor(), 2.f);
-  host_impl_->DidDrawAllLayers(frame);
-  provider->TestContext3d()->clear_reshape_called();
-}
-
 // Make sure damage tracking propagates all the way to the graphics context,
 // where it should request to swap only the sub-buffer that is damaged.
 TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) {
   scoped_refptr<TestContextProvider> context_provider(
       TestContextProvider::Create());
   context_provider->BindToCurrentThread();
   context_provider->TestContext3d()->set_have_post_sub_buffer(true);
 
   std::unique_ptr<FakeOutputSurface> output_surface(
-      FakeOutputSurface::Create3d(context_provider));
+      FakeOutputSurface::CreateDelegating3d(context_provider));
   FakeOutputSurface* fake_output_surface = output_surface.get();
 
   // This test creates its own LayerTreeHostImpl, so
   // that we can force partial swap enabled.
   LayerTreeSettings settings = DefaultSettings();
   settings.renderer_settings.partial_swap_enabled = true;
   std::unique_ptr<LayerTreeHostImpl> layer_tree_host_impl =
       LayerTreeHostImpl::Create(
           settings, this, &task_runner_provider_, &stats_instrumentation_,
           &shared_bitmap_manager_, NULL, &task_graph_runner_,
@@ skipping 18 matching lines @@
   layer_tree_host_impl->active_tree()->SetRootLayerForTesting(std::move(root));
   layer_tree_host_impl->active_tree()->BuildPropertyTreesForTesting();
 
   LayerTreeHostImpl::FrameData frame;
 
   // First frame, the entire screen should get swapped.
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
   layer_tree_host_impl->DrawLayers(&frame);
   layer_tree_host_impl->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
-  gfx::Rect expected_swap_rect(0, 0, 500, 500);
+  gfx::Rect expected_swap_rect(500, 500);
   EXPECT_EQ(expected_swap_rect.ToString(),
             fake_output_surface->last_swap_rect().ToString());
 
   // Second frame, only the damaged area should get swapped. Damage should be
-  // the union of old and new child rects.
-  // expected damage rect: gfx::Rect(26, 28);
-  // expected swap rect: vertically flipped, with origin at bottom left corner.
+  // the union of old and new child rects: gfx::Rect(26, 28).
   layer_tree_host_impl->active_tree()
       ->root_layer_for_testing()
       ->test_properties()
       ->children[0]
       ->SetPosition(gfx::PointF());
   layer_tree_host_impl->active_tree()
       ->root_layer_for_testing()
       ->test_properties()
       ->children[0]
       ->NoteLayerPropertyChanged();
   layer_tree_host_impl->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
   layer_tree_host_impl->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
 
-  // Make sure that partial swap is constrained to the viewport dimensions
-  // expected damage rect: gfx::Rect(500, 500);
-  // expected swap rect: flipped damage rect, but also clamped to viewport
-  expected_swap_rect = gfx::Rect(0, 500-28, 26, 28);
+  expected_swap_rect = gfx::Rect(26, 28);
   EXPECT_EQ(expected_swap_rect.ToString(),
             fake_output_surface->last_swap_rect().ToString());
 
   layer_tree_host_impl->SetViewportSize(gfx::Size(10, 10));
   // This will damage everything.
   layer_tree_host_impl->active_tree()
       ->root_layer_for_testing()
       ->SetBackgroundColor(SK_ColorBLACK);
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
   layer_tree_host_impl->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
 
-  expected_swap_rect = gfx::Rect(0, 0, 10, 10);
+  expected_swap_rect = gfx::Rect(10, 10);
   EXPECT_EQ(expected_swap_rect.ToString(),
             fake_output_surface->last_swap_rect().ToString());
 
   layer_tree_host_impl->ReleaseOutputSurface();
 }
 
 TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
   std::unique_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
@@ skipping 35 matching lines @@
         render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     my_quad->SetNew(
         shared_quad_state, quad_rect, visible_quad_rect, gray, false);
   }
 
  private:
   FakeLayerWithQuads(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id) {}
 };
 
-class MockContext : public TestWebGraphicsContext3D {

[enne (OOO), 2016/07/19 23:00:50]

I do think these should probably be display unit tests of some sort? 
Alternatively, do we cover partial swap and flipping in our pixel tests?

[danakj, 2016/07/20 01:03:25]

I added GLRenderer unittests. Will do some software ones tomorrow.

- public:
-  MOCK_METHOD1(useProgram, void(GLuint program));
-  MOCK_METHOD5(uniform4f, void(GLint location,
-                               GLfloat x,
-                               GLfloat y,
-                               GLfloat z,
-                               GLfloat w));
-  MOCK_METHOD4(uniformMatrix4fv, void(GLint location,
-                                      GLsizei count,
-                                      GLboolean transpose,
-                                      const GLfloat* value));
-  MOCK_METHOD4(drawElements, void(GLenum mode,
-                                  GLsizei count,
-                                  GLenum type,
-                                  GLintptr offset));
-  MOCK_METHOD1(enable, void(GLenum cap));
-  MOCK_METHOD1(disable, void(GLenum cap));
-  MOCK_METHOD4(scissor, void(GLint x,
-                             GLint y,
-                             GLsizei width,
-                             GLsizei height));
-};
-
-class MockContextHarness {
- private:
-  MockContext* context_;
-
- public:
-  explicit MockContextHarness(MockContext* context)
-      : context_(context) {
-    context_->set_have_post_sub_buffer(true);
-
-    // Catch "uninteresting" calls
-    EXPECT_CALL(*context_, useProgram(_))
-        .Times(0);
-
-    EXPECT_CALL(*context_, drawElements(_, _, _, _))
-        .Times(0);
-
-    // These are not asserted
-    EXPECT_CALL(*context_, uniformMatrix4fv(_, _, _, _))
-        .WillRepeatedly(Return());
-
-    EXPECT_CALL(*context_, uniform4f(_, _, _, _, _))
-        .WillRepeatedly(Return());
-
-    // Any un-sanctioned calls to enable() are OK
-    EXPECT_CALL(*context_, enable(_))
-        .WillRepeatedly(Return());
-
-    // Any un-sanctioned calls to disable() are OK
-    EXPECT_CALL(*context_, disable(_))
-        .WillRepeatedly(Return());
-  }
-
-  void MustDrawSolidQuad() {
-    EXPECT_CALL(*context_, drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0))
-        .WillOnce(Return())
-        .RetiresOnSaturation();
-
-    EXPECT_CALL(*context_, useProgram(_))
-        .WillOnce(Return())
-        .RetiresOnSaturation();
-  }
-
-  void MustSetScissor(int x, int y, int width, int height) {
-    EXPECT_CALL(*context_, enable(GL_SCISSOR_TEST))
-        .WillRepeatedly(Return());
-
-    EXPECT_CALL(*context_, scissor(x, y, width, height))
-        .Times(AtLeast(1))
-        .WillRepeatedly(Return());
-  }
-
-  void MustSetNoScissor() {
-    EXPECT_CALL(*context_, disable(GL_SCISSOR_TEST))
-        .WillRepeatedly(Return());
-
-    EXPECT_CALL(*context_, enable(GL_SCISSOR_TEST))
-        .Times(0);
-
-    EXPECT_CALL(*context_, scissor(_, _, _, _))
-        .Times(0);
-  }
-};
-
-TEST_F(LayerTreeHostImplTest, NoPartialSwap) {
-  std::unique_ptr<MockContext> mock_context_owned(new MockContext);
-  MockContext* mock_context = mock_context_owned.get();
-  MockContextHarness harness(mock_context);
-
-  // Run test case
-  LayerTreeSettings settings = DefaultSettings();
-  settings.renderer_settings.partial_swap_enabled = false;
-  CreateHostImpl(settings,
-                 FakeOutputSurface::Create3d(std::move(mock_context_owned)));
-  SetupRootLayerImpl(FakeLayerWithQuads::Create(host_impl_->active_tree(), 1));
-  host_impl_->active_tree()->BuildPropertyTreesForTesting();
-
-  // Without partial swap, and no clipping, no scissor is set.
-  harness.MustDrawSolidQuad();
-  harness.MustSetNoScissor();
-  {
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-    host_impl_->DrawLayers(&frame);
-    host_impl_->DidDrawAllLayers(frame);
-  }
-  Mock::VerifyAndClearExpectations(&mock_context);
-
-  // Without partial swap, but a layer does clip its subtree, one scissor is
-  // set.
-  auto* root = host_impl_->active_tree()->root_layer_for_testing();
-  root->SetMasksToBounds(true);
-  host_impl_->active_tree()->BuildPropertyTreesForTesting();
-  root->NoteLayerPropertyChanged();
-  harness.MustDrawSolidQuad();
-  harness.MustSetScissor(0, 0, 10, 10);
-  {
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-    host_impl_->DrawLayers(&frame);
-    host_impl_->DidDrawAllLayers(frame);
-  }
-  Mock::VerifyAndClearExpectations(&mock_context);
-}
-
-TEST_F(LayerTreeHostImplTest, PartialSwap) {
-  std::unique_ptr<MockContext> context_owned(new MockContext);
-  MockContext* mock_context = context_owned.get();
-  MockContextHarness harness(mock_context);
-
-  LayerTreeSettings settings = DefaultSettings();
-  settings.renderer_settings.partial_swap_enabled = true;
-  CreateHostImpl(settings,
-                 FakeOutputSurface::Create3d(std::move(context_owned)));
-  SetupRootLayerImpl(FakeLayerWithQuads::Create(host_impl_->active_tree(), 1));
-  host_impl_->active_tree()->BuildPropertyTreesForTesting();
-
-  // The first frame is not a partially-swapped one. No scissor should be set.
-  harness.MustSetNoScissor();
-  harness.MustDrawSolidQuad();
-  {
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-    host_impl_->DrawLayers(&frame);
-    host_impl_->DidDrawAllLayers(frame);
-  }
-  Mock::VerifyAndClearExpectations(&mock_context);
-
-  // Damage a portion of the frame.
-  auto* root = host_impl_->active_tree()->root_layer_for_testing();
-  root->SetUpdateRect(gfx::Rect(0, 0, 2, 3));
-  host_impl_->active_tree()->BuildPropertyTreesForTesting();
-
-  // The second frame will be partially-swapped (the y coordinates are flipped).
-  harness.MustSetScissor(0, 7, 2, 3);
-  harness.MustDrawSolidQuad();
-  {
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-    host_impl_->DrawLayers(&frame);
-    host_impl_->DidDrawAllLayers(frame);
-  }
-  Mock::VerifyAndClearExpectations(&mock_context);
-}
-
 static std::unique_ptr<LayerTreeHostImpl> SetupLayersForOpacity(
     LayerTreeSettings settings,
     bool partial_swap,
     LayerTreeHostImplClient* client,
     TaskRunnerProvider* task_runner_provider,
     SharedBitmapManager* manager,
     TaskGraphRunner* task_graph_runner,
     RenderingStatsInstrumentation* stats_instrumentation,
     OutputSurface* output_surface) {
   settings.renderer_settings.partial_swap_enabled = partial_swap;
@@ skipping 62 matching lines @@
   return my_host_impl;
 }
 
 TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorPartialSwap) {
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   provider->BindToCurrentThread();
   provider->TestContext3d()->set_have_post_sub_buffer(true);
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(provider));
+      FakeOutputSurface::CreateDelegating3d(provider));
   std::unique_ptr<LayerTreeHostImpl> my_host_impl = SetupLayersForOpacity(
       DefaultSettings(), true, this, &task_runner_provider_,
       &shared_bitmap_manager, &task_graph_runner, &stats_instrumentation_,
       output_surface.get());
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, my_host_impl->PrepareToDraw(&frame));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
@@ skipping 10 matching lines @@
   my_host_impl->ReleaseOutputSurface();
 }
 
 TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorNoPartialSwap) {
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   provider->BindToCurrentThread();
   provider->TestContext3d()->set_have_post_sub_buffer(true);
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(provider));
+      FakeOutputSurface::CreateDelegating3d(provider));
   std::unique_ptr<LayerTreeHostImpl> my_host_impl = SetupLayersForOpacity(
       DefaultSettings(), false, this, &task_runner_provider_,
       &shared_bitmap_manager, &task_graph_runner, &stats_instrumentation_,
       output_surface.get());
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, my_host_impl->PrepareToDraw(&frame));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
     ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR,
               frame.render_passes[0]->quad_list.front()->material);
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list.front()->material);
 
     my_host_impl->DrawLayers(&frame);
     my_host_impl->DidDrawAllLayers(frame);
   }
   my_host_impl->ReleaseOutputSurface();
 }
 
 TEST_F(LayerTreeHostImplTest, LayersFreeTextures) {
   std::unique_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(std::move(context)));
+      FakeOutputSurface::CreateDelegating3d(std::move(context)));
   CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   std::unique_ptr<LayerImpl> root_layer =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root_layer->SetBounds(gfx::Size(10, 10));
   root_layer->test_properties()->force_render_surface = true;
 
   scoped_refptr<VideoFrame> softwareFrame =
       media::VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
@@ skipping 27 matching lines @@
 class MockDrawQuadsToFillScreenContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD1(useProgram, void(GLuint program));
   MOCK_METHOD4(drawElements, void(GLenum mode,
                                   GLsizei count,
                                   GLenum type,
                                   GLintptr offset));
 };
 
 TEST_F(LayerTreeHostImplTest, HasTransparentBackground) {
-  std::unique_ptr<MockDrawQuadsToFillScreenContext> mock_context_owned(
-      new MockDrawQuadsToFillScreenContext);
-  MockDrawQuadsToFillScreenContext* mock_context = mock_context_owned.get();
-
-  // Run test case
-  LayerTreeSettings settings = DefaultSettings();
-  settings.renderer_settings.partial_swap_enabled = false;
-  CreateHostImpl(settings,
-                 FakeOutputSurface::Create3d(std::move(mock_context_owned)));
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   host_impl_->active_tree()->set_background_color(SK_ColorWHITE);
 
   // Verify one quad is drawn when transparent background set is not set.
   host_impl_->active_tree()->set_has_transparent_background(false);
-  EXPECT_CALL(*mock_context, useProgram(_))
-      .Times(1);
-  EXPECT_CALL(*mock_context, drawElements(_, _, _, _))
-      .Times(1);
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
+  {
+    const auto& root_pass = frame.render_passes.back();
+    ASSERT_EQ(1u, root_pass->quad_list.size());
+    EXPECT_EQ(DrawQuad::SOLID_COLOR, root_pass->quad_list.front()->material);
+  }
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
-  Mock::VerifyAndClearExpectations(&mock_context);
+  host_impl_->SwapBuffers(frame);
+
+  // Cause damage so we would draw something if possible.
+  host_impl_->SetFullRootLayerDamage();
 
   // Verify no quads are drawn when transparent background is set.
   host_impl_->active_tree()->set_has_transparent_background(true);
   host_impl_->SetFullRootLayerDamage();
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
+  {
+    const auto& root_pass = frame.render_passes.back();
+    ASSERT_EQ(0u, root_pass->quad_list.size());
+  }
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
-  Mock::VerifyAndClearExpectations(&mock_context);
+  host_impl_->SwapBuffers(frame);
 }
 
 class LayerTreeHostImplTestWithDelegatingRenderer
     : public LayerTreeHostImplTest {
  protected:
   std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     return FakeOutputSurface::CreateDelegating3d();
   }
 
   void DrawFrameAndTestDamage(const gfx::Rect& expected_damage) {
@@ skipping 195 matching lines @@
     return SoftwareOutputDevice::BeginPaint(damage_rect);
   }
   void EndPaint() override {
     SoftwareOutputDevice::EndPaint();
     ++frames_ended_;
   }
 
   int frames_began_, frames_ended_;
 };
 
-TEST_F(LayerTreeHostImplTest, ForcedDrawToSoftwareDeviceBasicRender) {

[enne (OOO), 2016/07/19 23:00:50]

Do we have a resourceless software draw test somewhere else?

[danakj, 2016/07/20 01:03:25]

LayerTreeHostTestResourcelessSoftwareDraw:
https://cs.chromium.org/chromium/src/cc/trees/layer_tree_host_unittest.cc?rcl...

It tests that we're sending quads to the output surface. It doesn't test a
software device. We could add a SynchronousCompositorOutputSurfaceTest perhaps
to do that. It doesn't have unit tests currently, and if it didn't draw, I guess
we'd hear about that pretty quickly.

-  // No main thread evictions in resourceless software mode.
-  set_reduce_memory_result(false);
-  CountingSoftwareDevice* software_device = new CountingSoftwareDevice();
-  EXPECT_TRUE(CreateHostImpl(
-      DefaultSettings(),
-      FakeOutputSurface::CreateSoftware(base::WrapUnique(software_device))));
-  host_impl_->SetViewportSize(gfx::Size(50, 50));
-
-  SetupScrollAndContentsLayers(gfx::Size(100, 100));
-
-  const gfx::Transform external_transform;
-  const gfx::Rect external_viewport;
-  const gfx::Rect external_clip;
-  const bool resourceless_software_draw = true;
-  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
-                                                 external_transform);
-
-  EXPECT_EQ(0, software_device->frames_began_);
-  EXPECT_EQ(0, software_device->frames_ended_);
-
-  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
-                     resourceless_software_draw);
-
-  EXPECT_EQ(1, software_device->frames_began_);
-  EXPECT_EQ(1, software_device->frames_ended_);
-
-  // Call another API method that is likely to hit nullptr in this mode.
-  std::unique_ptr<base::trace_event::TracedValue> state(
-      new base::trace_event::TracedValue());
-  host_impl_->ActivationStateAsValueInto(state.get());
-}
-
 TEST_F(LayerTreeHostImplTest,
        ForcedDrawToSoftwareDeviceSkipsUnsupportedLayers) {
   set_reduce_memory_result(false);
   EXPECT_TRUE(CreateHostImpl(
-      DefaultSettings(), FakeOutputSurface::CreateSoftware(
+      DefaultSettings(), FakeOutputSurface::CreateDelegatingSoftware(
                              base::WrapUnique(new CountingSoftwareDevice))));
 
   const gfx::Transform external_transform;
   const gfx::Rect external_viewport;
   const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
   host_impl_->SetExternalTilePriorityConstraints(external_viewport,
                                                  external_transform);
 
   // SolidColorLayerImpl will be drawn.
@@ skipping 24 matching lines @@
   host_impl_->ReleaseOutputSurface();
   host_impl_ = nullptr;
 
   LayerTreeSettings settings = DefaultSettings();
   host_impl_ = LayerTreeHostImpl::Create(
       settings, this, &task_runner_provider_, &stats_instrumentation_,
       &shared_bitmap_manager_, &gpu_memory_buffer_manager_, &task_graph_runner_,
       AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0);
 
   output_surface_ =
-      FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create());
+      FakeOutputSurface::CreateDelegating3d(TestWebGraphicsContext3D::Create());
   host_impl_->SetVisible(true);
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_LT(0ul, host_impl_->memory_allocation_limit_bytes());
 }
 
 TEST_F(LayerTreeHostImplTest, RequireHighResWhenVisible) {
   ASSERT_TRUE(host_impl_->active_tree());
 
   // RequiresHighResToDraw is set when new output surface is used.
   EXPECT_TRUE(host_impl_->RequiresHighResToDraw());
@@ skipping 64 matching lines @@
   EXPECT_FALSE(fake_host_impl_->prepare_tiles_needed());
   host_impl_->SetVisible(true);
   EXPECT_TRUE(fake_host_impl_->prepare_tiles_needed());
 }
 
 TEST_F(LayerTreeHostImplTest, UIResourceManagement) {
   std::unique_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   std::unique_ptr<FakeOutputSurface> output_surface =
-      FakeOutputSurface::Create3d();
+      FakeOutputSurface::CreateDelegating3d();
   CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   UIResourceId ui_resource_id = 1;
   bool is_opaque = false;
   UIResourceBitmap bitmap(gfx::Size(1, 1), is_opaque);
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
   ResourceId id1 = host_impl_->ResourceIdForUIResource(ui_resource_id);
@@ skipping 22 matching lines @@
 
   // Should not change state for multiple deletion on one UIResourceId
   host_impl_->DeleteUIResource(ui_resource_id);
   EXPECT_EQ(0u, context3d->NumTextures());
 }
 
 TEST_F(LayerTreeHostImplTest, CreateETC1UIResource) {
   std::unique_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
-  CreateHostImpl(DefaultSettings(), FakeOutputSurface::Create3d());
+  CreateHostImpl(DefaultSettings(), FakeOutputSurface::CreateDelegating3d());
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   gfx::Size size(4, 4);
   // SkImageInfo has no support for ETC1.  The |info| below contains the right
   // total pixel size for the bitmap but not the right height and width.  The
   // correct width/height are passed directly to UIResourceBitmap.
   SkImageInfo info =
       SkImageInfo::Make(4, 2, kAlpha_8_SkColorType, kPremul_SkAlphaType);
   sk_sp<SkPixelRef> pixel_ref(SkMallocPixelRef::NewAllocate(info, 0, 0));
   pixel_ref->setImmutable();
   UIResourceBitmap bitmap(std::move(pixel_ref), size);
   UIResourceId ui_resource_id = 1;
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
   ResourceId id1 = host_impl_->ResourceIdForUIResource(ui_resource_id);
   EXPECT_NE(0u, id1);
 }
 
 void ShutdownReleasesContext_Callback(
     std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostImplTest, ShutdownReleasesContext) {
   scoped_refptr<TestContextProvider> context_provider =
       TestContextProvider::Create();
 
-  CreateHostImpl(DefaultSettings(),
-                 FakeOutputSurface::Create3d(context_provider));
+  CreateHostImpl(
+      DefaultSettings(),
+      base::MakeUnique<TestDelegatingOutputSurface>(
+          context_provider, TestContextProvider::CreateWorker(),
+          FakeOutputSurface::Create3d(context_provider), nullptr, nullptr,
+          RendererSettings(), base::ThreadTaskRunnerHandle::Get().get(),
+          true /* synchronous_composite */));
 
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
 
   LayerImpl* root = host_impl_->active_tree()->root_layer_for_testing();
   root->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(
           base::Bind(&ShutdownReleasesContext_Callback)));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
+  host_impl_->SwapBuffers(frame);
 
   // The CopyOutputResult's callback has a ref on the ContextProvider and a
   // texture in a texture mailbox.
   EXPECT_FALSE(context_provider->HasOneRef());
   EXPECT_EQ(1u, context_provider->TestContext3d()->NumTextures());
 
   host_impl_->ReleaseOutputSurface();
   host_impl_ = nullptr;
 
   // The CopyOutputResult's callback was cancelled, the CopyOutputResult
@@ skipping 2705 matching lines @@
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
   EXPECT_FALSE(host_impl_->use_msaa());
 
   std::unique_ptr<TestWebGraphicsContext3D> context_with_msaa =
       TestWebGraphicsContext3D::Create();
   context_with_msaa->SetMaxSamples(8);
 
   LayerTreeSettings msaaSettings = GpuRasterizationEnabledSettings();
   msaaSettings.gpu_rasterization_msaa_sample_count = 4;
   EXPECT_TRUE(CreateHostImpl(
-      msaaSettings, FakeOutputSurface::Create3d(std::move(context_with_msaa))));
+      msaaSettings,
+      FakeOutputSurface::CreateDelegating3d(std::move(context_with_msaa))));
   host_impl_->SetHasGpuRasterizationTrigger(true);
   host_impl_->SetContentIsSuitableForGpuRasterization(false);
   EXPECT_EQ(GpuRasterizationStatus::MSAA_CONTENT,
             host_impl_->gpu_rasterization_status());
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
   EXPECT_TRUE(host_impl_->use_msaa());
 
   LayerTreeSettings settings = DefaultSettings();
   settings.gpu_rasterization_enabled = false;
-  EXPECT_TRUE(CreateHostImpl(settings, FakeOutputSurface::Create3d()));
+  EXPECT_TRUE(
+      CreateHostImpl(settings, FakeOutputSurface::CreateDelegating3d()));
   host_impl_->SetHasGpuRasterizationTrigger(true);
   host_impl_->SetContentIsSuitableForGpuRasterization(true);
   EXPECT_EQ(GpuRasterizationStatus::OFF_DEVICE,
             host_impl_->gpu_rasterization_status());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 
   settings.gpu_rasterization_forced = true;
-  EXPECT_TRUE(CreateHostImpl(settings, FakeOutputSurface::Create3d()));
+  EXPECT_TRUE(
+      CreateHostImpl(settings, FakeOutputSurface::CreateDelegating3d()));
 
   host_impl_->SetHasGpuRasterizationTrigger(false);
   host_impl_->SetContentIsSuitableForGpuRasterization(false);
   EXPECT_EQ(GpuRasterizationStatus::ON_FORCED,
             host_impl_->gpu_rasterization_status());
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 }
 
 class MsaaIsSlowLayerTreeHostImplTest : public LayerTreeHostImplTest {
  public:
   void CreateHostImplWithMsaaIsSlow(bool msaa_is_slow) {
     LayerTreeSettings settings = DefaultSettings();
     settings.gpu_rasterization_enabled = true;
     settings.gpu_rasterization_msaa_sample_count = 4;
     auto context_provider = TestContextProvider::Create();
     context_provider->UnboundTestContext3d()->SetMaxSamples(4);
     context_provider->UnboundTestContext3d()->set_msaa_is_slow(msaa_is_slow);
     auto msaa_is_normal_output_surface =
-        FakeOutputSurface::Create3d(context_provider);
+        FakeOutputSurface::CreateDelegating3d(context_provider);
     EXPECT_TRUE(
         CreateHostImpl(settings, std::move(msaa_is_normal_output_surface)));
   }
 };
 
 TEST_F(MsaaIsSlowLayerTreeHostImplTest, GpuRasterizationStatusMsaaIsSlow) {
   // Ensure that without the msaa_is_slow cap we raster unsuitable content with
   // msaa.
   CreateHostImplWithMsaaIsSlow(false);
   host_impl_->SetHasGpuRasterizationTrigger(true);
@@ skipping 201 matching lines @@
   settings.gpu_rasterization_forced = true;
 
   host_impl_ = LayerTreeHostImpl::Create(
       settings, this, &task_runner_provider_, &stats_instrumentation_,
       &shared_bitmap_manager_, &gpu_memory_buffer_manager_, &task_graph_runner_,
       AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0);
   host_impl_->SetVisible(true);
 
   // InitializeRenderer with a gpu-raster enabled output surface.
   auto gpu_raster_output_surface =
-      FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create());
+      FakeOutputSurface::CreateDelegating3d(TestWebGraphicsContext3D::Create());
   host_impl_->InitializeRenderer(gpu_raster_output_surface.get());
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 
   // Re-initialize with a software output surface.
-  output_surface_ = FakeOutputSurface::CreateSoftware(
+  output_surface_ = FakeOutputSurface::CreateDelegatingSoftware(
       base::WrapUnique(new SoftwareOutputDevice));
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc