Split ResourceProvider into LayerTreeResourceProvider and DisplayResourceProvider
ResourceProvider manages resources shared between producer (render layer tree, browser
layer tree) and consumer (display compositor). The producer writes to resources and
sends it to the consumer, the consumer receives and reads resources. These write/send
and receive/read currently live in a single ResourceProvider. The general idea is to
split the responsibilities in ResourceProvider into two parts: write/send in the
LayerTreeResourceProvider, receive/read in the DisplayResourceProvider.
After investigating the write/read in producer and consumer (list in below table:
https://docs.google.com/spreadsheets/d/1lnyONBganHkiQKw8J-3e3xC7STZkYvSh7dkzxSUFmPw/edit),
most of these Scoped*s are used by both the producer and consumer. So in this patch,
will split send into LayerTreeResourceProvider and receive into DisplayResourceProvider
first.
TODO: split read/write in ResourceProvider into LayerTreeResourceProvider or
DisplayResourceProvider, related bug is
https://bugs.chromium.org/p/chromium/issues/detail?id=757291
BUG=738190
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Ifc686fbd234f325228a8de0c6270500fc1b22fe2
Reviewed-on: https://chromium-review.googlesource.com/599628
Commit-Queue: Xing Xu <xing.xu@intel.com>
Reviewed-by: Eric Karl <ericrk@chromium.org>
Reviewed-by: Fady Samuel <fsamuel@chromium.org>
Reviewed-by: enne <enne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#496211}diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index ef4042c..07488f3 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -253,6 +253,10 @@
"raster/tile_task.h",
"raster/zero_copy_raster_buffer_provider.cc",
"raster/zero_copy_raster_buffer_provider.h",
+ "resources/display_resource_provider.cc",
+ "resources/display_resource_provider.h",
+ "resources/layer_tree_resource_provider.cc",
+ "resources/layer_tree_resource_provider.h",
"resources/memory_history.cc",
"resources/memory_history.h",
"resources/resource.h",
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index 61a63af..b9cc894 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -1061,7 +1061,8 @@
}
TEST_F(TextureLayerImplWithMailboxTest, TestCallbackOnInUseResource) {
- ResourceProvider* provider = host_impl_.active_tree()->resource_provider();
+ LayerTreeResourceProvider* provider =
+ host_impl_.active_tree()->resource_provider();
viz::ResourceId id = provider->CreateResourceFromTextureMailbox(
test_data_.mailbox1_,
SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 33de6cc..346dfe7 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -77,7 +77,7 @@
DirectRenderer::DirectRenderer(const viz::RendererSettings* settings,
OutputSurface* output_surface,
- ResourceProvider* resource_provider)
+ DisplayResourceProvider* resource_provider)
: settings_(settings),
output_surface_(output_surface),
resource_provider_(resource_provider),
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index b387439..0cec4d42 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -17,7 +17,7 @@
#include "cc/output/dc_layer_overlay.h"
#include "cc/output/overlay_processor.h"
#include "cc/quads/tile_draw_quad.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/display_resource_provider.h"
#include "gpu/command_buffer/common/texture_in_use_response.h"
#include "ui/gfx/geometry/quad_f.h"
#include "ui/gfx/geometry/rect.h"
@@ -32,10 +32,10 @@
}
namespace cc {
+class DisplayResourceProvider;
class DrawPolygon;
class OutputSurface;
class RenderPass;
-class ResourceProvider;
class ScopedResource;
// This is the base class for code shared between the GL and software
@@ -46,7 +46,7 @@
public:
DirectRenderer(const viz::RendererSettings* settings,
OutputSurface* output_surface,
- ResourceProvider* resource_provider);
+ DisplayResourceProvider* resource_provider);
virtual ~DirectRenderer();
void Initialize();
@@ -182,7 +182,7 @@
const viz::RendererSettings* const settings_;
OutputSurface* const output_surface_;
- ResourceProvider* const resource_provider_;
+ DisplayResourceProvider* const resource_provider_;
// This can be replaced by test implementations.
std::unique_ptr<OverlayProcessor> overlay_processor_;
diff --git a/cc/output/overlay_candidate.cc b/cc/output/overlay_candidate.cc
index 9a8a214..14f5ca4 100644
--- a/cc/output/overlay_candidate.cc
+++ b/cc/output/overlay_candidate.cc
@@ -12,7 +12,7 @@
#include "cc/quads/stream_video_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
#include "cc/quads/tile_draw_quad.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/display_resource_provider.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/vector3d_f.h"
@@ -193,7 +193,7 @@
OverlayCandidate::~OverlayCandidate() {}
// static
-bool OverlayCandidate::FromDrawQuad(ResourceProvider* resource_provider,
+bool OverlayCandidate::FromDrawQuad(DisplayResourceProvider* resource_provider,
const DrawQuad* quad,
OverlayCandidate* candidate) {
// We don't support an opacity value different than one for an overlay plane.
@@ -254,11 +254,12 @@
}
// static
-bool OverlayCandidate::FromDrawQuadResource(ResourceProvider* resource_provider,
- const DrawQuad* quad,
- viz::ResourceId resource_id,
- bool y_flipped,
- OverlayCandidate* candidate) {
+bool OverlayCandidate::FromDrawQuadResource(
+ DisplayResourceProvider* resource_provider,
+ const DrawQuad* quad,
+ viz::ResourceId resource_id,
+ bool y_flipped,
+ OverlayCandidate* candidate) {
if (!resource_provider->IsOverlayCandidate(resource_id))
return false;
@@ -289,9 +290,10 @@
}
// static
-bool OverlayCandidate::FromTextureQuad(ResourceProvider* resource_provider,
- const TextureDrawQuad* quad,
- OverlayCandidate* candidate) {
+bool OverlayCandidate::FromTextureQuad(
+ DisplayResourceProvider* resource_provider,
+ const TextureDrawQuad* quad,
+ OverlayCandidate* candidate) {
if (quad->background_color != SK_ColorTRANSPARENT)
return false;
if (!FromDrawQuadResource(resource_provider, quad, quad->resource_id(),
@@ -304,7 +306,7 @@
}
// static
-bool OverlayCandidate::FromTileQuad(ResourceProvider* resource_provider,
+bool OverlayCandidate::FromTileQuad(DisplayResourceProvider* resource_provider,
const TileDrawQuad* quad,
OverlayCandidate* candidate) {
if (!FromDrawQuadResource(resource_provider, quad, quad->resource_id(), false,
@@ -317,9 +319,10 @@
}
// static
-bool OverlayCandidate::FromStreamVideoQuad(ResourceProvider* resource_provider,
- const StreamVideoDrawQuad* quad,
- OverlayCandidate* candidate) {
+bool OverlayCandidate::FromStreamVideoQuad(
+ DisplayResourceProvider* resource_provider,
+ const StreamVideoDrawQuad* quad,
+ OverlayCandidate* candidate) {
if (!FromDrawQuadResource(resource_provider, quad, quad->resource_id(), false,
candidate)) {
return false;
diff --git a/cc/output/overlay_candidate.h b/cc/output/overlay_candidate.h
index 2f3f597..a3ee59b 100644
--- a/cc/output/overlay_candidate.h
+++ b/cc/output/overlay_candidate.h
@@ -24,17 +24,17 @@
namespace cc {
+class DisplayResourceProvider;
class DrawQuad;
class StreamVideoDrawQuad;
class TextureDrawQuad;
class TileDrawQuad;
-class ResourceProvider;
class CC_EXPORT OverlayCandidate {
public:
// Returns true and fills in |candidate| if |draw_quad| is of a known quad
// type and contains an overlayable resource.
- static bool FromDrawQuad(ResourceProvider* resource_provider,
+ static bool FromDrawQuad(DisplayResourceProvider* resource_provider,
const DrawQuad* quad,
OverlayCandidate* candidate);
// Returns true if |quad| will not block quads underneath from becoming
@@ -100,18 +100,18 @@
bool overlay_handled;
private:
- static bool FromDrawQuadResource(ResourceProvider* resource_provider,
+ static bool FromDrawQuadResource(DisplayResourceProvider* resource_provider,
const DrawQuad* quad,
viz::ResourceId resource_id,
bool y_flipped,
OverlayCandidate* candidate);
- static bool FromTextureQuad(ResourceProvider* resource_provider,
+ static bool FromTextureQuad(DisplayResourceProvider* resource_provider,
const TextureDrawQuad* quad,
OverlayCandidate* candidate);
- static bool FromTileQuad(ResourceProvider* resource_provider,
+ static bool FromTileQuad(DisplayResourceProvider* resource_provider,
const TileDrawQuad* quad,
OverlayCandidate* candidate);
- static bool FromStreamVideoQuad(ResourceProvider* resource_provider,
+ static bool FromStreamVideoQuad(DisplayResourceProvider* resource_provider,
const StreamVideoDrawQuad* quad,
OverlayCandidate* candidate);
};
diff --git a/cc/output/overlay_processor.cc b/cc/output/overlay_processor.cc
index e593e9e..5a1ee11f 100644
--- a/cc/output/overlay_processor.cc
+++ b/cc/output/overlay_processor.cc
@@ -9,7 +9,7 @@
#include "cc/output/overlay_strategy_single_on_top.h"
#include "cc/output/overlay_strategy_underlay.h"
#include "cc/quads/draw_quad.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/display_resource_provider.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/transform.h"
@@ -20,8 +20,9 @@
// before returning from ProcessForOverlays.
class SendPromotionHintsBeforeReturning {
public:
- SendPromotionHintsBeforeReturning(cc::ResourceProvider* resource_provider,
- cc::OverlayCandidateList* candidates)
+ SendPromotionHintsBeforeReturning(
+ cc::DisplayResourceProvider* resource_provider,
+ cc::OverlayCandidateList* candidates)
: resource_provider_(resource_provider), candidates_(candidates) {}
~SendPromotionHintsBeforeReturning() {
resource_provider_->SendPromotionHints(
@@ -29,7 +30,7 @@
}
private:
- cc::ResourceProvider* resource_provider_;
+ cc::DisplayResourceProvider* resource_provider_;
cc::OverlayCandidateList* candidates_;
DISALLOW_COPY_AND_ASSIGN(SendPromotionHintsBeforeReturning);
@@ -60,7 +61,7 @@
}
bool OverlayProcessor::ProcessForCALayers(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
const OverlayProcessor::FilterOperationsMap& render_pass_filters,
const OverlayProcessor::FilterOperationsMap& render_pass_background_filters,
@@ -88,7 +89,7 @@
}
bool OverlayProcessor::ProcessForDCLayers(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPassList* render_passes,
const OverlayProcessor::FilterOperationsMap& render_pass_filters,
const OverlayProcessor::FilterOperationsMap& render_pass_background_filters,
@@ -109,7 +110,7 @@
}
void OverlayProcessor::ProcessForOverlays(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPassList* render_passes,
const OverlayProcessor::FilterOperationsMap& render_pass_filters,
const OverlayProcessor::FilterOperationsMap& render_pass_background_filters,
diff --git a/cc/output/overlay_processor.h b/cc/output/overlay_processor.h
index 9162982..3b558bf 100644
--- a/cc/output/overlay_processor.h
+++ b/cc/output/overlay_processor.h
@@ -16,8 +16,8 @@
#include "cc/quads/render_pass.h"
namespace cc {
+class DisplayResourceProvider;
class OutputSurface;
-class ResourceProvider;
class CC_EXPORT OverlayProcessor {
public:
@@ -28,7 +28,7 @@
// current set of render passes. Returns true if the strategy was successful
// and adds any additional passes necessary to represent overlays to
// |render_passes|.
- virtual bool Attempt(ResourceProvider* resource_provider,
+ virtual bool Attempt(DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidates,
std::vector<gfx::Rect>* content_bounds) = 0;
@@ -47,7 +47,7 @@
// Attempt to replace quads from the specified root render pass with overlays
// or CALayers. This must be called every frame.
void ProcessForOverlays(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPassList* render_passes,
const FilterOperationsMap& render_pass_filters,
const FilterOperationsMap& render_pass_background_filters,
@@ -65,7 +65,7 @@
private:
bool ProcessForCALayers(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
const FilterOperationsMap& render_pass_filters,
const FilterOperationsMap& render_pass_background_filters,
@@ -73,7 +73,7 @@
CALayerOverlayList* ca_layer_overlays,
gfx::Rect* damage_rect);
bool ProcessForDCLayers(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPassList* render_passes,
const FilterOperationsMap& render_pass_filters,
const FilterOperationsMap& render_pass_background_filters,
diff --git a/cc/output/overlay_strategy_fullscreen.cc b/cc/output/overlay_strategy_fullscreen.cc
index e9401ec..eedd2d3c 100644
--- a/cc/output/overlay_strategy_fullscreen.cc
+++ b/cc/output/overlay_strategy_fullscreen.cc
@@ -22,7 +22,7 @@
OverlayStrategyFullscreen::~OverlayStrategyFullscreen() {}
bool OverlayStrategyFullscreen::Attempt(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list,
std::vector<gfx::Rect>* content_bounds) {
diff --git a/cc/output/overlay_strategy_fullscreen.h b/cc/output/overlay_strategy_fullscreen.h
index 5717330..f8158d92 100644
--- a/cc/output/overlay_strategy_fullscreen.h
+++ b/cc/output/overlay_strategy_fullscreen.h
@@ -20,7 +20,7 @@
OverlayCandidateValidator* capability_checker);
~OverlayStrategyFullscreen() override;
- bool Attempt(ResourceProvider* resource_provider,
+ bool Attempt(DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list,
std::vector<gfx::Rect>* content_bounds) override;
diff --git a/cc/output/overlay_strategy_single_on_top.cc b/cc/output/overlay_strategy_single_on_top.cc
index 8cfda28..138a889e 100644
--- a/cc/output/overlay_strategy_single_on_top.cc
+++ b/cc/output/overlay_strategy_single_on_top.cc
@@ -26,7 +26,7 @@
OverlayStrategySingleOnTop::~OverlayStrategySingleOnTop() {}
bool OverlayStrategySingleOnTop::Attempt(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list,
std::vector<gfx::Rect>* content_bounds) {
diff --git a/cc/output/overlay_strategy_single_on_top.h b/cc/output/overlay_strategy_single_on_top.h
index b305b8f..e8dc61d 100644
--- a/cc/output/overlay_strategy_single_on_top.h
+++ b/cc/output/overlay_strategy_single_on_top.h
@@ -18,7 +18,7 @@
OverlayCandidateValidator* capability_checker);
~OverlayStrategySingleOnTop() override;
- bool Attempt(ResourceProvider* resource_provider,
+ bool Attempt(DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list,
std::vector<gfx::Rect>* content_bounds) override;
diff --git a/cc/output/overlay_strategy_underlay.cc b/cc/output/overlay_strategy_underlay.cc
index c383b6f..70d2daf 100644
--- a/cc/output/overlay_strategy_underlay.cc
+++ b/cc/output/overlay_strategy_underlay.cc
@@ -18,10 +18,11 @@
OverlayStrategyUnderlay::~OverlayStrategyUnderlay() {}
-bool OverlayStrategyUnderlay::Attempt(ResourceProvider* resource_provider,
- RenderPass* render_pass,
- OverlayCandidateList* candidate_list,
- std::vector<gfx::Rect>* content_bounds) {
+bool OverlayStrategyUnderlay::Attempt(
+ DisplayResourceProvider* resource_provider,
+ RenderPass* render_pass,
+ OverlayCandidateList* candidate_list,
+ std::vector<gfx::Rect>* content_bounds) {
QuadList& quad_list = render_pass->quad_list;
for (auto it = quad_list.begin(); it != quad_list.end(); ++it) {
OverlayCandidate candidate;
diff --git a/cc/output/overlay_strategy_underlay.h b/cc/output/overlay_strategy_underlay.h
index c47dd58..fa91cda 100644
--- a/cc/output/overlay_strategy_underlay.h
+++ b/cc/output/overlay_strategy_underlay.h
@@ -23,7 +23,7 @@
OverlayCandidateValidator* capability_checker);
~OverlayStrategyUnderlay() override;
- bool Attempt(ResourceProvider* resource_provider,
+ bool Attempt(DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list,
std::vector<gfx::Rect>* content_bounds) override;
diff --git a/cc/output/overlay_strategy_underlay_cast.cc b/cc/output/overlay_strategy_underlay_cast.cc
index 70921701..bbe3fac 100644
--- a/cc/output/overlay_strategy_underlay_cast.cc
+++ b/cc/output/overlay_strategy_underlay_cast.cc
@@ -18,7 +18,7 @@
OverlayStrategyUnderlayCast::~OverlayStrategyUnderlayCast() {}
bool OverlayStrategyUnderlayCast::Attempt(
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list,
std::vector<gfx::Rect>* content_bounds) {
diff --git a/cc/output/overlay_strategy_underlay_cast.h b/cc/output/overlay_strategy_underlay_cast.h
index 5266bb3..09b7e1cf 100644
--- a/cc/output/overlay_strategy_underlay_cast.h
+++ b/cc/output/overlay_strategy_underlay_cast.h
@@ -19,7 +19,7 @@
OverlayCandidateValidator* capability_checker);
~OverlayStrategyUnderlayCast() override;
- bool Attempt(ResourceProvider* resource_provider,
+ bool Attempt(DisplayResourceProvider* resource_provider,
RenderPass* render_pass,
OverlayCandidateList* candidate_list,
std::vector<gfx::Rect>* content_bounds) override;
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 1c7062f8..adf6619 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -27,7 +27,7 @@
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/stream_video_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/display_resource_provider.h"
#include "cc/test/fake_output_surface_client.h"
#include "cc/test/fake_resource_provider.h"
#include "cc/test/geometry_test_utils.h"
@@ -467,7 +467,7 @@
new OverlayCandidateValidatorType);
shared_bitmap_manager_.reset(new TestSharedBitmapManager());
- resource_provider_ = FakeResourceProvider::Create(
+ resource_provider_ = FakeResourceProvider::Create<DisplayResourceProvider>(
provider_.get(), shared_bitmap_manager_.get());
overlay_processor_.reset(new OverlayProcessor(output_surface_.get()));
@@ -478,7 +478,7 @@
std::unique_ptr<OutputSurfaceType> output_surface_;
FakeOutputSurfaceClient client_;
std::unique_ptr<viz::SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<DisplayResourceProvider> resource_provider_;
std::unique_ptr<OverlayProcessor> overlay_processor_;
gfx::Rect damage_rect_;
std::vector<gfx::Rect> content_bounds_;
@@ -509,8 +509,9 @@
std::unique_ptr<viz::SharedBitmapManager> shared_bitmap_manager(
new TestSharedBitmapManager());
- std::unique_ptr<ResourceProvider> resource_provider =
- FakeResourceProvider::Create(provider.get(), shared_bitmap_manager.get());
+ std::unique_ptr<DisplayResourceProvider> resource_provider =
+ FakeResourceProvider::Create<DisplayResourceProvider>(
+ provider.get(), shared_bitmap_manager.get());
std::unique_ptr<DefaultOverlayProcessor> overlay_processor(
new DefaultOverlayProcessor(&output_surface));
@@ -2272,7 +2273,7 @@
public:
OverlayInfoRendererGL(const viz::RendererSettings* settings,
OutputSurface* output_surface,
- ResourceProvider* resource_provider)
+ DisplayResourceProvider* resource_provider)
: viz::GLRenderer(settings, output_surface, resource_provider, NULL),
expect_overlays_(false) {}
@@ -2324,7 +2325,8 @@
provider_->BindToCurrentThread();
output_surface_.reset(new OutputSurfaceType(provider_));
output_surface_->BindToClient(&output_surface_client_);
- resource_provider_ = FakeResourceProvider::Create(provider_.get(), nullptr);
+ resource_provider_ = FakeResourceProvider::Create<DisplayResourceProvider>(
+ provider_.get(), nullptr);
provider_->support()->SetScheduleOverlayPlaneCallback(base::Bind(
&MockOverlayScheduler::Schedule, base::Unretained(&scheduler_)));
@@ -2366,7 +2368,7 @@
viz::RendererSettings settings_;
FakeOutputSurfaceClient output_surface_client_;
std::unique_ptr<OutputSurfaceType> output_surface_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<DisplayResourceProvider> resource_provider_;
std::unique_ptr<OverlayInfoRendererGL> renderer_;
scoped_refptr<TestContextProvider> provider_;
MockOverlayScheduler scheduler_;
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index e8510d7..fb6756ad 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -55,7 +55,7 @@
SoftwareRenderer::SoftwareRenderer(const viz::RendererSettings* settings,
OutputSurface* output_surface,
- ResourceProvider* resource_provider)
+ DisplayResourceProvider* resource_provider)
: DirectRenderer(settings, output_surface, resource_provider),
output_device_(output_surface->software_device()) {}
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index c718d44..d377da0 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -15,7 +15,7 @@
class OutputSurface;
class PictureDrawQuad;
class RenderPassDrawQuad;
-class ResourceProvider;
+class DisplayResourceProvider;
class SoftwareOutputDevice;
class SolidColorDrawQuad;
class TextureDrawQuad;
@@ -25,7 +25,7 @@
public:
SoftwareRenderer(const viz::RendererSettings* settings,
OutputSurface* output_surface,
- ResourceProvider* resource_provider);
+ DisplayResourceProvider* resource_provider);
~SoftwareRenderer() override;
diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index 5946324..7ab448b 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc
@@ -42,15 +42,15 @@
output_surface_->BindToClient(&output_surface_client_);
shared_bitmap_manager_.reset(new TestSharedBitmapManager());
- resource_provider_ =
- FakeResourceProvider::Create(nullptr, shared_bitmap_manager_.get());
+ resource_provider_ = FakeResourceProvider::Create<DisplayResourceProvider>(
+ nullptr, shared_bitmap_manager_.get());
renderer_ = base::MakeUnique<SoftwareRenderer>(
&settings_, output_surface_.get(), resource_provider());
renderer_->Initialize();
renderer_->SetVisible(true);
}
- ResourceProvider* resource_provider() const {
+ DisplayResourceProvider* resource_provider() const {
return resource_provider_.get();
}
@@ -85,7 +85,7 @@
FakeOutputSurfaceClient output_surface_client_;
std::unique_ptr<FakeOutputSurface> output_surface_;
std::unique_ptr<viz::SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<DisplayResourceProvider> resource_provider_;
std::unique_ptr<SoftwareRenderer> renderer_;
};
diff --git a/cc/raster/bitmap_raster_buffer_provider.cc b/cc/raster/bitmap_raster_buffer_provider.cc
index e3800de..36d7b680 100644
--- a/cc/raster/bitmap_raster_buffer_provider.cc
+++ b/cc/raster/bitmap_raster_buffer_provider.cc
@@ -15,6 +15,7 @@
#include "base/trace_event/trace_event.h"
#include "base/trace_event/trace_event_argument.h"
#include "cc/raster/raster_source.h"
+#include "cc/resources/layer_tree_resource_provider.h"
#include "cc/resources/resource.h"
#include "components/viz/common/resources/platform_color.h"
@@ -23,7 +24,7 @@
class RasterBufferImpl : public RasterBuffer {
public:
- RasterBufferImpl(ResourceProvider* resource_provider,
+ RasterBufferImpl(LayerTreeResourceProvider* resource_provider,
const Resource* resource,
uint64_t resource_content_id,
uint64_t previous_content_id)
@@ -68,13 +69,13 @@
// static
std::unique_ptr<RasterBufferProvider> BitmapRasterBufferProvider::Create(
- ResourceProvider* resource_provider) {
+ LayerTreeResourceProvider* resource_provider) {
return base::WrapUnique<RasterBufferProvider>(
new BitmapRasterBufferProvider(resource_provider));
}
BitmapRasterBufferProvider::BitmapRasterBufferProvider(
- ResourceProvider* resource_provider)
+ LayerTreeResourceProvider* resource_provider)
: resource_provider_(resource_provider) {}
BitmapRasterBufferProvider::~BitmapRasterBufferProvider() {}
diff --git a/cc/raster/bitmap_raster_buffer_provider.h b/cc/raster/bitmap_raster_buffer_provider.h
index 9781886..d257c30 100644
--- a/cc/raster/bitmap_raster_buffer_provider.h
+++ b/cc/raster/bitmap_raster_buffer_provider.h
@@ -18,14 +18,14 @@
}
namespace cc {
-class ResourceProvider;
+class LayerTreeResourceProvider;
class CC_EXPORT BitmapRasterBufferProvider : public RasterBufferProvider {
public:
~BitmapRasterBufferProvider() override;
static std::unique_ptr<RasterBufferProvider> Create(
- ResourceProvider* resource_provider);
+ LayerTreeResourceProvider* resource_provider);
// Overridden from RasterBufferProvider:
std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
@@ -46,13 +46,14 @@
void Shutdown() override;
protected:
- explicit BitmapRasterBufferProvider(ResourceProvider* resource_provider);
+ explicit BitmapRasterBufferProvider(
+ LayerTreeResourceProvider* resource_provider);
private:
std::unique_ptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
const;
- ResourceProvider* resource_provider_;
+ LayerTreeResourceProvider* resource_provider_;
DISALLOW_COPY_AND_ASSIGN(BitmapRasterBufferProvider);
};
diff --git a/cc/raster/gpu_raster_buffer_provider.cc b/cc/raster/gpu_raster_buffer_provider.cc
index 328a4b6..55bff4be 100644
--- a/cc/raster/gpu_raster_buffer_provider.cc
+++ b/cc/raster/gpu_raster_buffer_provider.cc
@@ -99,7 +99,7 @@
GpuRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
GpuRasterBufferProvider* client,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
viz::ResourceId resource_id,
bool resource_has_previous_content)
: client_(client),
@@ -130,7 +130,7 @@
GpuRasterBufferProvider::GpuRasterBufferProvider(
viz::ContextProvider* compositor_context_provider,
viz::ContextProvider* worker_context_provider,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
bool use_distance_field_text,
int gpu_rasterization_msaa_sample_count,
viz::ResourceFormat preferred_tile_format,
diff --git a/cc/raster/gpu_raster_buffer_provider.h b/cc/raster/gpu_raster_buffer_provider.h
index fbbe651..aa275da 100644
--- a/cc/raster/gpu_raster_buffer_provider.h
+++ b/cc/raster/gpu_raster_buffer_provider.h
@@ -9,7 +9,7 @@
#include "base/macros.h"
#include "cc/raster/raster_buffer_provider.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/layer_tree_resource_provider.h"
#include "gpu/command_buffer/common/sync_token.h"
namespace viz {
@@ -22,7 +22,7 @@
public:
GpuRasterBufferProvider(viz::ContextProvider* compositor_context_provider,
viz::ContextProvider* worker_context_provider,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
bool use_distance_field_text,
int gpu_rasterization_msaa_sample_count,
viz::ResourceFormat preferred_tile_format,
@@ -62,7 +62,7 @@
class RasterBufferImpl : public RasterBuffer {
public:
RasterBufferImpl(GpuRasterBufferProvider* client,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
viz::ResourceId resource_id,
bool resource_has_previous_content);
~RasterBufferImpl() override;
@@ -92,7 +92,7 @@
viz::ContextProvider* const compositor_context_provider_;
viz::ContextProvider* const worker_context_provider_;
- ResourceProvider* const resource_provider_;
+ LayerTreeResourceProvider* const resource_provider_;
const bool use_distance_field_text_;
const int msaa_sample_count_;
const viz::ResourceFormat preferred_tile_format_;
diff --git a/cc/raster/one_copy_raster_buffer_provider.cc b/cc/raster/one_copy_raster_buffer_provider.cc
index 5ef5236..07b54f9 100644
--- a/cc/raster/one_copy_raster_buffer_provider.cc
+++ b/cc/raster/one_copy_raster_buffer_provider.cc
@@ -37,7 +37,7 @@
OneCopyRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
OneCopyRasterBufferProvider* client,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
const Resource* resource,
uint64_t previous_content_id)
: client_(client),
@@ -70,7 +70,7 @@
base::SequencedTaskRunner* task_runner,
viz::ContextProvider* compositor_context_provider,
viz::ContextProvider* worker_context_provider,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
int max_copy_texture_chromium_size,
bool use_partial_raster,
int max_staging_buffer_usage_in_bytes,
diff --git a/cc/raster/one_copy_raster_buffer_provider.h b/cc/raster/one_copy_raster_buffer_provider.h
index 92c9ded..34fd5f1 100644
--- a/cc/raster/one_copy_raster_buffer_provider.h
+++ b/cc/raster/one_copy_raster_buffer_provider.h
@@ -10,7 +10,7 @@
#include "base/macros.h"
#include "cc/raster/raster_buffer_provider.h"
#include "cc/raster/staging_buffer_pool.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/layer_tree_resource_provider.h"
#include "components/viz/common/gpu/context_provider.h"
#include "gpu/command_buffer/common/sync_token.h"
@@ -23,7 +23,7 @@
OneCopyRasterBufferProvider(base::SequencedTaskRunner* task_runner,
viz::ContextProvider* compositor_context_provider,
viz::ContextProvider* worker_context_provider,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
int max_copy_texture_chromium_size,
bool use_partial_raster,
int max_staging_buffer_usage_in_bytes,
@@ -66,7 +66,7 @@
class RasterBufferImpl : public RasterBuffer {
public:
RasterBufferImpl(OneCopyRasterBufferProvider* client,
- ResourceProvider* resource_provider,
+ LayerTreeResourceProvider* resource_provider,
const Resource* resource,
uint64_t previous_content_id);
~RasterBufferImpl() override;
@@ -115,7 +115,7 @@
viz::ContextProvider* const compositor_context_provider_;
viz::ContextProvider* const worker_context_provider_;
- ResourceProvider* const resource_provider_;
+ LayerTreeResourceProvider* const resource_provider_;
const int max_bytes_per_copy_operation_;
const bool use_partial_raster_;
diff --git a/cc/raster/raster_buffer_provider_perftest.cc b/cc/raster/raster_buffer_provider_perftest.cc
index 7056b94..3bcf162d 100644
--- a/cc/raster/raster_buffer_provider_perftest.cc
+++ b/cc/raster/raster_buffer_provider_perftest.cc
@@ -309,7 +309,7 @@
protected:
scoped_refptr<viz::ContextProvider> compositor_context_provider_;
scoped_refptr<viz::ContextProvider> worker_context_provider_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<LayerTreeResourceProvider> resource_provider_;
scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
std::unique_ptr<SynchronousTaskGraphRunner> task_graph_runner_;
LapTimer timer_;
@@ -485,13 +485,15 @@
private:
void Create3dResourceProvider() {
resource_provider_ =
- FakeResourceProvider::Create(compositor_context_provider_.get(),
- nullptr, &gpu_memory_buffer_manager_);
+ FakeResourceProvider::Create<LayerTreeResourceProvider>(
+ compositor_context_provider_.get(), nullptr,
+ &gpu_memory_buffer_manager_);
}
void CreateSoftwareResourceProvider() {
resource_provider_ =
- FakeResourceProvider::Create(nullptr, &shared_bitmap_manager_, nullptr);
+ FakeResourceProvider::Create<LayerTreeResourceProvider>(
+ nullptr, &shared_bitmap_manager_, nullptr);
}
std::string TestModifierString() const {
@@ -555,8 +557,9 @@
public:
// Overridden from testing::Test:
void SetUp() override {
- resource_provider_ = FakeResourceProvider::Create(
- compositor_context_provider_.get(), nullptr);
+ resource_provider_ =
+ FakeResourceProvider::Create<LayerTreeResourceProvider>(
+ compositor_context_provider_.get(), nullptr);
}
void RunBuildTileTaskGraphTest(const std::string& test_name,
diff --git a/cc/raster/raster_buffer_provider_unittest.cc b/cc/raster/raster_buffer_provider_unittest.cc
index 1033b227..54ad4bb 100644
--- a/cc/raster/raster_buffer_provider_unittest.cc
+++ b/cc/raster/raster_buffer_provider_unittest.cc
@@ -297,14 +297,16 @@
worker_context_provider_ = TestContextProvider::CreateWorker();
TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
context3d->set_support_sync_query(true);
- resource_provider_ = FakeResourceProvider::Create(
- context_provider_.get(), &shared_bitmap_manager_,
- &gpu_memory_buffer_manager_);
+ resource_provider_ =
+ FakeResourceProvider::Create<LayerTreeResourceProvider>(
+ context_provider_.get(), &shared_bitmap_manager_,
+ &gpu_memory_buffer_manager_);
}
void CreateSoftwareResourceProvider() {
- resource_provider_ = FakeResourceProvider::Create(
- nullptr, &shared_bitmap_manager_, &gpu_memory_buffer_manager_);
+ resource_provider_ =
+ FakeResourceProvider::Create<LayerTreeResourceProvider>(
+ nullptr, &shared_bitmap_manager_, &gpu_memory_buffer_manager_);
}
void OnTimeout() {
@@ -315,7 +317,7 @@
protected:
scoped_refptr<TestContextProvider> context_provider_;
scoped_refptr<TestContextProvider> worker_context_provider_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<LayerTreeResourceProvider> resource_provider_;
std::unique_ptr<TileTaskManager> tile_task_manager_;
std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
diff --git a/cc/resources/display_resource_provider.cc b/cc/resources/display_resource_provider.cc
new file mode 100644
index 0000000..2a39010f
--- /dev/null
+++ b/cc/resources/display_resource_provider.cc
@@ -0,0 +1,210 @@
+// Copyright 2017 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/resources/display_resource_provider.h"
+
+#include "base/trace_event/trace_event.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "third_party/skia/include/gpu/GrBackendSurface.h"
+
+using gpu::gles2::GLES2Interface;
+
+namespace cc {
+
+DisplayResourceProvider::DisplayResourceProvider(
+ viz::ContextProvider* compositor_context_provider,
+ viz::SharedBitmapManager* shared_bitmap_manager,
+ gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+ BlockingTaskRunner* blocking_main_thread_task_runner,
+ bool delegated_sync_points_required,
+ bool enable_color_correct_rasterization,
+ const viz::ResourceSettings& resource_settings)
+ : ResourceProvider(compositor_context_provider,
+ shared_bitmap_manager,
+ gpu_memory_buffer_manager,
+ blocking_main_thread_task_runner,
+ delegated_sync_points_required,
+ enable_color_correct_rasterization,
+ resource_settings) {}
+
+DisplayResourceProvider::~DisplayResourceProvider() {}
+
+#if defined(OS_ANDROID)
+void DisplayResourceProvider::SendPromotionHints(
+ const OverlayCandidateList::PromotionHintInfoMap& promotion_hints) {
+ GLES2Interface* gl = ContextGL();
+ if (!gl)
+ return;
+
+ for (const auto& id : wants_promotion_hints_set_) {
+ const ResourceMap::iterator it = resources_.find(id);
+ if (it == resources_.end())
+ continue;
+
+ if (it->second.marked_for_deletion)
+ continue;
+
+ const Resource* resource = LockForRead(id);
+ DCHECK(resource->wants_promotion_hint);
+
+ // Insist that this is backed by a GPU texture.
+ if (ResourceProvider::IsGpuResourceType(resource->type)) {
+ DCHECK(resource->gl_id);
+ auto iter = promotion_hints.find(id);
+ bool promotable = iter != promotion_hints.end();
+ gl->OverlayPromotionHintCHROMIUM(resource->gl_id, promotable,
+ promotable ? iter->second.x() : 0,
+ promotable ? iter->second.y() : 0,
+ promotable ? iter->second.width() : 0,
+ promotable ? iter->second.height() : 0);
+ }
+ UnlockForRead(id);
+ }
+}
+#endif
+
+DisplayResourceProvider::ScopedBatchReturnResources::ScopedBatchReturnResources(
+ DisplayResourceProvider* resource_provider)
+ : resource_provider_(resource_provider) {
+ resource_provider_->SetBatchReturnResources(true);
+}
+
+DisplayResourceProvider::ScopedBatchReturnResources::
+ ~ScopedBatchReturnResources() {
+ resource_provider_->SetBatchReturnResources(false);
+}
+
+void DisplayResourceProvider::SetBatchReturnResources(bool batch) {
+ DCHECK_NE(batch_return_resources_, batch);
+ batch_return_resources_ = batch;
+ if (!batch) {
+ for (const auto& resources : batched_returning_resources_) {
+ ChildMap::iterator child_it = children_.find(resources.first);
+ DCHECK(child_it != children_.end());
+ DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, resources.second);
+ }
+ batched_returning_resources_.clear();
+ }
+}
+
+int DisplayResourceProvider::CreateChild(
+ const ReturnCallback& return_callback) {
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+ Child child_info;
+ child_info.return_callback = return_callback;
+
+ int child = next_child_++;
+ children_[child] = child_info;
+ return child;
+}
+
+void DisplayResourceProvider::SetChildNeedsSyncTokens(int child_id,
+ bool needs) {
+ ChildMap::iterator it = children_.find(child_id);
+ DCHECK(it != children_.end());
+ it->second.needs_sync_tokens = needs;
+}
+
+void DisplayResourceProvider::DestroyChild(int child_id) {
+ ChildMap::iterator it = children_.find(child_id);
+ DCHECK(it != children_.end());
+ DestroyChildInternal(it, NORMAL);
+}
+
+void DisplayResourceProvider::ReceiveFromChild(
+ int child,
+ const std::vector<viz::TransferableResource>& resources) {
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+ GLES2Interface* gl = ContextGL();
+ Child& child_info = children_.find(child)->second;
+ DCHECK(!child_info.marked_for_deletion);
+ for (std::vector<viz::TransferableResource>::const_iterator it =
+ resources.begin();
+ it != resources.end(); ++it) {
+ ResourceIdMap::iterator resource_in_map_it =
+ child_info.child_to_parent_map.find(it->id);
+ if (resource_in_map_it != child_info.child_to_parent_map.end()) {
+ Resource* resource = GetResource(resource_in_map_it->second);
+ resource->marked_for_deletion = false;
+ resource->imported_count++;
+ continue;
+ }
+
+ if ((!it->is_software && !gl) ||
+ (it->is_software && !shared_bitmap_manager_)) {
+ TRACE_EVENT0("cc", "ResourceProvider::ReceiveFromChild dropping invalid");
+ std::vector<viz::ReturnedResource> to_return;
+ to_return.push_back(it->ToReturnedResource());
+ child_info.return_callback.Run(to_return,
+ blocking_main_thread_task_runner_);
+ continue;
+ }
+
+ viz::ResourceId local_id = next_id_++;
+ Resource* resource = nullptr;
+ if (it->is_software) {
+ resource = InsertResource(local_id,
+ Resource(it->mailbox_holder.mailbox, it->size,
+ Resource::DELEGATED, GL_LINEAR));
+ } else {
+ resource = InsertResource(
+ local_id, Resource(0, it->size, Resource::DELEGATED,
+ it->mailbox_holder.texture_target, it->filter,
+ TEXTURE_HINT_IMMUTABLE, RESOURCE_TYPE_GL_TEXTURE,
+ it->format));
+ resource->buffer_format = it->buffer_format;
+ resource->SetMailbox(viz::TextureMailbox(
+ it->mailbox_holder.mailbox, it->mailbox_holder.sync_token,
+ it->mailbox_holder.texture_target));
+ resource->read_lock_fences_enabled = it->read_lock_fences_enabled;
+ resource->is_overlay_candidate = it->is_overlay_candidate;
+#if defined(OS_ANDROID)
+ resource->is_backed_by_surface_texture = it->is_backed_by_surface_texture;
+ resource->wants_promotion_hint = it->wants_promotion_hint;
+ if (resource->wants_promotion_hint)
+ wants_promotion_hints_set_.insert(local_id);
+#endif
+ resource->color_space = it->color_space;
+ }
+ resource->child_id = child;
+ // Don't allocate a texture for a child.
+ resource->allocated = true;
+ resource->imported_count = 1;
+ resource->id_in_child = it->id;
+ child_info.child_to_parent_map[it->id] = local_id;
+ }
+}
+
+void DisplayResourceProvider::DeclareUsedResourcesFromChild(
+ int child,
+ const viz::ResourceIdSet& resources_from_child) {
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+ ChildMap::iterator child_it = children_.find(child);
+ DCHECK(child_it != children_.end());
+ Child& child_info = child_it->second;
+ DCHECK(!child_info.marked_for_deletion);
+
+ ResourceIdArray unused;
+ for (ResourceIdMap::iterator it = child_info.child_to_parent_map.begin();
+ it != child_info.child_to_parent_map.end(); ++it) {
+ viz::ResourceId local_id = it->second;
+ bool resource_is_in_use = resources_from_child.count(it->first) > 0;
+ if (!resource_is_in_use)
+ unused.push_back(local_id);
+ }
+ DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, unused);
+}
+
+const ResourceProvider::ResourceIdMap&
+DisplayResourceProvider::GetChildToParentMap(int child) const {
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+ ChildMap::const_iterator it = children_.find(child);
+ DCHECK(it != children_.end());
+ DCHECK(!it->second.marked_for_deletion);
+ return it->second.child_to_parent_map;
+}
+
+} // namespace cc
diff --git a/cc/resources/display_resource_provider.h b/cc/resources/display_resource_provider.h
new file mode 100644
index 0000000..bde33df
--- /dev/null
+++ b/cc/resources/display_resource_provider.h
@@ -0,0 +1,98 @@
+// Copyright 2017 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.
+
+#ifndef CC_RESOURCES_DISPLAY_RESOURCE_PROVIDER_H_
+#define CC_RESOURCES_DISPLAY_RESOURCE_PROVIDER_H_
+
+#include "build/build_config.h"
+#include "cc/resources/resource_provider.h"
+
+namespace viz {
+class SharedBitmapManager;
+} // namespace viz
+
+namespace cc {
+class BlockingTaskRunner;
+
+// This class is not thread-safe and can only be called from the thread it was
+// created on.
+class CC_EXPORT DisplayResourceProvider : public ResourceProvider {
+ public:
+ DisplayResourceProvider(
+ viz::ContextProvider* compositor_context_provider,
+ viz::SharedBitmapManager* shared_bitmap_manager,
+ gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+ BlockingTaskRunner* blocking_main_thread_task_runner,
+ bool delegated_sync_points_required,
+ bool enable_color_correct_rasterization,
+ const viz::ResourceSettings& resource_settings);
+ ~DisplayResourceProvider() override;
+
+#if defined(OS_ANDROID)
+ // Send an overlay promotion hint to all resources that requested it via
+ // |wants_promotion_hints_set_|. |promotable_hints| contains all the
+ // resources that should be told that they're promotable. Others will be told
+ // that they're not promotable right now.
+ void SendPromotionHints(
+ const OverlayCandidateList::PromotionHintInfoMap& promotion_hints);
+#endif
+
+ // All resources that are returned to children while an instance of this
+ // class exists will be stored and returned when the instance is destroyed.
+ class CC_EXPORT ScopedBatchReturnResources {
+ public:
+ explicit ScopedBatchReturnResources(
+ DisplayResourceProvider* resource_provider);
+ ~ScopedBatchReturnResources();
+
+ private:
+ DisplayResourceProvider* const resource_provider_;
+
+ DISALLOW_COPY_AND_ASSIGN(ScopedBatchReturnResources);
+ };
+
+ // Creates accounting for a child. Returns a child ID.
+ int CreateChild(const ReturnCallback& return_callback);
+
+ // Destroys accounting for the child, deleting all accounted resources.
+ void DestroyChild(int child);
+
+ // Sets whether resources need sync points set on them when returned to this
+ // child. Defaults to true.
+ void SetChildNeedsSyncTokens(int child, bool needs_sync_tokens);
+
+ // Gets the child->parent resource ID map.
+ const ResourceIdMap& GetChildToParentMap(int child) const;
+
+ // Receives resources from a child, moving them from mailboxes. Resource IDs
+ // passed are in the child namespace, and will be translated to the parent
+ // namespace, added to the child->parent map.
+ // This adds the resources to the working set in the ResourceProvider without
+ // declaring which resources are in use. Use DeclareUsedResourcesFromChild
+ // after calling this method to do that. All calls to ReceiveFromChild should
+ // be followed by a DeclareUsedResourcesFromChild.
+ // NOTE: if the sync_token is set on any viz::TransferableResource, this will
+ // wait on it.
+ void ReceiveFromChild(
+ int child,
+ const std::vector<viz::TransferableResource>& transferable_resources);
+
+ // Once a set of resources have been received, they may or may not be used.
+ // This declares what set of resources are currently in use from the child,
+ // releasing any other resources back to the child.
+ void DeclareUsedResourcesFromChild(
+ int child,
+ const viz::ResourceIdSet& resources_from_child);
+
+ private:
+ friend class ScopedBatchReturnResources;
+
+ void SetBatchReturnResources(bool aggregate);
+
+ DISALLOW_COPY_AND_ASSIGN(DisplayResourceProvider);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_DISPLAY_RESOURCE_PROVIDER_H_
diff --git a/cc/resources/layer_tree_resource_provider.cc b/cc/resources/layer_tree_resource_provider.cc
new file mode 100644
index 0000000..6f757e7
--- /dev/null
+++ b/cc/resources/layer_tree_resource_provider.cc
@@ -0,0 +1,216 @@
+// Copyright 2017 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/resources/layer_tree_resource_provider.h"
+
+#include "build/build_config.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+
+using gpu::gles2::GLES2Interface;
+
+namespace cc {
+
+LayerTreeResourceProvider::LayerTreeResourceProvider(
+ viz::ContextProvider* compositor_context_provider,
+ viz::SharedBitmapManager* shared_bitmap_manager,
+ gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+ BlockingTaskRunner* blocking_main_thread_task_runner,
+ bool delegated_sync_points_required,
+ bool enable_color_correct_rasterization,
+ const viz::ResourceSettings& resource_settings)
+ : ResourceProvider(compositor_context_provider,
+ shared_bitmap_manager,
+ gpu_memory_buffer_manager,
+ blocking_main_thread_task_runner,
+ delegated_sync_points_required,
+ enable_color_correct_rasterization,
+ resource_settings) {}
+
+LayerTreeResourceProvider::~LayerTreeResourceProvider() {}
+
+gpu::SyncToken LayerTreeResourceProvider::GetSyncTokenForResources(
+ const ResourceIdArray& resource_ids) {
+ gpu::SyncToken latest_sync_token;
+ for (viz::ResourceId id : resource_ids) {
+ const gpu::SyncToken& sync_token = GetResource(id)->mailbox().sync_token();
+ if (sync_token.release_count() > latest_sync_token.release_count())
+ latest_sync_token = sync_token;
+ }
+ return latest_sync_token;
+}
+
+void LayerTreeResourceProvider::PrepareSendToParent(
+ const ResourceIdArray& resource_ids,
+ std::vector<viz::TransferableResource>* list) {
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+ GLES2Interface* gl = ContextGL();
+
+ // This function goes through the array multiple times, store the resources
+ // as pointers so we don't have to look up the resource id multiple times.
+ std::vector<Resource*> resources;
+ resources.reserve(resource_ids.size());
+ for (const viz::ResourceId id : resource_ids)
+ resources.push_back(GetResource(id));
+
+ // Lazily create any mailboxes and verify all unverified sync tokens.
+ std::vector<GLbyte*> unverified_sync_tokens;
+ std::vector<Resource*> need_synchronization_resources;
+ for (Resource* resource : resources) {
+ if (!ResourceProvider::IsGpuResourceType(resource->type))
+ continue;
+
+ CreateMailbox(resource);
+
+ if (settings_.delegated_sync_points_required) {
+ if (resource->needs_sync_token()) {
+ need_synchronization_resources.push_back(resource);
+ } else if (!resource->mailbox().sync_token().verified_flush()) {
+ unverified_sync_tokens.push_back(resource->GetSyncTokenData());
+ }
+ }
+ }
+
+ // Insert sync point to synchronize the mailbox creation or bound textures.
+ gpu::SyncToken new_sync_token;
+ if (!need_synchronization_resources.empty()) {
+ DCHECK(settings_.delegated_sync_points_required);
+ DCHECK(gl);
+ const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
+ gl->OrderingBarrierCHROMIUM();
+ gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, new_sync_token.GetData());
+ unverified_sync_tokens.push_back(new_sync_token.GetData());
+ }
+
+ if (!unverified_sync_tokens.empty()) {
+ DCHECK(settings_.delegated_sync_points_required);
+ DCHECK(gl);
+ gl->VerifySyncTokensCHROMIUM(unverified_sync_tokens.data(),
+ unverified_sync_tokens.size());
+ }
+
+ // Set sync token after verification.
+ for (Resource* resource : need_synchronization_resources) {
+ DCHECK(ResourceProvider::IsGpuResourceType(resource->type));
+ resource->UpdateSyncToken(new_sync_token);
+ resource->SetSynchronized();
+ }
+
+ // Transfer Resources
+ DCHECK_EQ(resources.size(), resource_ids.size());
+ for (size_t i = 0; i < resources.size(); ++i) {
+ Resource* source = resources[i];
+ const viz::ResourceId id = resource_ids[i];
+
+ DCHECK(!settings_.delegated_sync_points_required ||
+ !source->needs_sync_token());
+ DCHECK(!settings_.delegated_sync_points_required ||
+ Resource::LOCALLY_USED != source->synchronization_state());
+
+ viz::TransferableResource resource;
+ TransferResource(source, id, &resource);
+
+ source->exported_count++;
+ list->push_back(resource);
+ }
+}
+
+void LayerTreeResourceProvider::ReceiveReturnsFromParent(
+ const std::vector<viz::ReturnedResource>& resources) {
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+ GLES2Interface* gl = ContextGL();
+
+ std::unordered_map<int, ResourceIdArray> resources_for_child;
+
+ for (const viz::ReturnedResource& returned : resources) {
+ viz::ResourceId local_id = returned.id;
+ ResourceMap::iterator map_iterator = resources_.find(local_id);
+ // Resource was already lost (e.g. it belonged to a child that was
+ // destroyed).
+ if (map_iterator == resources_.end())
+ continue;
+
+ Resource* resource = &map_iterator->second;
+
+ CHECK_GE(resource->exported_count, returned.count);
+ resource->exported_count -= returned.count;
+ resource->lost |= returned.lost;
+ if (resource->exported_count)
+ continue;
+
+ if (returned.sync_token.HasData()) {
+ DCHECK(!resource->has_shared_bitmap_id);
+ if (resource->origin == Resource::INTERNAL) {
+ DCHECK(resource->gl_id);
+ gl->WaitSyncTokenCHROMIUM(returned.sync_token.GetConstData());
+ resource->SetSynchronized();
+ } else {
+ DCHECK(!resource->gl_id);
+ resource->UpdateSyncToken(returned.sync_token);
+ }
+ }
+
+ if (!resource->marked_for_deletion)
+ continue;
+
+ if (!resource->child_id) {
+ // The resource belongs to this LayerTreeResourceProvider, so it can be
+ // destroyed.
+ DeleteResourceInternal(map_iterator, NORMAL);
+ continue;
+ }
+
+ DCHECK(resource->origin == Resource::DELEGATED);
+ resources_for_child[resource->child_id].push_back(local_id);
+ }
+
+ for (const auto& children : resources_for_child) {
+ ChildMap::iterator child_it = children_.find(children.first);
+ DCHECK(child_it != children_.end());
+ DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, children.second);
+ }
+}
+
+void LayerTreeResourceProvider::TransferResource(
+ Resource* source,
+ viz::ResourceId id,
+ viz::TransferableResource* resource) {
+ DCHECK(!source->locked_for_write);
+ DCHECK(!source->lock_for_read_count);
+ DCHECK(source->origin != Resource::EXTERNAL || source->mailbox().IsValid());
+ DCHECK(source->allocated);
+ resource->id = id;
+ resource->format = source->format;
+ resource->buffer_format = source->buffer_format;
+ resource->mailbox_holder.texture_target = source->target;
+ resource->filter = source->filter;
+ resource->size = source->size;
+ resource->read_lock_fences_enabled = source->read_lock_fences_enabled;
+ resource->is_overlay_candidate = source->is_overlay_candidate;
+#if defined(OS_ANDROID)
+ resource->is_backed_by_surface_texture = source->is_backed_by_surface_texture;
+ resource->wants_promotion_hint = source->wants_promotion_hint;
+#endif
+ resource->color_space = source->color_space;
+
+ if (source->type == RESOURCE_TYPE_BITMAP) {
+ resource->mailbox_holder.mailbox = source->shared_bitmap_id;
+ resource->is_software = true;
+ if (source->shared_bitmap) {
+ resource->shared_bitmap_sequence_number =
+ source->shared_bitmap->sequence_number();
+ } else {
+ resource->shared_bitmap_sequence_number = 0;
+ }
+ } else {
+ DCHECK(source->mailbox().IsValid());
+ DCHECK(source->mailbox().IsTexture());
+ // This is either an external resource, or a compositor resource that we
+ // already exported. Make sure to forward the sync point that we were given.
+ resource->mailbox_holder.mailbox = source->mailbox().mailbox();
+ resource->mailbox_holder.texture_target = source->mailbox().target();
+ resource->mailbox_holder.sync_token = source->mailbox().sync_token();
+ }
+}
+
+} // namespace cc
diff --git a/cc/resources/layer_tree_resource_provider.h b/cc/resources/layer_tree_resource_provider.h
new file mode 100644
index 0000000..9795fba
--- /dev/null
+++ b/cc/resources/layer_tree_resource_provider.h
@@ -0,0 +1,59 @@
+// Copyright 2017 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.
+
+#ifndef CC_RESOURCES_LAYER_TREE_RESOURCE_PROVIDER_H_
+#define CC_RESOURCES_LAYER_TREE_RESOURCE_PROVIDER_H_
+
+#include "cc/resources/resource_provider.h"
+
+namespace viz {
+class SharedBitmapManager;
+} // namespace viz
+
+namespace cc {
+class BlockingTaskRunner;
+
+// This class is not thread-safe and can only be called from the thread it was
+// created on (in practice, the impl thread).
+class CC_EXPORT LayerTreeResourceProvider : public ResourceProvider {
+ public:
+ LayerTreeResourceProvider(
+ viz::ContextProvider* compositor_context_provider,
+ viz::SharedBitmapManager* shared_bitmap_manager,
+ gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+ BlockingTaskRunner* blocking_main_thread_task_runner,
+ bool delegated_sync_points_required,
+ bool enable_color_correct_rasterization,
+ const viz::ResourceSettings& resource_settings);
+ ~LayerTreeResourceProvider() override;
+
+ // Gets the most recent sync token from the indicated resources.
+ gpu::SyncToken GetSyncTokenForResources(const ResourceIdArray& resource_ids);
+
+ // Prepares resources to be transfered to the parent, moving them to
+ // mailboxes and serializing meta-data into TransferableResources.
+ // Resources are not removed from the ResourceProvider, but are marked as
+ // "in use".
+ void PrepareSendToParent(
+ const ResourceIdArray& resource_ids,
+ std::vector<viz::TransferableResource>* transferable_resources);
+
+ // Receives resources from the parent, moving them from mailboxes. Resource
+ // IDs passed are in the child namespace.
+ // NOTE: if the sync_token is set on any viz::TransferableResource, this will
+ // wait on it.
+ void ReceiveReturnsFromParent(
+ const std::vector<viz::ReturnedResource>& transferable_resources);
+
+ private:
+ void TransferResource(Resource* source,
+ viz::ResourceId id,
+ viz::TransferableResource* resource);
+
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeResourceProvider);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_LAYER_TREE_RESOURCE_PROVIDER_H_
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index eea5e7b0f..fc86a43 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -88,10 +88,6 @@
namespace {
-bool IsGpuResourceType(ResourceProvider::ResourceType type) {
- return type != ResourceProvider::RESOURCE_TYPE_BITMAP;
-}
-
GLenum TextureToStorageFormat(viz::ResourceFormat format) {
GLenum storage_format = GL_RGBA8_OES;
switch (format) {
@@ -388,14 +384,14 @@
shared_bitmap_manager_(shared_bitmap_manager),
gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
- lost_context_provider_(false),
next_id_(1),
next_child_(1),
+ lost_context_provider_(false),
buffer_to_texture_target_map_(
resource_settings.buffer_to_texture_target_map),
tracing_id_(g_next_resource_provider_tracing_id.GetNext()) {
DCHECK(resource_settings.texture_id_allocation_chunk_size);
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
// Don't register a dump provider in these cases.
@@ -589,7 +585,7 @@
const gfx::ColorSpace& color_space) {
DCHECK_LE(size.width(), settings_.max_texture_size);
DCHECK_LE(size.height(), settings_.max_texture_size);
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// TODO(crbug.com/590317): We should not assume that all resources created by
// ResourceProvider are GPU_READ_CPU_READ_WRITE. We should determine this
@@ -611,7 +607,7 @@
viz::ResourceId ResourceProvider::CreateBitmapResource(
const gfx::Size& size,
const gfx::ColorSpace& color_space) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
std::unique_ptr<viz::SharedBitmap> bitmap =
shared_bitmap_manager_->AllocateSharedBitmap(size);
@@ -632,7 +628,7 @@
std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl,
bool read_lock_fences_enabled,
gfx::BufferFormat buffer_format) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// Just store the information. Mailbox will be consumed in LockForRead().
viz::ResourceId id = next_id_++;
DCHECK(mailbox.IsValid());
@@ -691,7 +687,7 @@
}
void ResourceProvider::DeleteResource(viz::ResourceId id) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
ResourceMap::iterator it = resources_.find(id);
CHECK(it != resources_.end());
Resource* resource = &it->second;
@@ -877,17 +873,6 @@
}
}
-gpu::SyncToken ResourceProvider::GetSyncTokenForResources(
- const ResourceIdArray& resource_ids) {
- gpu::SyncToken latest_sync_token;
- for (viz::ResourceId id : resource_ids) {
- const gpu::SyncToken& sync_token = GetResource(id)->mailbox().sync_token();
- if (sync_token.release_count() > latest_sync_token.release_count())
- latest_sync_token = sync_token;
- }
- return latest_sync_token;
-}
-
ResourceProvider::Resource* ResourceProvider::InsertResource(
viz::ResourceId id,
Resource resource) {
@@ -898,7 +883,7 @@
}
ResourceProvider::Resource* ResourceProvider::GetResource(viz::ResourceId id) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(id);
ResourceMap::iterator it = resources_.find(id);
DCHECK(it != resources_.end());
@@ -951,7 +936,7 @@
}
void ResourceProvider::UnlockForRead(viz::ResourceId id) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
ResourceMap::iterator it = resources_.find(id);
CHECK(it != resources_.end());
@@ -1356,16 +1341,6 @@
return gpu_memory_buffer_.get();
}
-ResourceProvider::ScopedBatchReturnResources::ScopedBatchReturnResources(
- ResourceProvider* resource_provider)
- : resource_provider_(resource_provider) {
- resource_provider_->SetBatchReturnResources(true);
-}
-
-ResourceProvider::ScopedBatchReturnResources::~ScopedBatchReturnResources() {
- resource_provider_->SetBatchReturnResources(false);
-}
-
ResourceProvider::SynchronousFence::SynchronousFence(
gpu::gles2::GLES2Interface* gl)
: gl_(gl), has_synchronized_(true) {}
@@ -1393,32 +1368,9 @@
gl_->Finish();
}
-int ResourceProvider::CreateChild(const ReturnCallback& return_callback) {
- DCHECK(thread_checker_.CalledOnValidThread());
-
- Child child_info;
- child_info.return_callback = return_callback;
-
- int child = next_child_++;
- children_[child] = child_info;
- return child;
-}
-
-void ResourceProvider::SetChildNeedsSyncTokens(int child_id, bool needs) {
- ChildMap::iterator it = children_.find(child_id);
- DCHECK(it != children_.end());
- it->second.needs_sync_tokens = needs;
-}
-
-void ResourceProvider::DestroyChild(int child_id) {
- ChildMap::iterator it = children_.find(child_id);
- DCHECK(it != children_.end());
- DestroyChildInternal(it, NORMAL);
-}
-
void ResourceProvider::DestroyChildInternal(ChildMap::iterator it,
DeleteStyle style) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
Child& child = it->second;
DCHECK(style == FOR_SHUTDOWN || !child.marked_for_deletion);
@@ -1436,324 +1388,11 @@
DeleteAndReturnUnusedResourcesToChild(it, style, resources_for_child);
}
-const ResourceProvider::ResourceIdMap& ResourceProvider::GetChildToParentMap(
- int child) const {
- DCHECK(thread_checker_.CalledOnValidThread());
- ChildMap::const_iterator it = children_.find(child);
- DCHECK(it != children_.end());
- DCHECK(!it->second.marked_for_deletion);
- return it->second.child_to_parent_map;
-}
-
-void ResourceProvider::PrepareSendToParent(
- const ResourceIdArray& resource_ids,
- std::vector<viz::TransferableResource>* list) {
- DCHECK(thread_checker_.CalledOnValidThread());
- GLES2Interface* gl = ContextGL();
-
- // This function goes through the array multiple times, store the resources
- // as pointers so we don't have to look up the resource id multiple times.
- std::vector<Resource*> resources;
- resources.reserve(resource_ids.size());
- for (const viz::ResourceId id : resource_ids)
- resources.push_back(GetResource(id));
-
- // Lazily create any mailboxes and verify all unverified sync tokens. Also
- // upload GMB resources to GPU if necessary.
- std::vector<GLbyte*> unverified_sync_tokens;
- std::vector<Resource*> need_synchronization_resources;
- for (Resource* resource : resources) {
- if (!IsGpuResourceType(resource->type))
- continue;
-
- CreateMailbox(resource);
-
- if (settings_.delegated_sync_points_required) {
- if (resource->needs_sync_token()) {
- need_synchronization_resources.push_back(resource);
- } else if (!resource->mailbox().sync_token().verified_flush()) {
- unverified_sync_tokens.push_back(resource->GetSyncTokenData());
- }
- }
- }
-
- // Insert sync point to synchronize the mailbox creation or bound textures.
- gpu::SyncToken new_sync_token;
- if (!need_synchronization_resources.empty()) {
- DCHECK(settings_.delegated_sync_points_required);
- DCHECK(gl);
- const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
- gl->OrderingBarrierCHROMIUM();
- gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, new_sync_token.GetData());
- unverified_sync_tokens.push_back(new_sync_token.GetData());
- }
-
- if (!unverified_sync_tokens.empty()) {
- DCHECK(settings_.delegated_sync_points_required);
- DCHECK(gl);
- gl->VerifySyncTokensCHROMIUM(unverified_sync_tokens.data(),
- unverified_sync_tokens.size());
- }
-
- // Set sync token after verification.
- for (Resource* resource : need_synchronization_resources) {
- DCHECK(IsGpuResourceType(resource->type));
- resource->UpdateSyncToken(new_sync_token);
- resource->SetSynchronized();
- }
-
- // Transfer Resources
- DCHECK_EQ(resources.size(), resource_ids.size());
- for (size_t i = 0; i < resources.size(); ++i) {
- Resource* source = resources[i];
- const viz::ResourceId id = resource_ids[i];
-
- DCHECK(!settings_.delegated_sync_points_required ||
- !source->needs_sync_token());
- DCHECK(!settings_.delegated_sync_points_required ||
- Resource::LOCALLY_USED != source->synchronization_state());
-
- viz::TransferableResource resource;
- TransferResource(source, id, &resource);
-
- source->exported_count++;
- list->push_back(resource);
- }
-}
-
-void ResourceProvider::ReceiveFromChild(
- int child,
- const std::vector<viz::TransferableResource>& resources) {
- DCHECK(thread_checker_.CalledOnValidThread());
- GLES2Interface* gl = ContextGL();
- Child& child_info = children_.find(child)->second;
- DCHECK(!child_info.marked_for_deletion);
- for (std::vector<viz::TransferableResource>::const_iterator it =
- resources.begin();
- it != resources.end(); ++it) {
- ResourceIdMap::iterator resource_in_map_it =
- child_info.child_to_parent_map.find(it->id);
- if (resource_in_map_it != child_info.child_to_parent_map.end()) {
- Resource* resource = GetResource(resource_in_map_it->second);
- resource->marked_for_deletion = false;
- resource->imported_count++;
- continue;
- }
-
- if ((!it->is_software && !gl) ||
- (it->is_software && !shared_bitmap_manager_)) {
- TRACE_EVENT0("cc", "ResourceProvider::ReceiveFromChild dropping invalid");
- std::vector<viz::ReturnedResource> to_return;
- to_return.push_back(it->ToReturnedResource());
- child_info.return_callback.Run(to_return,
- blocking_main_thread_task_runner_);
- continue;
- }
-
- viz::ResourceId local_id = next_id_++;
- Resource* resource = nullptr;
- if (it->is_software) {
- resource = InsertResource(local_id,
- Resource(it->mailbox_holder.mailbox, it->size,
- Resource::DELEGATED, GL_LINEAR));
- } else {
- resource = InsertResource(
- local_id, Resource(0, it->size, Resource::DELEGATED,
- it->mailbox_holder.texture_target, it->filter,
- TEXTURE_HINT_IMMUTABLE, RESOURCE_TYPE_GL_TEXTURE,
- it->format));
- resource->buffer_format = it->buffer_format;
- resource->SetMailbox(viz::TextureMailbox(
- it->mailbox_holder.mailbox, it->mailbox_holder.sync_token,
- it->mailbox_holder.texture_target));
- resource->read_lock_fences_enabled = it->read_lock_fences_enabled;
- resource->is_overlay_candidate = it->is_overlay_candidate;
-#if defined(OS_ANDROID)
- resource->is_backed_by_surface_texture = it->is_backed_by_surface_texture;
- resource->wants_promotion_hint = it->wants_promotion_hint;
- if (resource->wants_promotion_hint)
- wants_promotion_hints_set_.insert(local_id);
-#endif
- resource->color_space = it->color_space;
- }
- resource->child_id = child;
- // Don't allocate a texture for a child.
- resource->allocated = true;
- resource->imported_count = 1;
- resource->id_in_child = it->id;
- child_info.child_to_parent_map[it->id] = local_id;
- }
-}
-
-void ResourceProvider::DeclareUsedResourcesFromChild(
- int child,
- const viz::ResourceIdSet& resources_from_child) {
- DCHECK(thread_checker_.CalledOnValidThread());
-
- ChildMap::iterator child_it = children_.find(child);
- DCHECK(child_it != children_.end());
- Child& child_info = child_it->second;
- DCHECK(!child_info.marked_for_deletion);
-
- ResourceIdArray unused;
- for (ResourceIdMap::iterator it = child_info.child_to_parent_map.begin();
- it != child_info.child_to_parent_map.end(); ++it) {
- viz::ResourceId local_id = it->second;
- bool resource_is_in_use = resources_from_child.count(it->first) > 0;
- if (!resource_is_in_use)
- unused.push_back(local_id);
- }
- DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, unused);
-}
-
-void ResourceProvider::ReceiveReturnsFromParent(
- const std::vector<viz::ReturnedResource>& resources) {
- DCHECK(thread_checker_.CalledOnValidThread());
- GLES2Interface* gl = ContextGL();
-
- std::unordered_map<int, ResourceIdArray> resources_for_child;
-
- for (const viz::ReturnedResource& returned : resources) {
- viz::ResourceId local_id = returned.id;
- ResourceMap::iterator map_iterator = resources_.find(local_id);
- // Resource was already lost (e.g. it belonged to a child that was
- // destroyed).
- if (map_iterator == resources_.end())
- continue;
-
- Resource* resource = &map_iterator->second;
-
- CHECK_GE(resource->exported_count, returned.count);
- resource->exported_count -= returned.count;
- resource->lost |= returned.lost;
- if (resource->exported_count)
- continue;
-
- if (returned.sync_token.HasData()) {
- DCHECK(!resource->has_shared_bitmap_id);
- if (resource->origin == Resource::INTERNAL) {
- DCHECK(resource->gl_id);
- gl->WaitSyncTokenCHROMIUM(returned.sync_token.GetConstData());
- resource->SetSynchronized();
- } else {
- DCHECK(!resource->gl_id);
- resource->UpdateSyncToken(returned.sync_token);
- }
- }
-
- if (!resource->marked_for_deletion)
- continue;
-
- if (!resource->child_id) {
- // The resource belongs to this ResourceProvider, so it can be destroyed.
- DeleteResourceInternal(map_iterator, NORMAL);
- continue;
- }
-
- DCHECK(resource->origin == Resource::DELEGATED);
- resources_for_child[resource->child_id].push_back(local_id);
- }
-
- for (const auto& children : resources_for_child) {
- ChildMap::iterator child_it = children_.find(children.first);
- DCHECK(child_it != children_.end());
- DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, children.second);
- }
-}
-
-void ResourceProvider::SetBatchReturnResources(bool batch) {
- DCHECK_NE(batch_return_resources_, batch);
- batch_return_resources_ = batch;
- if (!batch) {
- for (const auto& resources : batched_returning_resources_) {
- ChildMap::iterator child_it = children_.find(resources.first);
- DCHECK(child_it != children_.end());
- DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, resources.second);
- }
- batched_returning_resources_.clear();
- }
-}
-
-#if defined(OS_ANDROID)
-void ResourceProvider::SendPromotionHints(
- const OverlayCandidateList::PromotionHintInfoMap& promotion_hints) {
- GLES2Interface* gl = ContextGL();
- if (!gl)
- return;
-
- for (const auto& id : wants_promotion_hints_set_) {
- const ResourceMap::iterator it = resources_.find(id);
- if (it == resources_.end())
- continue;
-
- if (it->second.marked_for_deletion)
- continue;
-
- const Resource* resource = LockForRead(id);
- DCHECK(resource->wants_promotion_hint);
-
- // Insist that this is backed by a GPU texture.
- if (IsGpuResourceType(resource->type)) {
- DCHECK(resource->gl_id);
- auto iter = promotion_hints.find(id);
- bool promotable = iter != promotion_hints.end();
- gl->OverlayPromotionHintCHROMIUM(resource->gl_id, promotable,
- promotable ? iter->second.x() : 0,
- promotable ? iter->second.y() : 0,
- promotable ? iter->second.width() : 0,
- promotable ? iter->second.height() : 0);
- }
- UnlockForRead(id);
- }
-}
-#endif
-
-void ResourceProvider::TransferResource(Resource* source,
- viz::ResourceId id,
- viz::TransferableResource* resource) {
- DCHECK(!source->locked_for_write);
- DCHECK(!source->lock_for_read_count);
- DCHECK(source->origin != Resource::EXTERNAL || source->mailbox().IsValid());
- DCHECK(source->allocated);
- resource->id = id;
- resource->format = source->format;
- resource->buffer_format = source->buffer_format;
- resource->mailbox_holder.texture_target = source->target;
- resource->filter = source->filter;
- resource->size = source->size;
- resource->read_lock_fences_enabled = source->read_lock_fences_enabled;
- resource->is_overlay_candidate = source->is_overlay_candidate;
-#if defined(OS_ANDROID)
- resource->is_backed_by_surface_texture = source->is_backed_by_surface_texture;
- resource->wants_promotion_hint = source->wants_promotion_hint;
-#endif
- resource->color_space = source->color_space;
-
- if (source->type == RESOURCE_TYPE_BITMAP) {
- resource->mailbox_holder.mailbox = source->shared_bitmap_id;
- resource->is_software = true;
- if (source->shared_bitmap) {
- resource->shared_bitmap_sequence_number =
- source->shared_bitmap->sequence_number();
- } else {
- resource->shared_bitmap_sequence_number = 0;
- }
- } else {
- DCHECK(source->mailbox().IsValid());
- DCHECK(source->mailbox().IsTexture());
- // This is either an external resource, or a compositor resource that we
- // already exported. Make sure to forward the sync point that we were given.
- resource->mailbox_holder.mailbox = source->mailbox().mailbox();
- resource->mailbox_holder.texture_target = source->mailbox().target();
- resource->mailbox_holder.sync_token = source->mailbox().sync_token();
- }
-}
-
void ResourceProvider::DeleteAndReturnUnusedResourcesToChild(
ChildMap::iterator child_it,
DeleteStyle style,
const ResourceIdArray& unused) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(child_it != children_.end());
Child* child_info = &child_it->second;
@@ -1868,7 +1507,7 @@
GLenum ResourceProvider::BindForSampling(viz::ResourceId resource_id,
GLenum unit,
GLenum filter) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
GLES2Interface* gl = ContextGL();
ResourceMap::iterator it = resources_.find(resource_id);
DCHECK(it != resources_.end());
@@ -2026,7 +1665,7 @@
}
void ResourceProvider::ValidateResource(viz::ResourceId id) const {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(id);
DCHECK(resources_.find(id) != resources_.end());
}
@@ -2043,7 +1682,7 @@
bool ResourceProvider::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
const uint64_t tracing_process_id =
base::trace_event::MemoryDumpManager::GetInstance()
diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
index ad5eb0b..9ef85fd 100644
--- a/cc/resources/resource_provider.h
+++ b/cc/resources/resource_provider.h
@@ -65,7 +65,7 @@
// created on (in practice, the impl thread).
class CC_EXPORT ResourceProvider
: public base::trace_event::MemoryDumpProvider {
- private:
+ protected:
struct Resource;
public:
@@ -93,6 +93,10 @@
const viz::ResourceSettings& resource_settings);
~ResourceProvider() override;
+ static bool IsGpuResourceType(ResourceProvider::ResourceType type) {
+ return type != ResourceProvider::RESOURCE_TYPE_BITMAP;
+ }
+
void Initialize();
void DidLoseVulkanContextProvider() { lost_context_provider_ = true; }
@@ -178,65 +182,6 @@
const uint8_t* image,
const gfx::Size& image_size);
- // Gets the most recent sync token from the indicated resources.
- gpu::SyncToken GetSyncTokenForResources(const ResourceIdArray& resource_ids);
-
- // Creates accounting for a child. Returns a child ID.
- int CreateChild(const ReturnCallback& return_callback);
-
- // Destroys accounting for the child, deleting all accounted resources.
- void DestroyChild(int child);
-
- // Sets whether resources need sync points set on them when returned to this
- // child. Defaults to true.
- void SetChildNeedsSyncTokens(int child, bool needs_sync_tokens);
-
- // Gets the child->parent resource ID map.
- const ResourceIdMap& GetChildToParentMap(int child) const;
-
- // Prepares resources to be transfered to the parent, moving them to
- // mailboxes and serializing meta-data into TransferableResources.
- // Resources are not removed from the ResourceProvider, but are marked as
- // "in use".
- void PrepareSendToParent(
- const ResourceIdArray& resource_ids,
- std::vector<viz::TransferableResource>* transferable_resources);
-
- // Receives resources from a child, moving them from mailboxes. Resource IDs
- // passed are in the child namespace, and will be translated to the parent
- // namespace, added to the child->parent map.
- // This adds the resources to the working set in the ResourceProvider without
- // declaring which resources are in use. Use DeclareUsedResourcesFromChild
- // after calling this method to do that. All calls to ReceiveFromChild should
- // be followed by a DeclareUsedResourcesFromChild.
- // NOTE: if the sync_token is set on any viz::TransferableResource, this will
- // wait on it.
- void ReceiveFromChild(
- int child,
- const std::vector<viz::TransferableResource>& transferable_resources);
-
- // Once a set of resources have been received, they may or may not be used.
- // This declares what set of resources are currently in use from the child,
- // releasing any other resources back to the child.
- void DeclareUsedResourcesFromChild(
- int child,
- const viz::ResourceIdSet& resources_from_child);
-
- // Receives resources from the parent, moving them from mailboxes. Resource
- // IDs passed are in the child namespace.
- // NOTE: if the sync_token is set on any viz::TransferableResource, this will
- // wait on it.
- void ReceiveReturnsFromParent(
- const std::vector<viz::ReturnedResource>& transferable_resources);
-
-#if defined(OS_ANDROID)
- // Send an overlay promotion hint to all resources that requested it via
- // |wants_promotion_hints_set_|. |promotable_hints| contains all the
- // resources that should be told that they're promotable. Others will be told
- // that they're not promotable right now.
- void SendPromotionHints(
- const OverlayCandidateList::PromotionHintInfoMap& promotion_hints);
-#endif
// The following lock classes are part of the ResourceProvider API and are
// needed to read and write the resource contents. The user must ensure
@@ -464,19 +409,6 @@
DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
};
- // All resources that are returned to children while an instance of this
- // class exists will be stored and returned when the instance is destroyed.
- class CC_EXPORT ScopedBatchReturnResources {
- public:
- explicit ScopedBatchReturnResources(ResourceProvider* resource_provider);
- ~ScopedBatchReturnResources();
-
- private:
- ResourceProvider* const resource_provider_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedBatchReturnResources);
- };
-
class CC_EXPORT Fence : public base::RefCounted<Fence> {
public:
Fence() {}
@@ -566,9 +498,7 @@
int tracing_id() const { return tracing_id_; }
- private:
- friend class ScopedBatchReturnResources;
-
+ protected:
struct Resource {
enum Origin { INTERNAL, EXTERNAL, DELEGATED };
enum SynchronizationState {
@@ -714,32 +644,11 @@
};
using ChildMap = std::unordered_map<int, Child>;
- bool ReadLockFenceHasPassed(const Resource* resource) {
- return !resource->read_lock_fence.get() ||
- resource->read_lock_fence->HasPassed();
- }
-
- viz::ResourceId CreateGpuResource(const gfx::Size& size,
- TextureHint hint,
- ResourceType type,
- viz::ResourceFormat format,
- gfx::BufferUsage usage,
- const gfx::ColorSpace& color_space);
- viz::ResourceId CreateBitmapResource(const gfx::Size& size,
- const gfx::ColorSpace& color_space);
Resource* InsertResource(viz::ResourceId id, Resource resource);
Resource* GetResource(viz::ResourceId id);
const Resource* LockForRead(viz::ResourceId id);
void UnlockForRead(viz::ResourceId id);
- Resource* LockForWrite(viz::ResourceId id);
- void UnlockForWrite(Resource* resource);
- void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
- const Resource* resource);
-
- void TransferResource(Resource* source,
- viz::ResourceId id,
- viz::TransferableResource* resource);
enum DeleteStyle {
NORMAL,
FOR_SHUTDOWN,
@@ -750,29 +659,10 @@
const ResourceIdArray& unused);
void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
- void CreateTexture(Resource* resource);
-
void CreateMailbox(Resource* resource);
- void CreateAndBindImage(Resource* resource);
-
- // Binds the given GL resource to a texture target for sampling using the
- // specified filter for both minification and magnification. Returns the
- // texture target used. The resource must be locked for reading.
- GLenum BindForSampling(viz::ResourceId resource_id,
- GLenum unit,
- GLenum filter);
-
// Returns null if we do not have a viz::ContextProvider.
gpu::gles2::GLES2Interface* ContextGL() const;
- bool IsGLContextLost() const;
-
- // Will return the invalid color space unless
- // |enable_color_correct_rasterization| is true.
- gfx::ColorSpace GetResourceColorSpaceForRaster(
- const Resource* resource) const;
-
- void SetBatchReturnResources(bool aggregate);
// Holds const settings for the ResourceProvider. Never changed after init.
struct Settings {
@@ -795,19 +685,8 @@
bool delegated_sync_points_required = false;
} const settings_;
- viz::ContextProvider* compositor_context_provider_;
- viz::SharedBitmapManager* shared_bitmap_manager_;
- gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
- BlockingTaskRunner* blocking_main_thread_task_runner_;
- bool lost_context_provider_;
- viz::ResourceId next_id_;
ResourceMap resources_;
- base::flat_map<viz::ResourceId, sk_sp<SkImage>> resource_sk_image_;
- int next_child_;
ChildMap children_;
- scoped_refptr<Fence> current_read_lock_fence_;
- std::unique_ptr<TextureIdAllocator> texture_id_allocator_;
- viz::BufferToTextureTargetMap buffer_to_texture_target_map_;
// Keep track of whether deleted resources should be batched up or returned
// immediately.
@@ -815,17 +694,68 @@
// Maps from a child id to the set of resources to be returned to it.
base::small_map<std::map<int, ResourceIdArray>> batched_returning_resources_;
- base::ThreadChecker thread_checker_;
+ viz::ContextProvider* compositor_context_provider_;
+ viz::SharedBitmapManager* shared_bitmap_manager_;
+ gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
+ BlockingTaskRunner* blocking_main_thread_task_runner_;
+ viz::ResourceId next_id_;
+ int next_child_;
- // A process-unique ID used for disambiguating memory dumps from different
- // resource providers.
- int tracing_id_;
+ THREAD_CHECKER(thread_checker_);
#if defined(OS_ANDROID)
// Set of resource Ids that would like to be notified about promotion hints.
viz::ResourceIdSet wants_promotion_hints_set_;
#endif
+ private:
+ bool ReadLockFenceHasPassed(const Resource* resource) {
+ return !resource->read_lock_fence.get() ||
+ resource->read_lock_fence->HasPassed();
+ }
+
+ viz::ResourceId CreateGpuResource(const gfx::Size& size,
+ TextureHint hint,
+ ResourceType type,
+ viz::ResourceFormat format,
+ gfx::BufferUsage usage,
+ const gfx::ColorSpace& color_space);
+ viz::ResourceId CreateBitmapResource(const gfx::Size& size,
+ const gfx::ColorSpace& color_space);
+ Resource* LockForWrite(viz::ResourceId id);
+ void UnlockForWrite(Resource* resource);
+
+ void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
+ const Resource* resource);
+
+ void CreateTexture(Resource* resource);
+
+ void CreateAndBindImage(Resource* resource);
+
+ // Binds the given GL resource to a texture target for sampling using the
+ // specified filter for both minification and magnification. Returns the
+ // texture target used. The resource must be locked for reading.
+ GLenum BindForSampling(viz::ResourceId resource_id,
+ GLenum unit,
+ GLenum filter);
+
+ bool IsGLContextLost() const;
+
+ // Will return the invalid color space unless
+ // |enable_color_correct_rasterization| is true.
+ gfx::ColorSpace GetResourceColorSpaceForRaster(
+ const Resource* resource) const;
+
+ bool lost_context_provider_;
+ base::flat_map<viz::ResourceId, sk_sp<SkImage>> resource_sk_image_;
+ scoped_refptr<Fence> current_read_lock_fence_;
+ std::unique_ptr<TextureIdAllocator> texture_id_allocator_;
+ viz::BufferToTextureTargetMap buffer_to_texture_target_map_;
+
+ // A process-unique ID used for disambiguating memory dumps from different
+ // resource providers.
+ int tracing_id_;
+
DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
};
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index 8aa9b8d..1c11796 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -2,7 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/display_resource_provider.h"
+#include "cc/resources/layer_tree_resource_provider.h"
#include <stddef.h>
#include <stdint.h>
@@ -402,7 +403,7 @@
std::deque<std::unique_ptr<PendingProduceTexture>> pending_produce_textures_;
};
-void GetResourcePixels(ResourceProvider* resource_provider,
+void GetResourcePixels(DisplayResourceProvider* resource_provider,
ResourceProviderContext* context,
viz::ResourceId id,
const gfx::Size& size,
@@ -464,12 +465,12 @@
gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager();
viz::ResourceSettings resource_settings = CreateResourceSettings();
- resource_provider_ = base::MakeUnique<ResourceProvider>(
+ resource_provider_ = base::MakeUnique<DisplayResourceProvider>(
context_provider_.get(), shared_bitmap_manager_.get(),
gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
resource_settings);
- child_resource_provider_ = base::MakeUnique<ResourceProvider>(
+ child_resource_provider_ = base::MakeUnique<LayerTreeResourceProvider>(
child_context_provider_.get(), shared_bitmap_manager_.get(),
child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
child_needs_sync_token, kEnableColorCorrectRendering,
@@ -544,14 +545,14 @@
scoped_refptr<TestContextProvider> child_context_provider_;
std::unique_ptr<BlockingTaskRunner> main_thread_task_runner_;
std::unique_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<DisplayResourceProvider> resource_provider_;
std::unique_ptr<TestGpuMemoryBufferManager> child_gpu_memory_buffer_manager_;
- std::unique_ptr<ResourceProvider> child_resource_provider_;
+ std::unique_ptr<LayerTreeResourceProvider> child_resource_provider_;
std::unique_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
};
void CheckCreateResource(ResourceProvider::ResourceType expected_default_type,
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
ResourceProviderContext* context) {
DCHECK_EQ(expected_default_type, resource_provider->default_resource_type());
@@ -1147,9 +1148,10 @@
resource_provider_->DeclareUsedResourcesFromChild(child_id,
viz::ResourceIdSet());
- std::unique_ptr<ResourceProvider::ScopedBatchReturnResources> returner =
- base::MakeUnique<ResourceProvider::ScopedBatchReturnResources>(
- resource_provider_.get());
+ std::unique_ptr<DisplayResourceProvider::ScopedBatchReturnResources>
+ returner =
+ base::MakeUnique<DisplayResourceProvider::ScopedBatchReturnResources>(
+ resource_provider_.get());
EXPECT_EQ(0u, returned_to_child.size());
read_locks.clear();
@@ -1617,8 +1619,8 @@
ResourceProviderContext::Create(shared_data_.get()));
child_context_provider->BindToCurrentThread();
- std::unique_ptr<ResourceProvider> child_resource_provider(
- base::MakeUnique<ResourceProvider>(
+ std::unique_ptr<LayerTreeResourceProvider> child_resource_provider(
+ base::MakeUnique<LayerTreeResourceProvider>(
child_context_provider.get(), shared_bitmap_manager_.get(),
gpu_memory_buffer_manager_.get(), nullptr,
kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -1898,8 +1900,8 @@
auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();
viz::ResourceSettings resource_settings = CreateResourceSettings();
- std::unique_ptr<ResourceProvider> child_resource_provider(
- base::MakeUnique<ResourceProvider>(
+ std::unique_ptr<LayerTreeResourceProvider> child_resource_provider(
+ base::MakeUnique<LayerTreeResourceProvider>(
child_context_provider.get(), shared_bitmap_manager.get(), nullptr,
nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
resource_settings));
@@ -1912,8 +1914,8 @@
TestContextProvider::Create(std::move(parent_context_owned));
parent_context_provider->BindToCurrentThread();
- std::unique_ptr<ResourceProvider> parent_resource_provider(
- base::MakeUnique<ResourceProvider>(
+ std::unique_ptr<DisplayResourceProvider> parent_resource_provider(
+ base::MakeUnique<DisplayResourceProvider>(
parent_context_provider.get(), shared_bitmap_manager.get(), nullptr,
nullptr, kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
resource_settings));
@@ -2988,8 +2990,8 @@
auto context_provider = TestContextProvider::Create(std::move(context_owned));
context_provider->BindToCurrentThread();
- std::unique_ptr<ResourceProvider> resource_provider(
- base::MakeUnique<ResourceProvider>(
+ std::unique_ptr<LayerTreeResourceProvider> resource_provider(
+ base::MakeUnique<LayerTreeResourceProvider>(
context_provider.get(), shared_bitmap_manager_.get(),
gpu_memory_buffer_manager_.get(), nullptr,
kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
@@ -3478,12 +3480,13 @@
ResourceProvider::ResourceIdArray array;
for (uint32_t i = 0; i < arraysize(release_counts); ++i) {
- viz::ResourceId id = resource_provider_->CreateResource(
+ viz::ResourceId id = child_resource_provider_->CreateResource(
size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
gfx::ColorSpace());
array.push_back(id);
- ResourceProvider::ScopedWriteLockGL lock(resource_provider_.get(), id);
+ ResourceProvider::ScopedWriteLockGL lock(child_resource_provider_.get(),
+ id);
gpu::SyncToken token;
token.Set(gpu::CommandBufferNamespace::INVALID, 0, gpu::CommandBufferId(),
release_counts[i]);
@@ -3491,7 +3494,7 @@
}
gpu::SyncToken last_token =
- resource_provider_->GetSyncTokenForResources(array);
+ child_resource_provider_->GetSyncTokenForResources(array);
EXPECT_EQ(last_token.release_count(), 10u);
}
diff --git a/cc/test/fake_resource_provider.h b/cc/test/fake_resource_provider.h
index 20295b5..e5ecb355 100644
--- a/cc/test/fake_resource_provider.h
+++ b/cc/test/fake_resource_provider.h
@@ -28,6 +28,19 @@
resource_settings));
}
+ template <typename T>
+ static std::unique_ptr<T> Create(
+ viz::ContextProvider* context_provider,
+ viz::SharedBitmapManager* shared_bitmap_manager) {
+ viz::ResourceSettings resource_settings;
+ resource_settings.texture_id_allocation_chunk_size = 1;
+ resource_settings.buffer_to_texture_target_map =
+ viz::DefaultBufferToTextureTargetMapForTesting();
+ return base::WrapUnique(new T(context_provider, shared_bitmap_manager,
+ nullptr, nullptr, true, false,
+ resource_settings));
+ }
+
static std::unique_ptr<FakeResourceProvider> Create(
viz::ContextProvider* context_provider,
viz::SharedBitmapManager* shared_bitmap_manager,
@@ -41,6 +54,20 @@
nullptr, true, false, resource_settings));
}
+ template <typename T>
+ static std::unique_ptr<T> Create(
+ viz::ContextProvider* context_provider,
+ viz::SharedBitmapManager* shared_bitmap_manager,
+ gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
+ viz::ResourceSettings resource_settings;
+ resource_settings.texture_id_allocation_chunk_size = 1;
+ resource_settings.buffer_to_texture_target_map =
+ viz::DefaultBufferToTextureTargetMapForTesting();
+ return base::WrapUnique(new T(context_provider, shared_bitmap_manager,
+ gpu_memory_buffer_manager, nullptr, true,
+ false, resource_settings));
+ }
+
private:
FakeResourceProvider(viz::ContextProvider* context_provider,
viz::SharedBitmapManager* shared_bitmap_manager,
diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index f8d935f..36913ce 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc
@@ -132,7 +132,7 @@
host_impl->layer_tree_frame_sink()->context_provider();
viz::ContextProvider* worker_context_provider =
host_impl->layer_tree_frame_sink()->worker_context_provider();
- ResourceProvider* resource_provider = host_impl->resource_provider();
+ LayerTreeResourceProvider* resource_provider = host_impl->resource_provider();
int max_bytes_per_copy_operation = 1024 * 1024;
int max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024;
diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc
index 57e07907..f8fbd67 100644
--- a/cc/test/pixel_test.cc
+++ b/cc/test/pixel_test.cc
@@ -166,7 +166,7 @@
gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
// Not relevant for display compositor since it's not delegated.
constexpr bool delegated_sync_points_required = false;
- resource_provider_ = base::MakeUnique<ResourceProvider>(
+ resource_provider_ = base::MakeUnique<DisplayResourceProvider>(
output_surface_->context_provider(), shared_bitmap_manager_.get(),
gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
delegated_sync_points_required,
@@ -195,7 +195,7 @@
shared_bitmap_manager_.reset(new TestSharedBitmapManager());
constexpr bool delegated_sync_points_required =
false; // Meaningless for software.
- resource_provider_ = base::MakeUnique<ResourceProvider>(
+ resource_provider_ = base::MakeUnique<DisplayResourceProvider>(
nullptr, shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(),
main_thread_task_runner_.get(), delegated_sync_points_required,
settings_.enable_color_correct_rasterization,
diff --git a/cc/test/pixel_test.h b/cc/test/pixel_test.h
index cea334d..e5bb448 100644
--- a/cc/test/pixel_test.h
+++ b/cc/test/pixel_test.h
@@ -20,10 +20,10 @@
}
namespace cc {
+class DisplayResourceProvider;
class DirectRenderer;
class FakeOutputSurfaceClient;
class OutputSurface;
-class ResourceProvider;
class SoftwareRenderer;
class TestGpuMemoryBufferManager;
class TestSharedBitmapManager;
@@ -66,7 +66,7 @@
std::unique_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
std::unique_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
std::unique_ptr<BlockingTaskRunner> main_thread_task_runner_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<DisplayResourceProvider> resource_provider_;
std::unique_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
std::unique_ptr<DirectRenderer> renderer_;
SoftwareRenderer* software_renderer_ = nullptr;
@@ -104,7 +104,7 @@
public:
GLRendererWithExpandedViewport(const viz::RendererSettings* settings,
OutputSurface* output_surface,
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
TextureMailboxDeleter* texture_mailbox_deleter)
: viz::GLRenderer(settings,
output_surface,
@@ -114,9 +114,10 @@
class SoftwareRendererWithExpandedViewport : public SoftwareRenderer {
public:
- SoftwareRendererWithExpandedViewport(const viz::RendererSettings* settings,
- OutputSurface* output_surface,
- ResourceProvider* resource_provider)
+ SoftwareRendererWithExpandedViewport(
+ const viz::RendererSettings* settings,
+ OutputSurface* output_surface,
+ DisplayResourceProvider* resource_provider)
: SoftwareRenderer(settings, output_surface, resource_provider) {}
};
@@ -124,7 +125,7 @@
public:
GLRendererWithFlippedSurface(const viz::RendererSettings* settings,
OutputSurface* output_surface,
- ResourceProvider* resource_provider,
+ DisplayResourceProvider* resource_provider,
TextureMailboxDeleter* texture_mailbox_deleter)
: viz::GLRenderer(settings,
output_surface,
diff --git a/cc/tiles/picture_layer_tiling_set_unittest.cc b/cc/tiles/picture_layer_tiling_set_unittest.cc
index 69013f23..eb4ccda 100644
--- a/cc/tiles/picture_layer_tiling_set_unittest.cc
+++ b/cc/tiles/picture_layer_tiling_set_unittest.cc
@@ -8,6 +8,7 @@
#include <vector>
#include "base/memory/ptr_util.h"
+#include "cc/resources/layer_tree_resource_provider.h"
#include "cc/resources/resource_provider.h"
#include "cc/test/fake_output_surface.h"
#include "cc/test/fake_output_surface_client.h"
@@ -249,8 +250,8 @@
ASSERT_TRUE(context_provider->BindToCurrentThread());
auto shared_bitmap_manager = base::MakeUnique<TestSharedBitmapManager>();
std::unique_ptr<ResourceProvider> resource_provider =
- FakeResourceProvider::Create(context_provider.get(),
- shared_bitmap_manager.get());
+ FakeResourceProvider::Create<LayerTreeResourceProvider>(
+ context_provider.get(), shared_bitmap_manager.get());
FakePictureLayerTilingClient client(resource_provider.get());
client.SetTileSize(gfx::Size(256, 256));
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 395469ab..b6b4f3c 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -2557,7 +2557,7 @@
layer_tree_frame_sink_ = layer_tree_frame_sink;
has_valid_layer_tree_frame_sink_ = true;
- resource_provider_ = base::MakeUnique<ResourceProvider>(
+ resource_provider_ = base::MakeUnique<LayerTreeResourceProvider>(
layer_tree_frame_sink_->context_provider(),
layer_tree_frame_sink_->shared_bitmap_manager(),
layer_tree_frame_sink_->gpu_memory_buffer_manager(),
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 9ddbc4e..4576d1c 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -28,7 +28,7 @@
#include "cc/output/layer_tree_frame_sink_client.h"
#include "cc/output/managed_memory_policy.h"
#include "cc/quads/render_pass.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/layer_tree_resource_provider.h"
#include "cc/resources/ui_resource_client.h"
#include "cc/scheduler/begin_frame_tracker.h"
#include "cc/scheduler/commit_earlyout_reason.h"
@@ -474,7 +474,9 @@
FrameRateCounter* fps_counter() { return fps_counter_.get(); }
MemoryHistory* memory_history() { return memory_history_.get(); }
DebugRectHistory* debug_rect_history() { return debug_rect_history_.get(); }
- ResourceProvider* resource_provider() { return resource_provider_.get(); }
+ LayerTreeResourceProvider* resource_provider() {
+ return resource_provider_.get();
+ }
BrowserControlsOffsetManager* browser_controls_manager() {
return browser_controls_offset_manager_.get();
}
@@ -752,7 +754,7 @@
std::unique_ptr<viz::ContextCacheController::ScopedVisibility>
worker_context_visibility_;
- std::unique_ptr<ResourceProvider> resource_provider_;
+ std::unique_ptr<LayerTreeResourceProvider> resource_provider_;
bool need_update_gpu_rasterization_status_;
bool content_has_slow_paths_;
bool content_has_non_aa_paint_;
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index c451b02..c9c5315e 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -882,8 +882,9 @@
child_context_provider_ = TestContextProvider::Create();
CHECK(child_context_provider_->BindToCurrentThread());
shared_bitmap_manager_.reset(new TestSharedBitmapManager);
- child_resource_provider_ = FakeResourceProvider::Create(
- child_context_provider_.get(), shared_bitmap_manager_.get());
+ child_resource_provider_ =
+ FakeResourceProvider::Create<LayerTreeResourceProvider>(
+ child_context_provider_.get(), shared_bitmap_manager_.get());
}
static void EmptyReleaseCallback(const gpu::SyncToken& sync_token,
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 7be2f01..6caf0b6 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -1296,7 +1296,7 @@
return layer_tree_host_impl_->layer_tree_frame_sink()->context_provider();
}
-ResourceProvider* LayerTreeImpl::resource_provider() const {
+LayerTreeResourceProvider* LayerTreeImpl::resource_provider() const {
return layer_tree_host_impl_->resource_provider();
}
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 8904025e..144e516 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -43,11 +43,11 @@
class ImageDecodeCache;
class LayerTreeDebugState;
class LayerTreeImpl;
+class LayerTreeResourceProvider;
class LayerTreeSettings;
class MemoryHistory;
class PictureLayerImpl;
class TaskRunnerProvider;
-class ResourceProvider;
class TileManager;
class UIResourceRequest;
class VideoFrameControllerClient;
@@ -107,7 +107,7 @@
const LayerTreeSettings& settings() const;
const LayerTreeDebugState& debug_state() const;
viz::ContextProvider* context_provider() const;
- ResourceProvider* resource_provider() const;
+ LayerTreeResourceProvider* resource_provider() const;
TileManager* tile_manager() const;
ImageDecodeCache* image_decode_cache() const;
FrameRateCounter* frame_rate_counter() const;
diff --git a/components/viz/service/display/display.cc b/components/viz/service/display/display.cc
index 0f70ad2c..0454cf5 100644
--- a/components/viz/service/display/display.cc
+++ b/components/viz/service/display/display.cc
@@ -182,7 +182,7 @@
void Display::InitializeRenderer() {
// Not relevant for display compositor since it's not delegated.
constexpr bool delegated_sync_points_required = false;
- resource_provider_ = base::MakeUnique<cc::ResourceProvider>(
+ resource_provider_ = base::MakeUnique<cc::DisplayResourceProvider>(
output_surface_->context_provider(), bitmap_manager_,
gpu_memory_buffer_manager_, nullptr, delegated_sync_points_required,
settings_.enable_color_correct_rendering, settings_.resource_settings);
diff --git a/components/viz/service/display/display.h b/components/viz/service/display/display.h
index 8718e72..553995a 100644
--- a/components/viz/service/display/display.h
+++ b/components/viz/service/display/display.h
@@ -11,6 +11,7 @@
#include "base/macros.h"
#include "base/observer_list.h"
#include "cc/output/output_surface_client.h"
+#include "cc/resources/display_resource_provider.h"
#include "components/viz/common/frame_sinks/begin_frame_source.h"
#include "components/viz/common/resources/returned_resource.h"
#include "components/viz/common/surfaces/frame_sink_id.h"
@@ -25,9 +26,9 @@
namespace cc {
class DirectRenderer;
+class DisplayResourceProvider;
class OutputSurface;
class RendererSettings;
-class ResourceProvider;
class SoftwareRenderer;
class TextureMailboxDeleter;
} // namespace cc
@@ -132,7 +133,7 @@
std::unique_ptr<cc::OutputSurface> output_surface_;
std::unique_ptr<DisplayScheduler> scheduler_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<SurfaceAggregator> aggregator_;
std::unique_ptr<cc::TextureMailboxDeleter> texture_mailbox_deleter_;
std::unique_ptr<cc::DirectRenderer> renderer_;
diff --git a/components/viz/service/display/gl_renderer.cc b/components/viz/service/display/gl_renderer.cc
index 99e5df7a..490f0aa 100644
--- a/components/viz/service/display/gl_renderer.cc
+++ b/components/viz/service/display/gl_renderer.cc
@@ -394,7 +394,7 @@
GLRenderer::GLRenderer(const RendererSettings* settings,
cc::OutputSurface* output_surface,
- cc::ResourceProvider* resource_provider,
+ cc::DisplayResourceProvider* resource_provider,
cc::TextureMailboxDeleter* texture_mailbox_deleter)
: cc::DirectRenderer(settings, output_surface, resource_provider),
shared_geometry_quad_(QuadVertexRect()),
@@ -2775,7 +2775,7 @@
gl_->ScheduleCALayerInUseQueryCHROMIUM(textures.size(), textures.data());
}
} else if (swapping_overlay_resources_.size() > 1) {
- cc::ResourceProvider::ScopedBatchReturnResources returner(
+ cc::DisplayResourceProvider::ScopedBatchReturnResources returner(
resource_provider_);
// If a query is not needed to release the overlay buffers, we can assume
@@ -2788,7 +2788,8 @@
void GLRenderer::DidReceiveTextureInUseResponses(
const gpu::TextureInUseResponses& responses) {
DCHECK(settings_->release_overlay_resources_after_gpu_query);
- cc::ResourceProvider::ScopedBatchReturnResources returner(resource_provider_);
+ cc::DisplayResourceProvider::ScopedBatchReturnResources returner(
+ resource_provider_);
for (const gpu::TextureInUseResponse& response : responses) {
if (!response.in_use) {
swapped_and_acked_overlay_resources_.erase(response.texture);
diff --git a/components/viz/service/display/gl_renderer.h b/components/viz/service/display/gl_renderer.h
index 2c6b31d..1c7da26 100644
--- a/components/viz/service/display/gl_renderer.h
+++ b/components/viz/service/display/gl_renderer.h
@@ -55,7 +55,7 @@
GLRenderer(const RendererSettings* settings,
cc::OutputSurface* output_surface,
- cc::ResourceProvider* resource_provider,
+ cc::DisplayResourceProvider* resource_provider,
cc::TextureMailboxDeleter* texture_mailbox_deleter);
~GLRenderer() override;
diff --git a/components/viz/service/display/gl_renderer_unittest.cc b/components/viz/service/display/gl_renderer_unittest.cc
index a92800a..8fba6a7 100644
--- a/components/viz/service/display/gl_renderer_unittest.cc
+++ b/components/viz/service/display/gl_renderer_unittest.cc
@@ -369,12 +369,12 @@
public:
FakeRendererGL(const RendererSettings* settings,
cc::OutputSurface* output_surface,
- cc::ResourceProvider* resource_provider)
+ cc::DisplayResourceProvider* resource_provider)
: GLRenderer(settings, output_surface, resource_provider, nullptr) {}
FakeRendererGL(const RendererSettings* settings,
cc::OutputSurface* output_surface,
- cc::ResourceProvider* resource_provider,
+ cc::DisplayResourceProvider* resource_provider,
cc::TextureMailboxDeleter* texture_mailbox_deleter)
: GLRenderer(settings,
output_surface,
@@ -401,8 +401,9 @@
output_surface_->BindToClient(&output_surface_client_);
shared_bitmap_manager_.reset(new cc::TestSharedBitmapManager());
- resource_provider_ = cc::FakeResourceProvider::Create(
- output_surface_->context_provider(), shared_bitmap_manager_.get());
+ resource_provider_ =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface_->context_provider(), shared_bitmap_manager_.get());
renderer_ = base::MakeUnique<FakeRendererGL>(
&settings_, output_surface_.get(), resource_provider_.get());
renderer_->Initialize();
@@ -415,7 +416,7 @@
cc::FakeOutputSurfaceClient output_surface_client_;
std::unique_ptr<cc::FakeOutputSurface> output_surface_;
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<FakeRendererGL> renderer_;
};
@@ -431,8 +432,9 @@
output_surface_->BindToClient(&output_surface_client_);
shared_bitmap_manager_.reset(new cc::TestSharedBitmapManager());
- resource_provider_ = cc::FakeResourceProvider::Create(
- output_surface_->context_provider(), shared_bitmap_manager_.get());
+ resource_provider_ =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface_->context_provider(), shared_bitmap_manager_.get());
renderer_.reset(new FakeRendererGL(&settings_, output_surface_.get(),
resource_provider_.get()));
renderer_->Initialize();
@@ -526,7 +528,7 @@
cc::FakeOutputSurfaceClient output_surface_client_;
std::unique_ptr<cc::FakeOutputSurface> output_surface_;
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<FakeRendererGL> renderer_;
};
@@ -656,9 +658,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -692,9 +694,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -726,9 +728,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -770,9 +772,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -807,9 +809,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -866,9 +868,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -949,9 +951,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
settings.should_clear_root_render_pass = false;
@@ -1039,9 +1041,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -1114,9 +1116,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
settings.partial_swap_enabled = true;
@@ -1314,9 +1316,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
{
RendererSettings settings;
@@ -1364,8 +1366,9 @@
output_surface_->BindToClient(&output_surface_client_);
shared_bitmap_manager_.reset(new cc::TestSharedBitmapManager());
- resource_provider_ = cc::FakeResourceProvider::Create(
- output_surface_->context_provider(), shared_bitmap_manager_.get());
+ resource_provider_ =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface_->context_provider(), shared_bitmap_manager_.get());
settings_.partial_swap_enabled = true;
renderer_ = base::MakeUnique<FakeRendererGL>(
&settings_, output_surface_.get(), resource_provider_.get());
@@ -1378,7 +1381,7 @@
cc::FakeOutputSurfaceClient output_surface_client_;
std::unique_ptr<cc::FakeOutputSurface> output_surface_;
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<FakeRendererGL> renderer_;
};
@@ -1451,9 +1454,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
@@ -1496,7 +1499,7 @@
cc::RenderPass* root_pass;
ResourceId mask = resource_provider_->CreateResource(
- gfx::Size(20, 12), cc::ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+ gfx::Size(20, 12), cc::DisplayResourceProvider::TEXTURE_HINT_IMMUTABLE,
resource_provider_->best_texture_format(), gfx::ColorSpace());
resource_provider_->AllocateForTesting(mask);
@@ -1803,8 +1806,9 @@
output_surface_->BindToClient(&output_surface_client_);
shared_bitmap_manager_.reset(new cc::TestSharedBitmapManager());
- resource_provider_ = cc::FakeResourceProvider::Create(
- output_surface_->context_provider(), shared_bitmap_manager_.get());
+ resource_provider_ =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface_->context_provider(), shared_bitmap_manager_.get());
renderer_.reset(new FakeRendererGL(&settings_, output_surface_.get(),
resource_provider_.get()));
@@ -1849,7 +1853,7 @@
OutputSurfaceMockContext* context_ = nullptr;
std::unique_ptr<StrictMock<MockOutputSurface>> output_surface_;
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<FakeRendererGL> renderer_;
};
@@ -1872,7 +1876,7 @@
Strategy() {}
~Strategy() override {}
MOCK_METHOD4(Attempt,
- bool(cc::ResourceProvider* resource_provider,
+ bool(cc::DisplayResourceProvider* resource_provider,
cc::RenderPass* render_pass,
cc::OverlayCandidateList* candidates,
std::vector<gfx::Rect>* content_bounds));
@@ -1921,9 +1925,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
std::unique_ptr<cc::TextureMailboxDeleter> mailbox_deleter(
new cc::TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
@@ -2088,9 +2092,9 @@
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
new cc::TestSharedBitmapManager());
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- shared_bitmap_manager.get());
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), shared_bitmap_manager.get());
std::unique_ptr<cc::TextureMailboxDeleter> mailbox_deleter(
new cc::TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
@@ -2186,9 +2190,9 @@
cc::FakeOutputSurface::Create3d(std::move(provider)));
output_surface->BindToClient(&output_surface_client);
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- nullptr);
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), nullptr);
RendererSettings settings;
settings.partial_swap_enabled = partial_swap;
@@ -2296,9 +2300,9 @@
cc::FakeOutputSurface::Create3d(std::move(provider)));
output_surface->BindToClient(&output_surface_client);
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- nullptr);
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), nullptr);
RendererSettings settings;
settings.partial_swap_enabled = true;
@@ -2390,8 +2394,9 @@
output_surface_ =
cc::FakeOutputSurface::Create3d(std::move(context_provider));
output_surface_->BindToClient(&output_surface_client_);
- resource_provider_ = cc::FakeResourceProvider::Create(
- output_surface_->context_provider(), nullptr);
+ resource_provider_ =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface_->context_provider(), nullptr);
renderer_ = base::MakeUnique<GLRenderer>(&settings_, output_surface_.get(),
resource_provider_.get(), nullptr);
renderer_->Initialize();
@@ -2401,7 +2406,7 @@
cc::FakeOutputSurfaceClient output_surface_client_;
MockContextSupport* context_support_ptr_;
std::unique_ptr<cc::OutputSurface> output_surface_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<GLRenderer> renderer_;
};
@@ -2430,7 +2435,7 @@
explicit Strategy(const std::vector<gfx::Rect>& content_bounds)
: content_bounds_(content_bounds) {}
~Strategy() override {}
- bool Attempt(cc::ResourceProvider* resource_provider,
+ bool Attempt(cc::DisplayResourceProvider* resource_provider,
cc::RenderPass* render_pass,
cc::OverlayCandidateList* candidates,
std::vector<gfx::Rect>* content_bounds) override {
@@ -2468,9 +2473,9 @@
cc::FakeOutputSurface::Create3d(std::move(provider)));
output_surface->BindToClient(&output_surface_client);
- std::unique_ptr<cc::ResourceProvider> resource_provider =
- cc::FakeResourceProvider::Create(output_surface->context_provider(),
- nullptr);
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ output_surface->context_provider(), nullptr);
RendererSettings settings;
FakeRendererGL renderer(&settings, output_surface.get(),
diff --git a/components/viz/service/display/skia_renderer.cc b/components/viz/service/display/skia_renderer.cc
index b1fb7fd..7687988 100644
--- a/components/viz/service/display/skia_renderer.cc
+++ b/components/viz/service/display/skia_renderer.cc
@@ -56,7 +56,7 @@
SkiaRenderer::SkiaRenderer(const RendererSettings* settings,
cc::OutputSurface* output_surface,
- cc::ResourceProvider* resource_provider)
+ cc::DisplayResourceProvider* resource_provider)
: DirectRenderer(settings, output_surface, resource_provider) {
const auto& context_caps =
output_surface_->context_provider()->ContextCapabilities();
diff --git a/components/viz/service/display/skia_renderer.h b/components/viz/service/display/skia_renderer.h
index 86cb168..75decd4 100644
--- a/components/viz/service/display/skia_renderer.h
+++ b/components/viz/service/display/skia_renderer.h
@@ -27,7 +27,7 @@
public:
SkiaRenderer(const RendererSettings* settings,
cc::OutputSurface* output_surface,
- cc::ResourceProvider* resource_provider);
+ cc::DisplayResourceProvider* resource_provider);
~SkiaRenderer() override;
diff --git a/components/viz/service/display/surface_aggregator.cc b/components/viz/service/display/surface_aggregator.cc
index 870a660..96fc5501 100644
--- a/components/viz/service/display/surface_aggregator.cc
+++ b/components/viz/service/display/surface_aggregator.cc
@@ -24,7 +24,7 @@
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/surface_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/display_resource_provider.h"
#include "components/viz/service/frame_sinks/compositor_frame_sink_support.h"
#include "components/viz/service/surfaces/surface.h"
#include "components/viz/service/surfaces/surface_client.h"
@@ -77,7 +77,7 @@
} // namespace
SurfaceAggregator::SurfaceAggregator(SurfaceManager* manager,
- cc::ResourceProvider* provider,
+ cc::DisplayResourceProvider* provider,
bool aggregate_only_damaged)
: manager_(manager),
provider_(provider),
diff --git a/components/viz/service/display/surface_aggregator.h b/components/viz/service/display/surface_aggregator.h
index c084ffa..6c4c843 100644
--- a/components/viz/service/display/surface_aggregator.h
+++ b/components/viz/service/display/surface_aggregator.h
@@ -22,7 +22,7 @@
namespace cc {
class BlockingTaskRunner;
class CompositorFrame;
-class ResourceProvider;
+class DisplayResourceProvider;
class SurfaceDrawQuad;
} // namespace cc
@@ -37,7 +37,7 @@
using SurfaceIndexMap = base::flat_map<SurfaceId, uint64_t>;
SurfaceAggregator(SurfaceManager* manager,
- cc::ResourceProvider* provider,
+ cc::DisplayResourceProvider* provider,
bool aggregate_only_damaged);
~SurfaceAggregator();
@@ -149,7 +149,7 @@
cc::BlockingTaskRunner* main_thread_task_runner);
SurfaceManager* manager_;
- cc::ResourceProvider* provider_;
+ cc::DisplayResourceProvider* provider_;
// Every Surface has its own cc::RenderPass ID namespace. This structure maps
// each source (SurfaceId, cc::RenderPass id) to a unified ID namespace that's
diff --git a/components/viz/service/display/surface_aggregator_perftest.cc b/components/viz/service/display/surface_aggregator_perftest.cc
index c4cc3846..bdf985c2 100644
--- a/components/viz/service/display/surface_aggregator_perftest.cc
+++ b/components/viz/service/display/surface_aggregator_perftest.cc
@@ -7,6 +7,7 @@
#include "cc/output/compositor_frame.h"
#include "cc/quads/surface_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
+#include "cc/resources/display_resource_provider.h"
#include "cc/test/fake_output_surface_client.h"
#include "cc/test/fake_resource_provider.h"
#include "cc/test/test_context_provider.h"
@@ -35,8 +36,9 @@
context_provider_->BindToCurrentThread();
shared_bitmap_manager_ = base::MakeUnique<cc::TestSharedBitmapManager>();
- resource_provider_ = cc::FakeResourceProvider::Create(
- context_provider_.get(), shared_bitmap_manager_.get());
+ resource_provider_ =
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ context_provider_.get(), shared_bitmap_manager_.get());
}
void RunTest(int num_surfaces,
@@ -149,7 +151,7 @@
FrameSinkManagerImpl manager_;
scoped_refptr<cc::TestContextProvider> context_provider_;
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<SurfaceAggregator> aggregator_;
cc::LapTimer timer_;
};
diff --git a/components/viz/service/display/surface_aggregator_unittest.cc b/components/viz/service/display/surface_aggregator_unittest.cc
index da4d070..0169cd1 100644
--- a/components/viz/service/display/surface_aggregator_unittest.cc
+++ b/components/viz/service/display/surface_aggregator_unittest.cc
@@ -19,6 +19,7 @@
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/surface_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
+#include "cc/resources/display_resource_provider.h"
#include "cc/test/fake_compositor_frame_sink_support_client.h"
#include "cc/test/fake_resource_provider.h"
#include "cc/test/render_pass_test_utils.h"
@@ -2129,7 +2130,8 @@
void SetUp() override {
shared_bitmap_manager_ = base::MakeUnique<cc::TestSharedBitmapManager>();
resource_provider_ =
- cc::FakeResourceProvider::Create(nullptr, shared_bitmap_manager_.get());
+ cc::FakeResourceProvider::Create<cc::DisplayResourceProvider>(
+ nullptr, shared_bitmap_manager_.get());
aggregator_ = base::MakeUnique<SurfaceAggregator>(
manager_.surface_manager(), resource_provider_.get(), false);
@@ -2139,7 +2141,7 @@
protected:
FrameSinkManagerImpl manager_;
std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
- std::unique_ptr<cc::ResourceProvider> resource_provider_;
+ std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;
std::unique_ptr<SurfaceAggregator> aggregator_;
};