UI Resource Manager

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"
@@ skipping 13 matching lines @@
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_update_queue.h"
 #include "cc/scheduler/frame_rate_controller.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_proxy.h"
+#include "cc/test/fake_scoped_ui_resource.h"
 #include "cc/test/fake_scrollbar_layer.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "skia/ext/refptr.h"
@@ skipping 355 matching lines @@
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->active_tree()->source_frame_number() == 1)
+    if (host_impl->active_tree()->source_frame_number() == 1) {
+      // Before the end of the test, we need to release the UI resources.
+      scrollbar_->SetLayerTreeHost(NULL);
       EndTest();
+    }
   }
 
   virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Changing the device scale factor causes a commit. It also changes
         // the content bounds of |scrollbar_|, which should not generate
         // a second commit as a result.
         layer_tree_host()->SetDeviceScaleFactor(4.f);
         break;
@@ skipping 679 matching lines @@
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<NoScaleContentLayer> root_layer_;
   scoped_refptr<ContentLayer> child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers);
 
 // Verify atomicity of commits and reuse of textures.
-class LayerTreeHostTestAtomicCommit : public LayerTreeHostTest {
+class LayerTreeHostTestDirectRendererAtomicCommit : public LayerTreeHostTest {
  public:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     // Make sure partial texture updates are turned off.
     settings->max_partial_texture_updates = 0;
     // Linear fade animator prevents scrollbars from drawing immediately.
     settings->use_linear_fade_scrollbar_animator = false;
   }
 
   virtual void SetupTree() OVERRIDE {
     layer_ = FakeContentLayer::Create(&client_);
@@ skipping 32 matching lines @@
         // Verify that used texture is correct.
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
 
         context->ResetUsedTextures();
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         // Number of textures should be doubled as the first textures
         // are used by impl thread and cannot by used for update.
-        ASSERT_EQ(4u, context->NumTextures());
+        ASSERT_EQ(3u, context->NumTextures());
         // Number of textures used for commit should still be
         // one for each layer.
         EXPECT_EQ(2u, context->NumUsedTextures());
         // First textures should not have been used.
         EXPECT_FALSE(context->UsedTexture(context->TextureAt(0)));
-        EXPECT_FALSE(context->UsedTexture(context->TextureAt(1)));
+        EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
         // New textures should have been used.
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(2)));
-        EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
-
         context->ResetUsedTextures();
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
@@ skipping 14 matching lines @@
     context->ResetUsedTextures();
   }
 
   virtual void Layout() OVERRIDE {
     layer_->SetNeedsDisplay();
     scrollbar_->SetNeedsDisplay();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
- private:
+ protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
   scoped_refptr<FakeScrollbarLayer> scrollbar_;
   int drew_frame_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestAtomicCommit);
+MULTI_THREAD_DIRECT_RENDERER_TEST_F(
+    LayerTreeHostTestDirectRendererAtomicCommit);
+
+class LayerTreeHostTestDelegatingRendererAtomicCommit
+    : public LayerTreeHostTestDirectRendererAtomicCommit {
+ public:
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    ASSERT_EQ(0u, layer_tree_host()->settings().max_partial_texture_updates);
+
+    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
+        impl->output_surface()->context3d());
+
+    switch (impl->active_tree()->source_frame_number()) {
+      case 0:
+        // Number of textures should be one for each layer
+        ASSERT_EQ(2u, context->NumTextures());
+        // Number of textures used for commit should be one for each layer.
+        EXPECT_EQ(2u, context->NumUsedTextures());
+        // Verify that used texture is correct.
+        EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
+        EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
+        context->ResetUsedTextures();
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 1:
+        // Number of textures should be doubled as the first textures
+        // are used by impl thread and cannot by used for update.
+        ASSERT_EQ(4u, context->NumTextures());
+        // Number of textures used for commit should still be
+        // one for each layer.
+        EXPECT_EQ(2u, context->NumUsedTextures());
+        // First textures should not have been used.
+        EXPECT_FALSE(context->UsedTexture(context->TextureAt(0)));
+        EXPECT_FALSE(context->UsedTexture(context->TextureAt(1)));
+        // New textures should have been used.
+        EXPECT_TRUE(context->UsedTexture(context->TextureAt(2)));
+        EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
+        context->ResetUsedTextures();
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 2:
+        EndTest();
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+};
+
+MULTI_THREAD_DELEGATING_RENDERER_TEST_F(
+    LayerTreeHostTestDelegatingRendererAtomicCommit);
 
 static void SetLayerPropertiesForTesting(Layer* layer,
                                          Layer* parent,
                                          const gfx::Transform& transform,
                                          gfx::PointF anchor,
                                          gfx::PointF position,
                                          gfx::Size bounds,
                                          bool opaque) {
   layer->RemoveAllChildren();
   if (parent)
     parent->AddChild(layer);
   layer->SetTransform(transform);
   layer->SetAnchorPoint(anchor);
   layer->SetPosition(position);
   layer->SetBounds(bounds);
   layer->SetContentsOpaque(opaque);
 }
 
 class LayerTreeHostTestAtomicCommitWithPartialUpdate
     : public LayerTreeHostTest {
  public:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     // Allow one partial texture update.
     settings->max_partial_texture_updates = 1;
-    // Linear fade animator prevents scrollbars from drawing immediately.
-    settings->use_linear_fade_scrollbar_animator = false;
     // No partial updates when impl side painting is enabled.
     settings->impl_side_painting = false;
   }
 
   virtual void SetupTree() OVERRIDE {
     parent_ = FakeContentLayer::Create(&client_);
     parent_->SetBounds(gfx::Size(10, 20));
 
     child_ = FakeContentLayer::Create(&client_);
     child_->SetPosition(gfx::Point(0, 10));
     child_->SetBounds(gfx::Size(3, 10));
 
-    bool paint_scrollbar = true;
-    bool has_thumb = false;
-    scrollbar_with_paints_ =
-        FakeScrollbarLayer::Create(paint_scrollbar, has_thumb, parent_->id());
-    scrollbar_with_paints_->SetPosition(gfx::Point(3, 10));
-    scrollbar_with_paints_->SetBounds(gfx::Size(3, 10));
-
-    paint_scrollbar = false;
-    scrollbar_without_paints_ =
-        FakeScrollbarLayer::Create(paint_scrollbar, has_thumb, parent_->id());
-    scrollbar_without_paints_->SetPosition(gfx::Point(6, 10));
-    scrollbar_without_paints_->SetBounds(gfx::Size(3, 10));
-
     parent_->AddChild(child_);
-    parent_->AddChild(scrollbar_with_paints_);
-    parent_->AddChild(scrollbar_without_paints_);
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         parent_->SetNeedsDisplay();
         child_->SetNeedsDisplay();
-        scrollbar_with_paints_->SetNeedsDisplay();
-        scrollbar_without_paints_->SetNeedsDisplay();
         break;
       case 2:
         // Damage part of layers.
         parent_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
         child_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
-        scrollbar_with_paints_->SetNeedsDisplayRect(
-            gfx::RectF(0.f, 0.f, 5.f, 5.f));
-        scrollbar_without_paints_->SetNeedsDisplayRect(
-            gfx::RectF(0.f, 0.f, 5.f, 5.f));
         break;
       case 3:
         child_->SetNeedsDisplay();
-        scrollbar_with_paints_->SetNeedsDisplay();
-        scrollbar_without_paints_->SetNeedsDisplay();
         layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
         break;
       case 4:
         layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
         break;
       case 5:
         EndTest();
         break;
       default:
         NOTREACHED() << layer_tree_host()->source_frame_number();
         break;
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ASSERT_EQ(1u, layer_tree_host()->settings().max_partial_texture_updates);
 
     TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
         impl->output_surface()->context3d());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // Number of textures should be one for each layer.
-        ASSERT_EQ(4u, context->NumTextures());
+        ASSERT_EQ(2u, context->NumTextures());
         // Number of textures used for commit should be one for each layer.
-        EXPECT_EQ(4u, context->NumUsedTextures());
+        EXPECT_EQ(2u, context->NumUsedTextures());
         // Verify that used textures are correct.
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
+        context->ResetUsedTextures();
+        break;
+      case 1:
+        // Number of textures should be two for each content layer.
+        ASSERT_EQ(4u, context->NumTextures());
+        // Number of textures used for commit should be one for each content
+        // layer.
+        EXPECT_EQ(2u, context->NumUsedTextures());
+
+        // First content textures should not have been used.
+        EXPECT_FALSE(context->UsedTexture(context->TextureAt(0)));
+        EXPECT_FALSE(context->UsedTexture(context->TextureAt(1)));
+        // New textures should have been used.
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(2)));
         EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
 
         context->ResetUsedTextures();
         break;
-      case 1:
-        // Number of textures should be two for each content layer and one
-        // for each scrollbar, since they always do a partial update.
-        ASSERT_EQ(6u, context->NumTextures());
+      case 2:
+        // Number of textures should be two for each content layer.
+        ASSERT_EQ(4u, context->NumTextures());
         // Number of textures used for commit should be one for each content
-        // layer, and one for the scrollbar layer that paints.
-        EXPECT_EQ(3u, context->NumUsedTextures());
+        // layer.
+        EXPECT_EQ(2u, context->NumUsedTextures());
 
-        // First content textures should not have been used.
-        EXPECT_FALSE(context->UsedTexture(context->TextureAt(0)));
-        EXPECT_FALSE(context->UsedTexture(context->TextureAt(1)));
-        // The non-painting scrollbar's texture wasn't updated.
-        EXPECT_FALSE(context->UsedTexture(context->TextureAt(2)));
-        // The painting scrollbar's partial update texture was used.
-        EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
-        // New textures should have been used.
-        EXPECT_TRUE(context->UsedTexture(context->TextureAt(4)));
-        EXPECT_TRUE(context->UsedTexture(context->TextureAt(5)));
+        // One content layer does a partial update also.
+        EXPECT_TRUE(context->UsedTexture(context->TextureAt(2)));
+        EXPECT_FALSE(context->UsedTexture(context->TextureAt(3)));
 
         context->ResetUsedTextures();
         break;
-      case 2:
-        // Number of textures should be two for each content layer and one
-        // for each scrollbar, since they always do a partial update.
-        ASSERT_EQ(6u, context->NumTextures());
-        // Number of textures used for commit should be one for each content
-        // layer, and one for the scrollbar layer that paints.
-        EXPECT_EQ(3u, context->NumUsedTextures());
-
-        // The non-painting scrollbar's texture wasn't updated.
-        EXPECT_FALSE(context->UsedTexture(context->TextureAt(2)));
-        // The painting scrollbar does a partial update.
-        EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
-        // One content layer does a partial update also.
-        EXPECT_TRUE(context->UsedTexture(context->TextureAt(4)));
-        EXPECT_FALSE(context->UsedTexture(context->TextureAt(5)));
-
-        context->ResetUsedTextures();
-        break;
       case 3:
         // No textures should be used for commit.
         EXPECT_EQ(0u, context->NumUsedTextures());
 
         context->ResetUsedTextures();
         break;
       case 4:
-        // Number of textures used for commit should be two. One for the
-        // content layer, and one for the painting scrollbar. The
-        // non-painting scrollbar doesn't update its texture.
-        EXPECT_EQ(2u, context->NumUsedTextures());
+        // Number of textures used for commit should be one, for the
+        // content layer.
+        EXPECT_EQ(1u, context->NumUsedTextures());
 
         context->ResetUsedTextures();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     EXPECT_LT(impl->active_tree()->source_frame_number(), 5);
 
     TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
         impl->output_surface()->context3d());
 
     // Number of textures used for drawing should one per layer except for
     // frame 3 where the viewport only contains one layer.
     if (impl->active_tree()->source_frame_number() == 3) {
       EXPECT_EQ(1u, context->NumUsedTextures());
     } else {
-      EXPECT_EQ(4u, context->NumUsedTextures()) <<
-          "For frame " << impl->active_tree()->source_frame_number();
+      EXPECT_EQ(2u, context->NumUsedTextures()) <<
+        "For frame " << impl->active_tree()->source_frame_number();
     }
 
     context->ResetUsedTextures();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> parent_;
   scoped_refptr<FakeContentLayer> child_;
-  scoped_refptr<FakeScrollbarLayer> scrollbar_with_paints_;
-  scoped_refptr<FakeScrollbarLayer> scrollbar_without_paints_;
 };
 
 // Partial updates are not possible with a delegating renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestAtomicCommitWithPartialUpdate);
 
 class LayerTreeHostTestFinishAllRendering : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFinishAllRendering() : once_(false), draw_count_(0) {}
 
@@ skipping 499 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
 
 class LayerTreeHostWithProxy : public LayerTreeHost {
  public:
   LayerTreeHostWithProxy(FakeLayerTreeHostClient* client,
                          const LayerTreeSettings& settings,
                          scoped_ptr<FakeProxy> proxy)
       : LayerTreeHost(client, settings) {
-        proxy->SetLayerTreeHost(this);
+    proxy->SetLayerTreeHost(this);
     EXPECT_TRUE(InitializeForTesting(proxy.PassAs<Proxy>()));
   }
 };
 
 TEST(LayerTreeHostTest, LimitPartialUpdates) {
   // When partial updates are not allowed, max updates should be 0.
   {
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
     scoped_ptr<FakeProxy> proxy(new FakeProxy);
@@ skipping 416 matching lines @@
   virtual WebKit::WebString getString(WebKit::WGC3Denum name) OVERRIDE {
     if (name == GL_EXTENSIONS) {
       return WebKit::WebString(
           "GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
     }
     return WebKit::WebString();
   }
 
   MOCK_METHOD1(activeTexture, void(WebKit::WGC3Denum texture));
   MOCK_METHOD2(bindTexture, void(WebKit::WGC3Denum target,
-                                WebKit::WebGLId texture_id));
+                                 WebKit::WebGLId texture_id));
   MOCK_METHOD3(texParameteri, void(WebKit::WGC3Denum target,
                                    WebKit::WGC3Denum pname,
                                    WebKit::WGC3Dint param));
   MOCK_METHOD5(texImageIOSurface2DCHROMIUM, void(WebKit::WGC3Denum target,
                                                  WebKit::WGC3Dint width,
                                                  WebKit::WGC3Dint height,
                                                  WebKit::WGC3Duint ioSurfaceId,
                                                  WebKit::WGC3Duint plane));
   MOCK_METHOD4(drawElements, void(WebKit::WGC3Denum mode,
                                   WebKit::WGC3Dsizei count,
@@ skipping 797 matching lines @@
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> layer_;
   bool did_initialize_gl_;
   bool did_release_gl_;
   int last_source_frame_number_drawn_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeferredInitialize);
 
+// Test for UI Resource management.
+class LayerTreeHostTestUIResource : public LayerTreeHostTest {
+ public:
+  LayerTreeHostTestUIResource() : num_commits_(0) {}
+
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual void DidCommit() OVERRIDE {
+    int frame = num_commits_;
+    switch (frame) {
+      case 1:
+        CreateResource();
+        CreateResource();
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 2:
+        // Usually ScopedUIResource are deleted from the manager in their
+        // destructor.  Here we just want to test that a direct call to
+        // DeleteUIResource works.
+        layer_tree_host()->DeleteUIResource(ui_resources_[0]->id());
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 3:
+        // DeleteUIResource can be called with an invalid id.
+        layer_tree_host()->DeleteUIResource(ui_resources_[0]->id());
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 4:
+        CreateResource();
+        CreateResource();
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 5:
+        ClearResources();
+        EndTest();
+        break;
+    }
+  }
+
+  void PerformTest(LayerTreeHostImpl* impl) {
+    TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
+        impl->output_surface()->context3d());
+
+    int frame = num_commits_;
+    switch (frame) {
+      case 1:
+        ASSERT_EQ(0u, context->NumTextures());
+        break;
+      case 2:
+        // Created two textures.
+        ASSERT_EQ(2u, context->NumTextures());
+        break;
+      case 3:
+        // One texture left after one deletion.
+        ASSERT_EQ(1u, context->NumTextures());
+        break;
+      case 4:
+        // Resource manager state should not change when delete is called on an
+        // invalid id.
+        ASSERT_EQ(1u, context->NumTextures());
+        break;
+      case 5:
+        // Creation after deletion: two more creates should total up to
+        // three textures.
+        ASSERT_EQ(3u, context->NumTextures());
+        break;
+    }
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    ++num_commits_;
+    if (!layer_tree_host()->settings().impl_side_painting)
+      PerformTest(impl);
+  }
+
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    if (layer_tree_host()->settings().impl_side_painting)
+      PerformTest(impl);
+  }
+
+  virtual void AfterTest() {}
+
+ private:
+  // Must clear all resources before exiting.
+  void ClearResources() {
+    for (FakeUIResources::iterator iter = ui_resources_.begin();
+         iter != ui_resources_.end();
+         iter++) {
+      delete *iter;
+    }
+    ui_resources_.clear();
+  }
+
+  void CreateResource() {
+    ui_resources_.push_back(new FakeScopedUIResource(layer_tree_host()));
+  }
+
+  typedef std::vector<FakeScopedUIResource*> FakeUIResources;
+  FakeUIResources ui_resources_;
+  int num_commits_;
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostTestUIResource);
+
 class PushPropertiesCountingLayer : public Layer {
  public:
   static scoped_refptr<PushPropertiesCountingLayer> Create() {
     return new PushPropertiesCountingLayer();
   }
 
   virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE {
     Layer::PushPropertiesTo(layer);
     push_properties_count_++;
     if (persist_needs_push_properties_)
@@ skipping 762 matching lines @@
 TEST_F(LayerTreeHostTestTreeActivationCallback, DirectRenderer) {
   RunTest(true, false, true);
 }
 
 TEST_F(LayerTreeHostTestTreeActivationCallback, DelegatingRenderer) {
   RunTest(true, true, true);
 }
 
 }  // namespace
 }  // namespace cc