Give ScopedResource a LayerTreeResourceProvider.

ScopedResource is used for making resources that will be shipped out
of the layer tree compositor. Give it a LayerTreeResourceProvider so
that we reduce the API surface needed by the ResourceProvider base
class to not include creating/deleting these resources, and allowing
us to change how software resource are created.

R=piman@chromium.org

Bug: 730660
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel
Change-Id: Ia89068da79c497539f4cbf98f96bba4b9f4d362b
Reviewed-on: https://chromium-review.googlesource.com/848253
Commit-Queue: danakj <danakj@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#527028}

cc/layers/heads_up_display_layer_impl.cc

@@ -89,7 +89,7 @@ std::unique_ptr<LayerImpl> HeadsUpDisplayLayerImpl::CreateLayerImpl(
 
 void HeadsUpDisplayLayerImpl::AcquireResource(
     DrawMode draw_mode,
-    ResourceProvider* resource_provider) {
+    LayerTreeResourceProvider* resource_provider) {
   for (auto& resource : resources_) {
     if (!resource_provider->InUseByConsumer(resource->id())) {
       resource.swap(resources_.back());
@@ -116,7 +116,7 @@ void HeadsUpDisplayLayerImpl::AcquireResource(
 }
 
 void HeadsUpDisplayLayerImpl::ReleaseUnmatchedSizeResources(
-    ResourceProvider* resource_provider) {
+    LayerTreeResourceProvider* resource_provider) {
   base::EraseIf(resources_,
                 [this](const std::unique_ptr<ScopedResource>& resource) {
                   return internal_content_bounds_ != resource->size();
@@ -170,7 +170,7 @@ void HeadsUpDisplayLayerImpl::AppendQuads(viz::RenderPass* render_pass,
 
 void HeadsUpDisplayLayerImpl::UpdateHudTexture(
     DrawMode draw_mode,
-    ResourceProvider* resource_provider,
+    LayerTreeResourceProvider* resource_provider,
     viz::ContextProvider* context_provider,
     const viz::RenderPassList& list) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE || !resources_.back()->id())

cc/layers/heads_up_display_layer_impl.h

@@ -24,9 +24,13 @@ class SkPaint;
 class SkTypeface;
 struct SkRect;
 
-namespace cc {
+namespace viz {
+class ContextProvider;
+}
 
+namespace cc {
 class FrameRateCounter;
+class LayerTreeResourceProvider;
 
 class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
  public:
@@ -44,7 +48,7 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
   void AppendQuads(viz::RenderPass* render_pass,
                    AppendQuadsData* append_quads_data) override;
   void UpdateHudTexture(DrawMode draw_mode,
-                        ResourceProvider* resource_provider,
+                        LayerTreeResourceProvider* resource_provider,
                         viz::ContextProvider* context_provider,
                         const viz::RenderPassList& list);
 
@@ -133,8 +137,10 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl {
                      const std::string& label_text) const;
   void DrawDebugRects(SkCanvas* canvas, DebugRectHistory* debug_rect_history);
 
-  void AcquireResource(DrawMode draw_mode, ResourceProvider* resource_provider);
-  void ReleaseUnmatchedSizeResources(ResourceProvider* resource_provider);
+  void AcquireResource(DrawMode draw_mode,
+                       LayerTreeResourceProvider* resource_provider);
+  void ReleaseUnmatchedSizeResources(
+      LayerTreeResourceProvider* resource_provider);
 
   std::vector<std::unique_ptr<ScopedResource>> resources_;
   sk_sp<SkSurface> hud_surface_;

cc/raster/gpu_raster_buffer_provider.cc

@@ -21,6 +21,7 @@
 #include "cc/resources/resource.h"
 #include "components/viz/common/gpu/context_provider.h"
 #include "components/viz/common/gpu/raster_context_provider.h"
+#include "components/viz/common/resources/resource_format_utils.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/raster_interface.h"

cc/raster/staging_buffer_pool.cc

@@ -12,6 +12,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/base/container_util.h"
+#include "cc/resources/resource_util.h"
 #include "cc/resources/scoped_resource.h"
 #include "components/viz/common/gpu/raster_context_provider.h"
 #include "gpu/command_buffer/client/raster_interface.h"

cc/raster/zero_copy_raster_buffer_provider.cc

@@ -16,6 +16,7 @@
 #include "cc/resources/layer_tree_resource_provider.h"
 #include "cc/resources/resource.h"
 #include "components/viz/common/resources/platform_color.h"
+#include "components/viz/common/resources/resource_format_utils.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 

cc/resources/resource.h

@@ -5,11 +5,11 @@
 #ifndef CC_RESOURCES_RESOURCE_H_
 #define CC_RESOURCES_RESOURCE_H_
 
-#include "base/logging.h"
 #include "base/macros.h"
 #include "cc/cc_export.h"
-#include "cc/resources/resource_provider.h"
-#include "cc/resources/resource_util.h"
+#include "components/viz/common/resources/resource_format.h"
+#include "components/viz/common/resources/resource_id.h"
+#include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace cc {

cc/resources/resource_pool.cc

@@ -17,7 +17,7 @@
 #include "base/trace_event/memory_dump_manager.h"
 #include "build/build_config.h"
 #include "cc/base/container_util.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/layer_tree_resource_provider.h"
 #include "cc/resources/resource_util.h"
 #include "cc/resources/scoped_resource.h"
 
@@ -42,8 +42,8 @@ bool ResourceMeetsSizeRequirements(const gfx::Size& requested_size,
     return false;
 
   // GetArea will crash on overflow, however all sizes in use are tile sizes.
-  // These are capped at ResourceProvider::max_texture_size(), and will not
-  // overflow.
+  // These are capped at LayerTreeResourceProvider::max_texture_size(), and will
+  // not overflow.
   float actual_area = actual_size.GetArea();
   float requested_area = requested_size.GetArea();
   // Don't use a resource that is more than |kReuseThreshold| times the
@@ -60,10 +60,10 @@ constexpr base::TimeDelta ResourcePool::kDefaultExpirationDelay;
 
 void ResourcePool::PoolResource::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd,
-    const ResourceProvider* resource_provider,
+    const LayerTreeResourceProvider* resource_provider,
     bool is_free) const {
-  // Resource IDs are not process-unique, so log with the ResourceProvider's
-  // unique id.
+  // Resource IDs are not process-unique, so log with the
+  // LayerTreeResourceProvider's unique id.
   std::string parent_node =
       base::StringPrintf("cc/resource_memory/provider_%d/resource_%d",
                          resource_provider->tracing_id(), id());
@@ -84,7 +84,7 @@ void ResourcePool::PoolResource::OnMemoryDump(
   }
 }
 
-ResourcePool::ResourcePool(ResourceProvider* resource_provider,
+ResourcePool::ResourcePool(LayerTreeResourceProvider* resource_provider,
                            base::SingleThreadTaskRunner* task_runner,
                            gfx::BufferUsage usage,
                            const base::TimeDelta& expiration_delay,
@@ -109,7 +109,7 @@ ResourcePool::ResourcePool(ResourceProvider* resource_provider,
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
-ResourcePool::ResourcePool(ResourceProvider* resource_provider,
+ResourcePool::ResourcePool(LayerTreeResourceProvider* resource_provider,
                            bool gpu_resources,
                            base::SingleThreadTaskRunner* task_runner,
                            viz::ResourceTextureHint hint,

cc/resources/resource_pool.h

@@ -15,11 +15,17 @@
 #include "base/macros.h"
 #include "base/memory/memory_coordinator_client.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "cc/cc_export.h"
 #include "cc/resources/resource.h"
 #include "cc/resources/scoped_resource.h"
 #include "components/viz/common/resources/resource_format.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
 
 namespace cc {
 
@@ -31,7 +37,7 @@ class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider,
       base::TimeDelta::FromSeconds(5);
 
   static std::unique_ptr<ResourcePool> CreateForGpuMemoryBufferResources(
-      ResourceProvider* resource_provider,
+      LayerTreeResourceProvider* resource_provider,
       base::SingleThreadTaskRunner* task_runner,
       gfx::BufferUsage usage,
       const base::TimeDelta& expiration_delay,
@@ -42,7 +48,7 @@ class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider,
   }
 
   static std::unique_ptr<ResourcePool> Create(
-      ResourceProvider* resource_provider,
+      LayerTreeResourceProvider* resource_provider,
       bool gpu_resources,
       base::SingleThreadTaskRunner* task_runner,
       viz::ResourceTextureHint hint,
@@ -108,14 +114,14 @@ class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider,
 
  protected:
   // Constructor for creating GPU memory buffer resources.
-  ResourcePool(ResourceProvider* resource_provider,
+  ResourcePool(LayerTreeResourceProvider* resource_provider,
                base::SingleThreadTaskRunner* task_runner,
                gfx::BufferUsage usage,
                const base::TimeDelta& expiration_delay,
                bool disallow_non_exact_reuse);
 
   // Constructor for creating standard resources.
-  ResourcePool(ResourceProvider* resource_provider,
+  ResourcePool(LayerTreeResourceProvider* resource_provider,
                bool gpu_resources,
                base::SingleThreadTaskRunner* task_runner,
                viz::ResourceTextureHint hint,
@@ -128,11 +134,11 @@ class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider,
   class PoolResource : public ScopedResource {
    public:
     static std::unique_ptr<PoolResource> Create(
-        ResourceProvider* resource_provider) {
+        LayerTreeResourceProvider* resource_provider) {
       return base::WrapUnique(new PoolResource(resource_provider));
     }
     void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
-                      const ResourceProvider* resource_provider,
+                      const LayerTreeResourceProvider* resource_provider,
                       bool is_free) const;
 
     uint64_t content_id() const { return content_id_; }
@@ -147,7 +153,7 @@ class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider,
     }
 
    private:
-    explicit PoolResource(ResourceProvider* resource_provider)
+    explicit PoolResource(LayerTreeResourceProvider* resource_provider)
         : ScopedResource(resource_provider), content_id_(0) {}
     uint64_t content_id_;
     base::TimeTicks last_usage_;
@@ -178,7 +184,7 @@ class CC_EXPORT ResourcePool : public base::trace_event::MemoryDumpProvider,
   bool HasEvictableResources() const;
   base::TimeTicks GetUsageTimeForLRUResource() const;
 
-  ResourceProvider* resource_provider_ = nullptr;
+  LayerTreeResourceProvider* resource_provider_ = nullptr;
   bool use_gpu_resources_ = false;
   bool use_gpu_memory_buffers_ = false;
   gfx::BufferUsage usage_ = gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;

cc/resources/resource_pool_unittest.cc

@@ -22,8 +22,8 @@ class ResourcePoolTest : public testing::Test {
   void SetUp() override {
     context_provider_ = TestContextProvider::Create();
     context_provider_->BindToCurrentThread();
-    resource_provider_ =
-        FakeResourceProvider::Create(context_provider_.get(), nullptr);
+    resource_provider_ = FakeResourceProvider::CreateLayerTreeResourceProvider(
+        context_provider_.get(), nullptr);
     task_runner_ = base::ThreadTaskRunnerHandle::Get();
     resource_pool_ =
         ResourcePool::Create(resource_provider_.get(), true, task_runner_.get(),
@@ -39,7 +39,7 @@ class ResourcePoolTest : public testing::Test {
   }
 
   scoped_refptr<TestContextProvider> context_provider_;
-  std::unique_ptr<ResourceProvider> resource_provider_;
+  std::unique_ptr<LayerTreeResourceProvider> resource_provider_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   std::unique_ptr<ResourcePool> resource_pool_;
 };

cc/resources/scoped_resource.cc

@@ -4,9 +4,11 @@
 
 #include "cc/resources/scoped_resource.h"
 
+#include "cc/resources/layer_tree_resource_provider.h"
+
 namespace cc {
 
-ScopedResource::ScopedResource(ResourceProvider* resource_provider)
+ScopedResource::ScopedResource(LayerTreeResourceProvider* resource_provider)
     : resource_provider_(resource_provider) {
   DCHECK(resource_provider_);
 }

cc/resources/scoped_resource.h

@@ -12,16 +12,19 @@
 #include "base/memory/ptr_util.h"
 #include "cc/cc_export.h"
 #include "cc/resources/resource.h"
+#include "components/viz/common/resources/resource_texture_hint.h"
+#include "ui/gfx/buffer_types.h"
 
 #if DCHECK_IS_ON()
 #include "base/threading/platform_thread.h"
 #endif
 
 namespace cc {
+class LayerTreeResourceProvider;
 
 class CC_EXPORT ScopedResource : public Resource {
  public:
-  explicit ScopedResource(ResourceProvider* provider);
+  explicit ScopedResource(LayerTreeResourceProvider* provider);
   virtual ~ScopedResource();
 
   void AllocateSoftware(const gfx::Size& size,
@@ -39,7 +42,7 @@ class CC_EXPORT ScopedResource : public Resource {
   viz::ResourceTextureHint hint() const { return hint_; }
 
  private:
-  ResourceProvider* resource_provider_;
+  LayerTreeResourceProvider* resource_provider_;
   viz::ResourceTextureHint hint_ = viz::ResourceTextureHint::kDefault;
 
 #if DCHECK_IS_ON()

cc/resources/scoped_resource_unittest.cc

@@ -6,9 +6,9 @@
 
 #include <stddef.h>
 
+#include "cc/resources/resource_util.h"
 #include "cc/test/fake_resource_provider.h"
 #include "cc/test/test_context_provider.h"
-#include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
@@ -20,11 +20,9 @@ TEST(ScopedResourceTest, NewScopedResource) {
   ASSERT_EQ(context_provider->BindToCurrentThread(),
             gpu::ContextResult::kSuccess);
 
-  std::unique_ptr<viz::SharedBitmapManager> shared_bitmap_manager(
-      new TestSharedBitmapManager());
-  std::unique_ptr<ResourceProvider> resource_provider =
-      FakeResourceProvider::Create(context_provider.get(),
-                                   shared_bitmap_manager.get());
+  std::unique_ptr<LayerTreeResourceProvider> resource_provider =
+      FakeResourceProvider::CreateLayerTreeResourceProvider(
+          context_provider.get(), nullptr);
   auto texture = std::make_unique<ScopedResource>(resource_provider.get());
 
   // New scoped textures do not hold a texture yet.
@@ -42,11 +40,9 @@ TEST(ScopedResourceTest, CreateScopedResource) {
   ASSERT_EQ(context_provider->BindToCurrentThread(),
             gpu::ContextResult::kSuccess);
 
-  std::unique_ptr<viz::SharedBitmapManager> shared_bitmap_manager(
-      new TestSharedBitmapManager());
-  std::unique_ptr<ResourceProvider> resource_provider =
-      FakeResourceProvider::Create(context_provider.get(),
-                                   shared_bitmap_manager.get());
+  std::unique_ptr<LayerTreeResourceProvider> resource_provider =
+      FakeResourceProvider::CreateLayerTreeResourceProvider(
+          context_provider.get(), nullptr);
   auto texture = std::make_unique<ScopedResource>(resource_provider.get());
   texture->AllocateGpuTexture(gfx::Size(30, 30),
                               viz::ResourceTextureHint::kDefault,
@@ -69,11 +65,9 @@ TEST(ScopedResourceTest, ScopedResourceIsDeleted) {
   ASSERT_EQ(context_provider->BindToCurrentThread(),
             gpu::ContextResult::kSuccess);
 
-  std::unique_ptr<viz::SharedBitmapManager> shared_bitmap_manager(
-      new TestSharedBitmapManager());
-  std::unique_ptr<ResourceProvider> resource_provider =
-      FakeResourceProvider::Create(context_provider.get(),
-                                   shared_bitmap_manager.get());
+  std::unique_ptr<LayerTreeResourceProvider> resource_provider =
+      FakeResourceProvider::CreateLayerTreeResourceProvider(
+          context_provider.get(), nullptr);
   {
     auto texture = std::make_unique<ScopedResource>(resource_provider.get());
 

cc/test/fake_picture_layer_tiling_client.cc

@@ -22,7 +22,7 @@ FakePictureLayerTilingClient::FakePictureLayerTilingClient()
       has_valid_tile_priorities_(true) {}
 
 FakePictureLayerTilingClient::FakePictureLayerTilingClient(
-    ResourceProvider* resource_provider)
+    LayerTreeResourceProvider* resource_provider)
     : resource_pool_(
           ResourcePool::Create(resource_provider,
                                true,

cc/test/fake_picture_layer_tiling_client.h

@@ -13,11 +13,13 @@
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
+class LayerTreeResourceProvider;
 
 class FakePictureLayerTilingClient : public PictureLayerTilingClient {
  public:
   FakePictureLayerTilingClient();
-  explicit FakePictureLayerTilingClient(ResourceProvider* resource_provider);
+  explicit FakePictureLayerTilingClient(
+      LayerTreeResourceProvider* resource_provider);
   ~FakePictureLayerTilingClient() override;
 
   // PictureLayerTilingClient implementation.

cc/tiles/picture_layer_tiling_set_unittest.cc

@@ -250,7 +250,7 @@ class PictureLayerTilingSetTestWithResources : public testing::Test {
     ASSERT_EQ(context_provider->BindToCurrentThread(),
               gpu::ContextResult::kSuccess);
     auto shared_bitmap_manager = std::make_unique<TestSharedBitmapManager>();
-    std::unique_ptr<ResourceProvider> resource_provider =
+    std::unique_ptr<LayerTreeResourceProvider> resource_provider =
         FakeResourceProvider::CreateLayerTreeResourceProvider(
             context_provider.get(), shared_bitmap_manager.get());
 

cc/tiles/tile.cc

@@ -12,6 +12,7 @@
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
+#include "cc/resources/resource_util.h"
 #include "cc/tiles/tile_manager.h"
 #include "components/viz/common/traced_value.h"
 

cc/tiles/tile_draw_info.h

@@ -11,6 +11,7 @@
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "components/viz/common/resources/platform_color.h"
+#include "components/viz/common/resources/resource_format_utils.h"
 
 namespace cc {
 

cc/tiles/tile_manager.cc

@@ -28,6 +28,7 @@
 #include "cc/raster/playback_image_provider.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/task_category.h"
+#include "cc/resources/resource_util.h"
 #include "cc/tiles/frame_viewer_instrumentation.h"
 #include "cc/tiles/tile.h"
 #include "ui/gfx/geometry/axis_transform2d.h"

cc/tiles/tile_manager_unittest.cc

@@ -18,6 +18,7 @@
 #include "cc/raster/raster_source.h"
 #include "cc/raster/synchronous_task_graph_runner.h"
 #include "cc/resources/resource_pool.h"
+#include "cc/resources/resource_util.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_frame_sink.h"
 #include "cc/test/fake_layer_tree_frame_sink_client.h"

components/viz/service/display/gl_renderer.cc

@@ -45,6 +45,7 @@
 #include "components/viz/common/resources/platform_color.h"
 #include "components/viz/common/resources/resource.h"
 #include "components/viz/common/resources/resource_fence.h"
+#include "components/viz/common/resources/resource_format_utils.h"
 #include "components/viz/service/display/draw_polygon.h"
 #include "components/viz/service/display/dynamic_geometry_binding.h"
 #include "components/viz/service/display/layer_quad.h"