android webview: allow cc to fail hardware draw

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 <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 102 matching lines @@
   void TearDown() override {}
 
   void UpdateRendererCapabilitiesOnImplThread() override {}
   void DidLoseOutputSurfaceOnImplThread() override {}
   void CommitVSyncParameters(base::TimeTicks timebase,
                              base::TimeDelta interval) override {}
   void SetEstimatedParentDrawTime(base::TimeDelta draw_time) override {}
   void SetMaxSwapsPendingOnImplThread(int max) override {}
   void DidSwapBuffersOnImplThread() override {}
   void DidSwapBuffersCompleteOnImplThread() override {}
+  void OnResourcelessSoftareDrawStateChanged(bool resourceless_draw) override {}
   void OnCanDrawStateChanged(bool can_draw) override {
     on_can_draw_state_changed_called_ = true;
   }
   void NotifyReadyToActivate() override {
     did_notify_ready_to_activate_ = true;
     host_impl_->ActivateSyncTree();
   }
   void NotifyReadyToDraw() override {}
   void SetNeedsRedrawOnImplThread() override { did_request_redraw_ = true; }
   void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) override {
@@ skipping 328 matching lines @@
   }
 };
 
 TEST_F(LayerTreeHostImplTest, NotifyIfCanDrawChanged) {
   bool always_draw = false;
   CheckNotifyCalledIfCanDrawChanged(always_draw);
 }
 
 TEST_F(LayerTreeHostImplTest, CanDrawIncompleteFrames) {
   CreateHostImpl(DefaultSettings(),
-                 FakeOutputSurface::CreateAlwaysDrawAndSwap3d());
+                 FakeOutputSurface::CreateSoftware(
+                     make_scoped_ptr(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_->SetExternalDrawConstraints(
+      external_transform, external_viewport, external_clip, external_viewport,
+      external_transform, resourceless_software_draw);
 
   bool always_draw = true;
   CheckNotifyCalledIfCanDrawChanged(always_draw);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaNoLayers) {
   ASSERT_FALSE(host_impl_->active_tree()->root_layer());
 
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
@@ skipping 2630 matching lines @@
     EXPECT_EQ(testcase.expected_result, PrepareToDrawFrame(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
     host_impl_->SwapBuffers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest,
        PrepareToDrawWhenDrawAndSwapFullViewportEveryFrame) {
   CreateHostImpl(DefaultSettings(),
-                 FakeOutputSurface::CreateAlwaysDrawAndSwap3d());
-  EXPECT_TRUE(host_impl_->output_surface()
-                  ->capabilities()
-                  .draw_and_swap_full_viewport_every_frame);
+                 FakeOutputSurface::CreateSoftware(
+                     make_scoped_ptr(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_->SetExternalDrawConstraints(
+      external_transform, external_viewport, external_clip, external_viewport,
+      external_transform, resourceless_software_draw);
 
   std::vector<PrepareToDrawSuccessTestCase> cases;
 
   // 0. Default case.
   cases.push_back(PrepareToDrawSuccessTestCase(DRAW_SUCCESS));
   // 1. Animation with missing tile.
   cases.push_back(PrepareToDrawSuccessTestCase(DRAW_SUCCESS));
   cases.back().layer_between.has_missing_tile = true;
   cases.back().layer_between.is_animating = true;
   // 2. High res required with incomplete tile.
@@ skipping 2390 matching lines @@
 
 class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
  protected:
   LayerTreeHostImplViewportCoveredTest() :
       gutter_quad_material_(DrawQuad::SOLID_COLOR),
       child_(NULL),
       did_activate_pending_tree_(false) {}
 
   scoped_ptr<OutputSurface> CreateFakeOutputSurface(bool always_draw) {
     if (always_draw) {
-      return FakeOutputSurface::CreateAlwaysDrawAndSwap3d();
+      return FakeOutputSurface::CreateSoftware(
+          make_scoped_ptr(new SoftwareOutputDevice()));
     }
     return FakeOutputSurface::Create3d();
   }
 
   void SetupActiveTreeLayers() {
     host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
     host_impl_->active_tree()->SetRootLayer(
         LayerImpl::Create(host_impl_->active_tree(), 1));
     host_impl_->active_tree()->root_layer()->SetHasRenderSurface(true);
     host_impl_->active_tree()->root_layer()->AddChild(
@@ skipping 129 matching lines @@
           texture_quad->uv_bottom_right.y(),
           texture_quad->rect.bottom() / gutter_texture_size_pixels.height());
     }
   }
 
   gfx::Size DipSizeToPixelSize(const gfx::Size& size) {
     return gfx::ScaleToRoundedSize(
         size, host_impl_->active_tree()->device_scale_factor());
   }
 
+  void SetAlwaysDraw() {
+    const gfx::Transform external_transform;
+    const gfx::Rect external_viewport;
+    const gfx::Rect external_clip;
+    const bool resourceless_software_draw = true;
+    host_impl_->SetExternalDrawConstraints(
+        external_transform, external_viewport, external_clip, external_viewport,
+        external_transform, resourceless_software_draw);
+  }
+
   DrawQuad::Material gutter_quad_material_;
   gfx::Size gutter_texture_size_;
   gfx::Size viewport_size_;
   BlendStateCheckLayer* child_;
   bool did_activate_pending_tree_;
 };
 
 TEST_F(LayerTreeHostImplViewportCoveredTest, ViewportCovered) {
   viewport_size_ = gfx::Size(1000, 1000);
 
@@ skipping 21 matching lines @@
   TestEmptyLayer();
   TestLayerInMiddleOfViewport();
   TestLayerIsLargerThanViewport();
 }
 
 TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeGrowViewportInvalid) {
   viewport_size_ = gfx::Size(1000, 1000);
 
   bool always_draw = true;
   CreateHostImpl(DefaultSettings(), CreateFakeOutputSurface(always_draw));
+  SetAlwaysDraw();

[brianderson, 2015/10/21 22:43:04]

Why isn't this called from other LayerTreeHostImplViewportCoveredTest tests when
those used to force draws before this patch too?

[boliu, 2015/10/21 22:46:34]

The above two tests have always_draw = false.

 
   // Pending tree to force active_tree size invalid. Not used otherwise.
   host_impl_->CreatePendingTree();
   host_impl_->SetViewportSize(DipSizeToPixelSize(viewport_size_));
   EXPECT_TRUE(host_impl_->active_tree()->ViewportSizeInvalid());
 
   SetupActiveTreeLayers();
   TestEmptyLayer();
   TestLayerInMiddleOfViewport();
   TestLayerIsLargerThanViewport();
 }
 
 TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeShrinkViewportInvalid) {
   viewport_size_ = gfx::Size(1000, 1000);
 
   bool always_draw = true;
   CreateHostImpl(DefaultSettings(), CreateFakeOutputSurface(always_draw));
+  SetAlwaysDraw();
 
   // Set larger viewport and activate it to active tree.
   host_impl_->CreatePendingTree();
   gfx::Size larger_viewport(viewport_size_.width() + 100,
                             viewport_size_.height() + 100);
   host_impl_->SetViewportSize(DipSizeToPixelSize(larger_viewport));
   EXPECT_TRUE(host_impl_->active_tree()->ViewportSizeInvalid());
   host_impl_->ActivateSyncTree();
   EXPECT_TRUE(did_activate_pending_tree_);
   EXPECT_FALSE(host_impl_->active_tree()->ViewportSizeInvalid());
@@ skipping 2464 matching lines @@
   // Resourceless software draw toggles do not need redraw. Damage is
   // set externally by SynchronousCompositorOutputSurface in this case.
 
   // Setting resourceless_software_draw do not need redraw.
   did_request_redraw_ = false;
   resourceless_software_draw = true;
   host_impl_->SetExternalDrawConstraints(
       external_transform, external_viewport, external_clip1, external_viewport,
       external_transform, resourceless_software_draw);
   EXPECT_FALSE(did_request_redraw_);
-  {
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
-    EXPECT_TRUE(frame.has_no_damage);
-  }
+  // Can't call PrepareToDrawFrame with no change for resourceless software
+  // draw.
 
   // Unsetting resourceless_software_draw do not need redraw.
   did_request_redraw_ = false;
   resourceless_software_draw = false;
   host_impl_->SetExternalDrawConstraints(
       external_transform, external_viewport, external_clip2, external_viewport,
       external_transform, resourceless_software_draw);
   EXPECT_FALSE(did_request_redraw_);
   {
     LayerTreeHostImpl::FrameData frame;
@@ skipping 593 matching lines @@
   host_impl_->ActivateSyncTree();
   host_impl_->active_tree()->UpdateDrawProperties(false);
   active_tree_node =
       host_impl_->active_tree()->property_trees()->transform_tree.Node(
           page_scale_layer->transform_tree_index());
   EXPECT_EQ(active_tree_node->data.post_local_scale_factor, 2.f);
 }
 
 }  // namespace
 }  // namespace cc