cc: Move UI Resource management out of LayerTreeHost.
Moves out the UIResource request tracking into its own class composed
into the LayerTreeHost. The code is pretty isolated and doesn't need
to live in the host.
BUG=625283
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_precise_blink_rel
Review-Url: https://codereview.chromium.org/2322943003
Cr-Commit-Position: refs/heads/master@{#417812}
diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 3562e55..c8acb81 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -421,6 +421,8 @@
"resources/ui_resource_bitmap.cc",
"resources/ui_resource_bitmap.h",
"resources/ui_resource_client.h",
+ "resources/ui_resource_manager.cc",
+ "resources/ui_resource_manager.h",
"resources/ui_resource_request.cc",
"resources/ui_resource_request.h",
"resources/video_resource_updater.cc",
diff --git a/cc/layers/nine_patch_layer_unittest.cc b/cc/layers/nine_patch_layer_unittest.cc
index abc431b7..459810da 100644
--- a/cc/layers/nine_patch_layer_unittest.cc
+++ b/cc/layers/nine_patch_layer_unittest.cc
@@ -59,8 +59,9 @@
EXPECT_FALSE(test_layer->DrawsContent());
bool is_opaque = false;
- std::unique_ptr<ScopedUIResource> resource = ScopedUIResource::Create(
- layer_tree_host_.get(), UIResourceBitmap(gfx::Size(10, 10), is_opaque));
+ std::unique_ptr<ScopedUIResource> resource =
+ ScopedUIResource::Create(layer_tree_host_->GetUIResourceManager(),
+ UIResourceBitmap(gfx::Size(10, 10), is_opaque));
gfx::Rect aperture(5, 5, 1, 1);
bool fill_center = true;
test_layer->SetAperture(aperture);
diff --git a/cc/layers/painted_scrollbar_layer.cc b/cc/layers/painted_scrollbar_layer.cc
index 0743e3ea..3c56ffc 100644
--- a/cc/layers/painted_scrollbar_layer.cc
+++ b/cc/layers/painted_scrollbar_layer.cc
@@ -170,7 +170,7 @@
void PaintedScrollbarLayer::UpdateInternalContentScale() {
float scale = GetLayerTree()->device_scale_factor();
- if (layer_tree_host()
+ if (GetLayerTree()
->GetSettings()
.layer_transforms_should_scale_layer_contents) {
gfx::Transform transform;
@@ -229,7 +229,7 @@
if (!track_resource_ || scrollbar_->NeedsPaintPart(TRACK)) {
track_resource_ = ScopedUIResource::Create(
- layer_tree_host(),
+ GetLayerTree()->GetUIResourceManager(),
RasterizeScrollbarPart(track_layer_rect, scaled_track_rect, TRACK));
}
@@ -241,7 +241,7 @@
scaled_thumb_rect.size() !=
thumb_resource_->GetBitmap(0, false).GetSize()) {
thumb_resource_ = ScopedUIResource::Create(
- layer_tree_host(),
+ GetLayerTree()->GetUIResourceManager(),
RasterizeScrollbarPart(thumb_layer_rect, scaled_thumb_rect, THUMB));
}
thumb_opacity_ = scrollbar_->ThumbOpacity();
diff --git a/cc/layers/painted_scrollbar_layer_impl_unittest.cc b/cc/layers/painted_scrollbar_layer_impl_unittest.cc
index 4bc3f06..4e76ec1 100644
--- a/cc/layers/painted_scrollbar_layer_impl_unittest.cc
+++ b/cc/layers/painted_scrollbar_layer_impl_unittest.cc
@@ -8,6 +8,7 @@
#include "cc/quads/draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
+#include "cc/resources/ui_resource_bitmap.h"
#include "cc/test/layer_test_common.h"
#include "testing/gtest/include/gtest/gtest.h"
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index 54ff422..c174acd 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -16,6 +16,7 @@
#include "cc/layers/solid_color_scrollbar_layer.h"
#include "cc/layers/solid_color_scrollbar_layer_impl.h"
#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/test/fake_impl_task_runner_provider.h"
#include "cc/test/fake_layer_tree_host.h"
#include "cc/test/fake_layer_tree_host_client.h"
@@ -42,17 +43,13 @@
namespace cc {
namespace {
-class FakeResourceTrackingLayerTreeHost : public FakeLayerTreeHost {
+class FakeResourceTrackingUIResourceManager : public UIResourceManager {
public:
- FakeResourceTrackingLayerTreeHost(FakeLayerTreeHostClient* client,
- LayerTreeHost::InitParams* params)
- : FakeLayerTreeHost(client, params, CompositorMode::SINGLE_THREADED),
- next_id_(1),
+ FakeResourceTrackingUIResourceManager()
+ : next_id_(1),
total_ui_resource_created_(0),
- total_ui_resource_deleted_(0) {
- InitializeSingleThreaded(&single_thread_client_,
- base::ThreadTaskRunnerHandle::Get(), nullptr);
- }
+ total_ui_resource_deleted_(0) {}
+ ~FakeResourceTrackingUIResourceManager() override = default;
UIResourceId CreateUIResource(UIResourceClient* content) override {
total_ui_resource_created_++;
@@ -120,8 +117,17 @@
params.animation_host =
AnimationHost::CreateForTesting(ThreadInstance::MAIN);
- layer_tree_host_.reset(
- new FakeResourceTrackingLayerTreeHost(&fake_client_, ¶ms));
+ std::unique_ptr<FakeResourceTrackingUIResourceManager>
+ fake_ui_resource_manager =
+ base::MakeUnique<FakeResourceTrackingUIResourceManager>();
+ fake_ui_resource_manager_ = fake_ui_resource_manager.get();
+
+ layer_tree_host_.reset(new FakeLayerTreeHost(
+ &fake_client_, ¶ms, CompositorMode::SINGLE_THREADED));
+ layer_tree_host_->SetUIResourceManagerForTesting(
+ std::move(fake_ui_resource_manager));
+ layer_tree_host_->InitializeSingleThreaded(
+ &single_thread_client_, base::ThreadTaskRunnerHandle::Get(), nullptr);
layer_tree_ = layer_tree_host_->GetLayerTree();
layer_tree_host_->SetVisible(true);
fake_client_.SetLayerTreeHost(layer_tree_host_.get());
@@ -155,10 +161,12 @@
}
protected:
+ FakeResourceTrackingUIResourceManager* fake_ui_resource_manager_;
FakeLayerTreeHostClient fake_client_;
+ StubLayerTreeHostSingleThreadClient single_thread_client_;
TestTaskGraphRunner task_graph_runner_;
LayerTreeSettings layer_tree_settings_;
- std::unique_ptr<FakeResourceTrackingLayerTreeHost> layer_tree_host_;
+ std::unique_ptr<FakeLayerTreeHost> layer_tree_host_;
LayerTree* layer_tree_;
int scrollbar_layer_id_;
};
@@ -780,9 +788,11 @@
scrollbar_layer->Update();
// A non-solid-color scrollbar should have requested two textures.
- EXPECT_EQ(expected_resources, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(expected_resources, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
}
@@ -841,9 +851,11 @@
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 0;
expected_created = 2;
@@ -853,9 +865,11 @@
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_EQ(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 0;
expected_created = 2;
@@ -864,9 +878,11 @@
EXPECT_FALSE(scrollbar_layer->Update());
EXPECT_EQ(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 2;
expected_created = 4;
@@ -876,9 +892,11 @@
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 1;
expected_created = 5;
@@ -887,9 +905,11 @@
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 0;
expected_created = 5;
@@ -899,9 +919,11 @@
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_EQ(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 2;
expected_created = 7;
@@ -920,9 +942,11 @@
EXPECT_TRUE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_NE(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
resource_count = 1;
expected_created = 10;
@@ -931,20 +955,23 @@
scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
scrollbar_layer->SetBounds(gfx::Size(90, 15));
EXPECT_TRUE(scrollbar_layer->Update());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
- EXPECT_EQ(
- gfx::Size(90, 15),
- layer_tree_host_->ui_resource_size(scrollbar_layer->track_resource_id()));
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
+ EXPECT_EQ(gfx::Size(90, 15), fake_ui_resource_manager_->ui_resource_size(
+ scrollbar_layer->track_resource_id()));
scrollbar_layer->ResetNeedsDisplayForTesting();
EXPECT_FALSE(scrollbar_layer->Update());
EXPECT_NE(0, scrollbar_layer->track_resource_id());
EXPECT_EQ(0, scrollbar_layer->thumb_resource_id());
- EXPECT_EQ(resource_count, layer_tree_host_->UIResourceCount());
- EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
- EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+ EXPECT_EQ(resource_count, fake_ui_resource_manager_->UIResourceCount());
+ EXPECT_EQ(expected_created,
+ fake_ui_resource_manager_->TotalUIResourceCreated());
+ EXPECT_EQ(expected_deleted,
+ fake_ui_resource_manager_->TotalUIResourceDeleted());
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
}
@@ -981,9 +1008,9 @@
// Verify that we have not generated any content uploads that are larger
// than their destination textures.
- gfx::Size track_size = layer_tree_host_->ui_resource_size(
+ gfx::Size track_size = fake_ui_resource_manager_->ui_resource_size(
scrollbar_layer->track_resource_id());
- gfx::Size thumb_size = layer_tree_host_->ui_resource_size(
+ gfx::Size thumb_size = fake_ui_resource_manager_->ui_resource_size(
scrollbar_layer->thumb_resource_id());
EXPECT_LE(track_size.width(),
@@ -1044,7 +1071,7 @@
scrollbar_layer->Update();
- UIResourceBitmap* bitmap = layer_tree_host_->ui_resource_bitmap(
+ UIResourceBitmap* bitmap = fake_ui_resource_manager_->ui_resource_bitmap(
scrollbar_layer->track_resource_id());
DCHECK(bitmap);
diff --git a/cc/layers/ui_resource_layer.cc b/cc/layers/ui_resource_layer.cc
index de86098..a887c0f 100644
--- a/cc/layers/ui_resource_layer.cc
+++ b/cc/layers/ui_resource_layer.cc
@@ -9,6 +9,7 @@
#include "cc/layers/ui_resource_layer_impl.h"
#include "cc/resources/scoped_ui_resource.h"
#include "cc/resources/ui_resource_bitmap.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/trees/layer_tree_host.h"
namespace cc {
@@ -19,15 +20,18 @@
class ScopedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
public:
static std::unique_ptr<ScopedUIResourceHolder> Create(
- LayerTreeHost* host,
+ UIResourceManager* ui_resource_manager,
const SkBitmap& skbitmap) {
- return base::WrapUnique(new ScopedUIResourceHolder(host, skbitmap));
+ return base::WrapUnique(
+ new ScopedUIResourceHolder(ui_resource_manager, skbitmap));
}
UIResourceId id() override { return resource_->id(); }
private:
- ScopedUIResourceHolder(LayerTreeHost* host, const SkBitmap& skbitmap) {
- resource_ = ScopedUIResource::Create(host, UIResourceBitmap(skbitmap));
+ ScopedUIResourceHolder(UIResourceManager* ui_resource_manager,
+ const SkBitmap& skbitmap) {
+ resource_ = ScopedUIResource::Create(ui_resource_manager,
+ UIResourceBitmap(skbitmap));
}
std::unique_ptr<ScopedUIResource> resource_;
@@ -118,9 +122,9 @@
void UIResourceLayer::SetBitmap(const SkBitmap& skbitmap) {
bitmap_ = skbitmap;
- if (layer_tree_host() && !bitmap_.empty()) {
- ui_resource_holder_ =
- ScopedUIResourceHolder::Create(layer_tree_host(), bitmap_);
+ if (GetLayerTree() && !bitmap_.empty()) {
+ ui_resource_holder_ = ScopedUIResourceHolder::Create(
+ GetLayerTree()->GetUIResourceManager(), bitmap_);
} else {
ui_resource_holder_ = nullptr;
}
@@ -157,10 +161,11 @@
if (!ui_resource_holder_) {
layer_impl->SetUIResourceId(0);
} else {
- DCHECK(layer_tree_host());
+ DCHECK(GetLayerTree());
gfx::Size image_size =
- layer_tree_host()->GetUIResourceSize(ui_resource_holder_->id());
+ GetLayerTree()->GetUIResourceManager()->GetUIResourceSize(
+ ui_resource_holder_->id());
layer_impl->SetUIResourceId(ui_resource_holder_->id());
layer_impl->SetImageBounds(image_size);
layer_impl->SetUV(uv_top_left_, uv_bottom_right_);
diff --git a/cc/layers/ui_resource_layer_unittest.cc b/cc/layers/ui_resource_layer_unittest.cc
index 62906af..c5fc041a 100644
--- a/cc/layers/ui_resource_layer_unittest.cc
+++ b/cc/layers/ui_resource_layer_unittest.cc
@@ -103,8 +103,9 @@
EXPECT_FALSE(test_layer->DrawsContent());
bool is_opaque = false;
- std::unique_ptr<ScopedUIResource> resource = ScopedUIResource::Create(
- layer_tree_host_.get(), UIResourceBitmap(gfx::Size(10, 10), is_opaque));
+ std::unique_ptr<ScopedUIResource> resource =
+ ScopedUIResource::Create(layer_tree_host_->GetUIResourceManager(),
+ UIResourceBitmap(gfx::Size(10, 10), is_opaque));
test_layer->SetUIResourceId(resource->id());
test_layer->Update();
@@ -112,8 +113,9 @@
// ID is preserved even when you set ID first and attach it to the tree.
layer_tree_host_->SetRootLayer(nullptr);
- std::unique_ptr<ScopedUIResource> shared_resource = ScopedUIResource::Create(
- layer_tree_host_.get(), UIResourceBitmap(gfx::Size(5, 5), is_opaque));
+ std::unique_ptr<ScopedUIResource> shared_resource =
+ ScopedUIResource::Create(layer_tree_host_->GetUIResourceManager(),
+ UIResourceBitmap(gfx::Size(5, 5), is_opaque));
test_layer->SetUIResourceId(shared_resource->id());
layer_tree_host_->SetRootLayer(test_layer);
EXPECT_EQ(shared_resource->id(), test_layer->GetUIResourceId());
diff --git a/cc/resources/scoped_ui_resource.cc b/cc/resources/scoped_ui_resource.cc
index 4ac336d2..dfac1ea01 100644
--- a/cc/resources/scoped_ui_resource.cc
+++ b/cc/resources/scoped_ui_resource.cc
@@ -6,29 +6,29 @@
#include "base/bind.h"
#include "base/memory/ptr_util.h"
-#include "cc/trees/layer_tree_host.h"
+#include "cc/resources/ui_resource_manager.h"
namespace cc {
std::unique_ptr<ScopedUIResource> ScopedUIResource::Create(
- LayerTreeHost* host,
+ UIResourceManager* ui_resource_manager,
const UIResourceBitmap& bitmap) {
- return base::WrapUnique(new ScopedUIResource(host, bitmap));
+ return base::WrapUnique(new ScopedUIResource(ui_resource_manager, bitmap));
}
-ScopedUIResource::ScopedUIResource(LayerTreeHost* host,
+ScopedUIResource::ScopedUIResource(UIResourceManager* ui_resource_manager,
const UIResourceBitmap& bitmap)
- : bitmap_(bitmap), host_(host) {
- DCHECK(host_);
- id_ = host_->CreateUIResource(this);
+ : bitmap_(bitmap), ui_resource_manager_(ui_resource_manager) {
+ DCHECK(ui_resource_manager_);
+ id_ = ui_resource_manager_->CreateUIResource(this);
}
// User must make sure that host is still valid before this object goes out of
// scope.
ScopedUIResource::~ScopedUIResource() {
if (id_) {
- DCHECK(host_);
- host_->DeleteUIResource(id_);
+ DCHECK(ui_resource_manager_);
+ ui_resource_manager_->DeleteUIResource(id_);
}
}
diff --git a/cc/resources/scoped_ui_resource.h b/cc/resources/scoped_ui_resource.h
index 4176c4b5..14db076b 100644
--- a/cc/resources/scoped_ui_resource.h
+++ b/cc/resources/scoped_ui_resource.h
@@ -13,7 +13,7 @@
namespace cc {
-class LayerTreeHost;
+class UIResourceManager;
// ScopedUIResource creates an UIResource from a bitmap and a LayerTreeHost.
// This class holds a pointer to the host so that when the instance goes out of
@@ -24,7 +24,7 @@
class CC_EXPORT ScopedUIResource : public UIResourceClient {
public:
static std::unique_ptr<ScopedUIResource> Create(
- LayerTreeHost* host,
+ UIResourceManager* ui_resource_manager,
const UIResourceBitmap& bitmap);
~ScopedUIResource() override;
@@ -33,10 +33,11 @@
UIResourceId id() { return id_; }
protected:
- ScopedUIResource(LayerTreeHost* host, const UIResourceBitmap& bitmap);
+ ScopedUIResource(UIResourceManager* ui_resource_manager,
+ const UIResourceBitmap& bitmap);
UIResourceBitmap bitmap_;
- LayerTreeHost* host_;
+ UIResourceManager* ui_resource_manager_;
UIResourceId id_;
private:
diff --git a/cc/resources/ui_resource_manager.cc b/cc/resources/ui_resource_manager.cc
new file mode 100644
index 0000000..e726e11
--- /dev/null
+++ b/cc/resources/ui_resource_manager.cc
@@ -0,0 +1,79 @@
+// Copyright 2016 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 <algorithm>
+
+#include "cc/resources/ui_resource_manager.h"
+
+namespace cc {
+
+UIResourceManager::UIResourceManager() : next_ui_resource_id_(1) {}
+
+UIResourceManager::~UIResourceManager() = default;
+
+UIResourceId UIResourceManager::CreateUIResource(UIResourceClient* client) {
+ DCHECK(client);
+
+ UIResourceId next_id = next_ui_resource_id_++;
+ DCHECK(ui_resource_client_map_.find(next_id) ==
+ ui_resource_client_map_.end());
+
+ bool resource_lost = false;
+ UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, next_id,
+ client->GetBitmap(next_id, resource_lost));
+ ui_resource_request_queue_.push_back(request);
+
+ UIResourceClientData data;
+ data.client = client;
+ data.size = request.GetBitmap().GetSize();
+
+ ui_resource_client_map_[request.GetId()] = data;
+ return request.GetId();
+}
+
+void UIResourceManager::DeleteUIResource(UIResourceId uid) {
+ UIResourceClientMap::iterator iter = ui_resource_client_map_.find(uid);
+ if (iter == ui_resource_client_map_.end())
+ return;
+
+ UIResourceRequest request(UIResourceRequest::UI_RESOURCE_DELETE, uid);
+ ui_resource_request_queue_.push_back(request);
+ ui_resource_client_map_.erase(iter);
+}
+
+void UIResourceManager::RecreateUIResources() {
+ for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
+ iter != ui_resource_client_map_.end(); ++iter) {
+ UIResourceId uid = iter->first;
+ const UIResourceClientData& data = iter->second;
+ bool resource_lost = true;
+ auto it = std::find_if(ui_resource_request_queue_.begin(),
+ ui_resource_request_queue_.end(),
+ [uid](const UIResourceRequest& request) {
+ return request.GetId() == uid;
+ });
+ if (it == ui_resource_request_queue_.end()) {
+ UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, uid,
+ data.client->GetBitmap(uid, resource_lost));
+ ui_resource_request_queue_.push_back(request);
+ }
+ }
+}
+
+gfx::Size UIResourceManager::GetUIResourceSize(UIResourceId uid) const {
+ UIResourceClientMap::const_iterator iter = ui_resource_client_map_.find(uid);
+ if (iter == ui_resource_client_map_.end())
+ return gfx::Size();
+
+ const UIResourceClientData& data = iter->second;
+ return data.size;
+}
+
+std::vector<UIResourceRequest> UIResourceManager::TakeUIResourcesRequests() {
+ UIResourceRequestQueue result;
+ result.swap(ui_resource_request_queue_);
+ return result;
+}
+
+} // namespace cc
diff --git a/cc/resources/ui_resource_manager.h b/cc/resources/ui_resource_manager.h
new file mode 100644
index 0000000..551a285
--- /dev/null
+++ b/cc/resources/ui_resource_manager.h
@@ -0,0 +1,65 @@
+// Copyright 2016 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_UI_RESOURCE_MANAGER_H_
+#define CC_RESOURCES_UI_RESOURCE_MANAGER_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "base/macros.h"
+#include "cc/base/cc_export.h"
+#include "cc/resources/scoped_ui_resource.h"
+#include "cc/resources/ui_resource_request.h"
+
+namespace cc {
+class UIResourceRequest;
+
+class CC_EXPORT UIResourceManager {
+ public:
+ UIResourceManager();
+ virtual ~UIResourceManager();
+
+ // CreateUIResource creates a resource given a bitmap. The bitmap is
+ // generated via an interface function, which is called when initializing the
+ // resource and when the resource has been lost (due to lost context). The
+ // parameter of the interface is a single boolean, which indicates whether the
+ // resource has been lost or not. CreateUIResource returns an Id of the
+ // resource, which is always positive.
+ virtual UIResourceId CreateUIResource(UIResourceClient* client);
+
+ // Deletes a UI resource. May safely be called more than once.
+ virtual void DeleteUIResource(UIResourceId id);
+
+ virtual gfx::Size GetUIResourceSize(UIResourceId id) const;
+
+ // Methods meant to be used only internally in cc ------------
+
+ // The current UIResourceRequestQueue is moved to the caller.
+ std::vector<UIResourceRequest> TakeUIResourcesRequests();
+
+ // Put the recreation of all UI resources into the resource queue after they
+ // were evicted on the impl thread.
+ void RecreateUIResources();
+
+ private:
+ struct UIResourceClientData {
+ UIResourceClient* client;
+ gfx::Size size;
+ };
+
+ using UIResourceClientMap =
+ std::unordered_map<UIResourceId, UIResourceClientData>;
+ UIResourceClientMap ui_resource_client_map_;
+ int next_ui_resource_id_;
+
+ using UIResourceRequestQueue = std::vector<UIResourceRequest>;
+ UIResourceRequestQueue ui_resource_request_queue_;
+
+ DISALLOW_COPY_AND_ASSIGN(UIResourceManager);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_UI_RESOURCE_MANAGER_H_
diff --git a/cc/test/fake_layer_tree_host.h b/cc/test/fake_layer_tree_host.h
index 7ee6a1ed0..52f02a38e 100644
--- a/cc/test/fake_layer_tree_host.h
+++ b/cc/test/fake_layer_tree_host.h
@@ -70,6 +70,7 @@
using LayerTreeHost::InitializeForTesting;
using LayerTreeHost::InitializePictureCacheForTesting;
using LayerTreeHost::RecordGpuRasterizationHistogram;
+ using LayerTreeHost::SetUIResourceManagerForTesting;
void UpdateLayers() { LayerTreeHost::UpdateLayers(); }
@@ -79,7 +80,6 @@
bool needs_commit() { return needs_commit_; }
- protected:
FakeLayerTreeHost(FakeLayerTreeHostClient* client,
LayerTreeHost::InitParams* params,
CompositorMode mode);
diff --git a/cc/test/fake_scoped_ui_resource.cc b/cc/test/fake_scoped_ui_resource.cc
index 9d1ac454..63fa31f 100644
--- a/cc/test/fake_scoped_ui_resource.cc
+++ b/cc/test/fake_scoped_ui_resource.cc
@@ -5,6 +5,7 @@
#include "cc/test/fake_scoped_ui_resource.h"
#include "base/memory/ptr_util.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/trees/layer_tree_host.h"
namespace cc {
@@ -19,21 +20,22 @@
} // anonymous namespace
std::unique_ptr<FakeScopedUIResource> FakeScopedUIResource::Create(
- LayerTreeHost* host) {
- return base::WrapUnique(new FakeScopedUIResource(host));
+ UIResourceManager* ui_resource_manager) {
+ return base::WrapUnique(new FakeScopedUIResource(ui_resource_manager));
}
-FakeScopedUIResource::FakeScopedUIResource(LayerTreeHost* host)
- : ScopedUIResource(host, CreateMockUIResourceBitmap()) {
+FakeScopedUIResource::FakeScopedUIResource(
+ UIResourceManager* ui_resource_manager)
+ : ScopedUIResource(ui_resource_manager, CreateMockUIResourceBitmap()) {
// The constructor of ScopedUIResource already created a resource so we need
// to delete the created resource to wipe the state clean.
- host_->DeleteUIResource(id_);
+ ui_resource_manager_->DeleteUIResource(id_);
ResetCounters();
- id_ = host_->CreateUIResource(this);
+ id_ = ui_resource_manager_->CreateUIResource(this);
}
void FakeScopedUIResource::DeleteResource() {
- host_->DeleteUIResource(id_);
+ ui_resource_manager_->DeleteUIResource(id_);
id_ = 0;
}
diff --git a/cc/test/fake_scoped_ui_resource.h b/cc/test/fake_scoped_ui_resource.h
index 54258b3..ae826402 100644
--- a/cc/test/fake_scoped_ui_resource.h
+++ b/cc/test/fake_scoped_ui_resource.h
@@ -14,7 +14,8 @@
class FakeScopedUIResource : public ScopedUIResource {
public:
- static std::unique_ptr<FakeScopedUIResource> Create(LayerTreeHost* host);
+ static std::unique_ptr<FakeScopedUIResource> Create(
+ UIResourceManager* ui_resource_manager);
UIResourceBitmap GetBitmap(UIResourceId uid, bool resource_lost) override;
void DeleteResource();
@@ -24,7 +25,7 @@
int lost_resource_count;
private:
- explicit FakeScopedUIResource(LayerTreeHost* host);
+ explicit FakeScopedUIResource(UIResourceManager* ui_resource_manager);
};
} // namespace cc
diff --git a/cc/trees/layer_tree.cc b/cc/trees/layer_tree.cc
index cf0c3bc4..7282f52 100644
--- a/cc/trees/layer_tree.cc
+++ b/cc/trees/layer_tree.cc
@@ -720,4 +720,12 @@
layer->SetNeedsDisplay();
}
+UIResourceManager* LayerTree::GetUIResourceManager() const {
+ return layer_tree_host_->GetUIResourceManager();
+}
+
+const LayerTreeSettings& LayerTree::GetSettings() const {
+ return layer_tree_host_->GetSettings();
+}
+
} // namespace cc
diff --git a/cc/trees/layer_tree.h b/cc/trees/layer_tree.h
index e731d4b..77d105c 100644
--- a/cc/trees/layer_tree.h
+++ b/cc/trees/layer_tree.h
@@ -37,7 +37,9 @@
class Layer;
class LayerTreeHost;
class LayerTreeImpl;
+class LayerTreeSettings;
struct PendingPageScaleAnimation;
+class UIResourceManager;
class CC_EXPORT LayerTree : public MutatorHostClient {
public:
@@ -120,6 +122,9 @@
void SetNeedsDisplayOnAllLayers();
+ UIResourceManager* GetUIResourceManager() const;
+ const LayerTreeSettings& GetSettings() const;
+
// Methods which should only be used internally in cc ------------------
void RegisterLayer(Layer* layer);
void UnregisterLayer(Layer* layer);
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index bc11de0..1976384 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -48,7 +48,7 @@
#include "cc/proto/gfx_conversions.h"
#include "cc/proto/layer_tree.pb.h"
#include "cc/proto/layer_tree_host.pb.h"
-#include "cc/resources/ui_resource_request.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/trees/draw_property_utils.h"
#include "cc/trees/layer_tree_host_client.h"
@@ -210,8 +210,8 @@
std::unique_ptr<LayerTree> layer_tree)
: micro_benchmark_controller_(this),
layer_tree_(std::move(layer_tree)),
- next_ui_resource_id_(1),
compositor_mode_(mode),
+ ui_resource_manager_(base::MakeUnique<UIResourceManager>()),
client_(params->client),
source_frame_number_(0),
rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
@@ -326,6 +326,11 @@
task_runner_provider_ = std::move(task_runner_provider);
}
+void LayerTreeHost::SetUIResourceManagerForTesting(
+ std::unique_ptr<UIResourceManager> ui_resource_manager) {
+ ui_resource_manager_ = std::move(ui_resource_manager);
+}
+
void LayerTreeHost::InitializeProxy(
std::unique_ptr<Proxy> proxy,
std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
@@ -374,6 +379,10 @@
return layer_tree_.get();
}
+UIResourceManager* LayerTreeHost::GetUIResourceManager() const {
+ return ui_resource_manager_.get();
+}
+
TaskRunnerProvider* LayerTreeHost::GetTaskRunnerProvider() const {
return task_runner_provider_.get();
}
@@ -460,10 +469,8 @@
sync_tree->SetDeviceScaleFactor(layer_tree_->device_scale_factor());
host_impl->SetDebugState(debug_state_);
- if (!ui_resource_request_queue_.empty()) {
- sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
- ui_resource_request_queue_.clear();
- }
+ sync_tree->set_ui_resource_request_queue(
+ ui_resource_manager_->TakeUIResourcesRequests());
{
TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
@@ -912,67 +919,6 @@
layer_tree_->property_trees()->needs_rebuild = true;
}
-UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
- DCHECK(client);
-
- UIResourceId next_id = next_ui_resource_id_++;
- DCHECK(ui_resource_client_map_.find(next_id) ==
- ui_resource_client_map_.end());
-
- bool resource_lost = false;
- UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, next_id,
- client->GetBitmap(next_id, resource_lost));
- ui_resource_request_queue_.push_back(request);
-
- UIResourceClientData data;
- data.client = client;
- data.size = request.GetBitmap().GetSize();
-
- ui_resource_client_map_[request.GetId()] = data;
- return request.GetId();
-}
-
-// Deletes a UI resource. May safely be called more than once.
-void LayerTreeHost::DeleteUIResource(UIResourceId uid) {
- UIResourceClientMap::iterator iter = ui_resource_client_map_.find(uid);
- if (iter == ui_resource_client_map_.end())
- return;
-
- UIResourceRequest request(UIResourceRequest::UI_RESOURCE_DELETE, uid);
- ui_resource_request_queue_.push_back(request);
- ui_resource_client_map_.erase(iter);
-}
-
-void LayerTreeHost::RecreateUIResources() {
- for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
- iter != ui_resource_client_map_.end();
- ++iter) {
- UIResourceId uid = iter->first;
- const UIResourceClientData& data = iter->second;
- bool resource_lost = true;
- auto it = std::find_if(ui_resource_request_queue_.begin(),
- ui_resource_request_queue_.end(),
- [uid](const UIResourceRequest& request) {
- return request.GetId() == uid;
- });
- if (it == ui_resource_request_queue_.end()) {
- UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, uid,
- data.client->GetBitmap(uid, resource_lost));
- ui_resource_request_queue_.push_back(request);
- }
- }
-}
-
-// Returns the size of a resource given its id.
-gfx::Size LayerTreeHost::GetUIResourceSize(UIResourceId uid) const {
- UIResourceClientMap::const_iterator iter = ui_resource_client_map_.find(uid);
- if (iter == ui_resource_client_map_.end())
- return gfx::Size();
-
- const UIResourceClientData& data = iter->second;
- return data.size;
-}
-
int LayerTreeHost::ScheduleMicroBenchmark(
const std::string& benchmark_name,
std::unique_ptr<base::Value> value,
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index 3fe2aba..32a2bd0 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -34,7 +34,6 @@
#include "cc/output/output_surface.h"
#include "cc/output/swap_promise.h"
#include "cc/resources/resource_format.h"
-#include "cc/resources/scoped_ui_resource.h"
#include "cc/surfaces/surface_sequence.h"
#include "cc/trees/compositor_mode.h"
#include "cc/trees/layer_tree.h"
@@ -73,7 +72,6 @@
class SharedBitmapManager;
class TaskGraphRunner;
class TopControlsManager;
-class UIResourceRequest;
struct PendingPageScaleAnimation;
struct RenderingStats;
struct ScrollAndScaleSet;
@@ -145,6 +143,7 @@
int SourceFrameNumber() const override;
LayerTree* GetLayerTree() override;
const LayerTree* GetLayerTree() const override;
+ UIResourceManager* GetUIResourceManager() const override;
TaskRunnerProvider* GetTaskRunnerProvider() const override;
const LayerTreeSettings& GetSettings() const override;
void SetSurfaceClientId(uint32_t client_id) override;
@@ -228,21 +227,6 @@
Proxy* proxy() const { return proxy_.get(); }
- // CreateUIResource creates a resource given a bitmap. The bitmap is
- // generated via an interface function, which is called when initializing the
- // resource and when the resource has been lost (due to lost context). The
- // parameter of the interface is a single boolean, which indicates whether the
- // resource has been lost or not. CreateUIResource returns an Id of the
- // resource, which is always positive.
- virtual UIResourceId CreateUIResource(UIResourceClient* client);
- // Deletes a UI resource. May safely be called more than once.
- virtual void DeleteUIResource(UIResourceId id);
- // Put the recreation of all UI resources into the resource queue after they
- // were evicted on the impl thread.
- void RecreateUIResources();
-
- virtual gfx::Size GetUIResourceSize(UIResourceId id) const;
-
void BreakSwapPromises(SwapPromise::DidNotSwapReason reason);
std::vector<std::unique_ptr<SwapPromise>> TakeSwapPromises();
@@ -313,6 +297,8 @@
void InitializePictureCacheForTesting();
void SetTaskRunnerProviderForTesting(
std::unique_ptr<TaskRunnerProvider> task_runner_provider);
+ void SetUIResourceManagerForTesting(
+ std::unique_ptr<UIResourceManager> ui_resource_manager);
// shared_bitmap_manager(), gpu_memory_buffer_manager(), and
// task_graph_runner() return valid values only until the LayerTreeHostImpl is
@@ -353,19 +339,6 @@
bool AnimateLayersRecursive(Layer* current, base::TimeTicks time);
- struct UIResourceClientData {
- UIResourceClient* client;
- gfx::Size size;
- };
-
- using UIResourceClientMap =
- std::unordered_map<UIResourceId, UIResourceClientData>;
- UIResourceClientMap ui_resource_client_map_;
- int next_ui_resource_id_;
-
- using UIResourceRequestQueue = std::vector<UIResourceRequest>;
- UIResourceRequestQueue ui_resource_request_queue_;
-
void CalculateLCDTextMetricsCallback(Layer* layer);
void NotifySwapPromiseMonitorsOfSetNeedsCommit();
@@ -374,6 +347,8 @@
const CompositorMode compositor_mode_;
+ std::unique_ptr<UIResourceManager> ui_resource_manager_;
+
LayerTreeHostClient* client_;
std::unique_ptr<Proxy> proxy_;
std::unique_ptr<TaskRunnerProvider> task_runner_provider_;
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 6fbc7b9..bcb68a1 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -44,6 +44,8 @@
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
#include "cc/quads/tile_draw_quad.h"
+#include "cc/resources/ui_resource_bitmap.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/test/animation_test_common.h"
#include "cc/test/begin_frame_args_test.h"
#include "cc/test/fake_layer_tree_host_impl.h"
diff --git a/cc/trees/layer_tree_host_interface.h b/cc/trees/layer_tree_host_interface.h
index 7308787..860031c 100644
--- a/cc/trees/layer_tree_host_interface.h
+++ b/cc/trees/layer_tree_host_interface.h
@@ -27,6 +27,7 @@
class OutputSurface;
class SwapPromiseMonitor;
class TaskRunnerProvider;
+class UIResourceManager;
// TODO(khushalsagar): Will be renamed to LayerTreeHost.
class CC_EXPORT LayerTreeHostInterface {
@@ -45,6 +46,10 @@
virtual LayerTree* GetLayerTree() = 0;
virtual const LayerTree* GetLayerTree() const = 0;
+ // Returns the UIResourceManager used to create UIResources for
+ // UIResourceLayers pushed to the LayerTree.
+ virtual UIResourceManager* GetUIResourceManager() const = 0;
+
// Returns the TaskRunnerProvider used to access the main and compositor
// thread task runners.
virtual TaskRunnerProvider* GetTaskRunnerProvider() const = 0;
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index bdccdc5..b2ab289e 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -33,6 +33,7 @@
#include "cc/quads/draw_quad.h"
#include "cc/quads/render_pass_draw_quad.h"
#include "cc/quads/tile_draw_quad.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/test/fake_content_layer_client.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_output_surface.h"
@@ -3016,12 +3017,14 @@
// Usually ScopedUIResource are deleted from the manager in their
// destructor. Here we just want to test that a direct call to
// DeleteUIResource works.
- layer_tree_host()->DeleteUIResource(ui_resources_[0]->id());
+ layer_tree_host()->GetUIResourceManager()->DeleteUIResource(
+ ui_resources_[0]->id());
PostSetNeedsCommitToMainThread();
break;
case 3:
// DeleteUIResource can be called with an invalid id.
- layer_tree_host()->DeleteUIResource(ui_resources_[0]->id());
+ layer_tree_host()->GetUIResourceManager()->DeleteUIResource(
+ ui_resources_[0]->id());
PostSetNeedsCommitToMainThread();
break;
case 4:
@@ -3078,7 +3081,7 @@
void CreateResource() {
ui_resources_[num_ui_resources_++] =
- FakeScopedUIResource::Create(layer_tree_host());
+ FakeScopedUIResource::Create(layer_tree_host()->GetUIResourceManager());
}
std::unique_ptr<FakeScopedUIResource> ui_resources_[5];
@@ -4931,7 +4934,8 @@
protected:
void SetupTree() override {
LayerTreeHostTest::SetupTree();
- ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource_ =
+ FakeScopedUIResource::Create(layer_tree_host()->GetUIResourceManager());
client_.set_bounds(layer_tree()->root_layer()->bounds());
}
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index 1c5dce6..156fca8 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -16,6 +16,7 @@
#include "cc/layers/video_layer_impl.h"
#include "cc/output/filter_operations.h"
#include "cc/resources/single_release_callback.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/test/fake_content_layer_client.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_output_surface.h"
@@ -1229,7 +1230,8 @@
EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
switch (step) {
case 0:
- ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
// Expects a valid UIResourceId.
EXPECT_NE(0, ui_resource_->id());
PostSetNeedsCommitToMainThread();
@@ -1287,7 +1289,8 @@
void StepCompleteOnMainThread(int step) override {
switch (step) {
case 0:
- ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
// Lose the context on the impl thread before the commit.
PostLoseContextToImplThread();
break;
@@ -1298,7 +1301,8 @@
// Delete this resource.
ui_resource_ = nullptr;
// Create another resource.
- ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
test_id1_ = ui_resource_->id();
// Sanity check that two resource creations return different ids.
EXPECT_NE(test_id0_, test_id1_);
@@ -1312,14 +1316,15 @@
break;
case 4:
// Sequence 3:
- ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
test_id0_ = ui_resource_->id();
// Sanity check the UIResourceId should not be 0.
EXPECT_NE(0, test_id0_);
// Usually ScopedUIResource are deleted from the manager in their
// destructor (so usually ui_resource_ = nullptr). But here we need
// ui_resource_ for the next step, so call DeleteUIResource directly.
- layer_tree_host()->DeleteUIResource(test_id0_);
+ layer_tree_host()->GetUIResourceManager()->DeleteUIResource(test_id0_);
// Delete the resouce and then lose the context.
PostLoseContextToImplThread();
break;
@@ -1384,7 +1389,8 @@
EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
switch (step) {
case 0:
- ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
PostSetNeedsCommitToMainThread();
break;
case 3:
@@ -1467,8 +1473,10 @@
EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
switch (step) {
case 0:
- ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
- ui_resource2_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
+ ui_resource2_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
EXPECT_NE(0, ui_resource_->id());
EXPECT_NE(0, ui_resource2_->id());
PostSetNeedsCommitToMainThread();
@@ -1477,7 +1485,8 @@
// Make the tree not visible.
PostSetVisibleToMainThread(false);
ui_resource2_->DeleteResource();
- ui_resource3_ = FakeScopedUIResource::Create(layer_tree_host());
+ ui_resource3_ = FakeScopedUIResource::Create(
+ layer_tree_host()->GetUIResourceManager());
break;
case 3:
// Release resources before ending the test.
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 7ec16870..a0af353 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -1556,8 +1556,8 @@
}
void LayerTreeImpl::set_ui_resource_request_queue(
- const UIResourceRequestQueue& queue) {
- ui_resource_request_queue_ = queue;
+ UIResourceRequestQueue queue) {
+ ui_resource_request_queue_ = std::move(queue);
}
ResourceId LayerTreeImpl::ResourceIdForUIResource(UIResourceId uid) const {
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 1f2cdbb3..13d7912 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -278,7 +278,7 @@
}
bool has_ever_been_drawn() const { return has_ever_been_drawn_; }
- void set_ui_resource_request_queue(const UIResourceRequestQueue& queue);
+ void set_ui_resource_request_queue(UIResourceRequestQueue queue);
const LayerImplList& RenderSurfaceLayerList() const;
const Region& UnoccludedScreenSpaceRegion() const;
diff --git a/cc/trees/proxy_main.cc b/cc/trees/proxy_main.cc
index b5032b4..414e014 100644
--- a/cc/trees/proxy_main.cc
+++ b/cc/trees/proxy_main.cc
@@ -15,6 +15,7 @@
#include "cc/debug/devtools_instrumentation.h"
#include "cc/output/output_surface.h"
#include "cc/output/swap_promise.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/trees/blocking_task_runner.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/trees/remote_channel_main.h"
@@ -178,7 +179,7 @@
// Recreate all UI resources if there were evicted UI resources when the impl
// thread initiated the commit.
if (begin_main_frame_state->evicted_ui_resources)
- layer_tree_host_->RecreateUIResources();
+ layer_tree_host_->GetUIResourceManager()->RecreateUIResources();
layer_tree_host_->RequestMainFrameUpdate();
TRACE_EVENT_SYNTHETIC_DELAY_END("cc.BeginMainFrame");
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index dc46c48..886d59b 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -14,6 +14,7 @@
#include "cc/output/context_provider.h"
#include "cc/output/output_surface.h"
#include "cc/quads/draw_quad.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/scheduler/commit_earlyout_reason.h"
#include "cc/scheduler/compositor_timing_history.h"
#include "cc/scheduler/delay_based_time_source.h"
@@ -205,7 +206,7 @@
layer_tree_host_impl_->BeginCommit();
if (layer_tree_host_impl_->EvictedUIResourcesExist())
- layer_tree_host_->RecreateUIResources();
+ layer_tree_host_->GetUIResourceManager()->RecreateUIResources();
layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
diff --git a/content/browser/renderer_host/compositor_impl_android.cc b/content/browser/renderer_host/compositor_impl_android.cc
index c690d29..1c21e9e2 100644
--- a/content/browser/renderer_host/compositor_impl_android.cc
+++ b/content/browser/renderer_host/compositor_impl_android.cc
@@ -39,6 +39,7 @@
#include "cc/output/texture_mailbox_deleter.h"
#include "cc/output/vulkan_in_process_context_provider.h"
#include "cc/raster/single_thread_task_graph_runner.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/surfaces/display.h"
#include "cc/surfaces/display_scheduler.h"
@@ -410,7 +411,7 @@
root_window->GetLayer()->AddChild(readback_layer_tree_);
root_window->AttachCompositor(this);
CreateLayerTreeHost();
- resource_manager_.Init(host_.get());
+ resource_manager_.Init(host_->GetUIResourceManager());
}
CompositorImpl::~CompositorImpl() {
@@ -746,12 +747,12 @@
cc::UIResourceId CompositorImpl::CreateUIResource(
cc::UIResourceClient* client) {
TRACE_EVENT0("compositor", "CompositorImpl::CreateUIResource");
- return host_->CreateUIResource(client);
+ return host_->GetUIResourceManager()->CreateUIResource(client);
}
void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
TRACE_EVENT0("compositor", "CompositorImpl::DeleteUIResource");
- host_->DeleteUIResource(resource_id);
+ host_->GetUIResourceManager()->DeleteUIResource(resource_id);
}
bool CompositorImpl::SupportsETC1NonPowerOfTwo() const {
diff --git a/ui/android/resources/resource_manager_impl.cc b/ui/android/resources/resource_manager_impl.cc
index e722c01..7a90374 100644
--- a/ui/android/resources/resource_manager_impl.cc
+++ b/ui/android/resources/resource_manager_impl.cc
@@ -14,6 +14,7 @@
#include "base/memory/ptr_util.h"
#include "base/trace_event/trace_event.h"
#include "cc/resources/scoped_ui_resource.h"
+#include "cc/resources/ui_resource_manager.h"
#include "jni/ResourceManager_jni.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkCanvas.h"
@@ -36,7 +37,7 @@
}
ResourceManagerImpl::ResourceManagerImpl(gfx::NativeWindow native_window)
- : host_(nullptr) {
+ : ui_resource_manager_(nullptr) {
JNIEnv* env = base::android::AttachCurrentThread();
java_obj_.Reset(
env, Java_ResourceManager_create(env, native_window->GetJavaObject(),
@@ -49,10 +50,10 @@
Java_ResourceManager_destroy(base::android::AttachCurrentThread(), java_obj_);
}
-void ResourceManagerImpl::Init(cc::LayerTreeHost* host) {
- DCHECK(!host_);
- DCHECK(host);
- host_ = host;
+void ResourceManagerImpl::Init(cc::UIResourceManager* ui_resource_manager) {
+ DCHECK(!ui_resource_manager_);
+ DCHECK(ui_resource_manager);
+ ui_resource_manager_ = ui_resource_manager;
}
base::android::ScopedJavaLocalRef<jobject>
@@ -135,8 +136,8 @@
tinted_resource->size = gfx::Size(base_image->size);
tinted_resource->padding = gfx::Rect(base_image->padding);
tinted_resource->aperture = gfx::Rect(base_image->aperture);
- tinted_resource->ui_resource = cc::ScopedUIResource::Create(host_,
- cc::UIResourceBitmap(tinted_bitmap));
+ tinted_resource->ui_resource = cc::ScopedUIResource::Create(
+ ui_resource_manager_, cc::UIResourceBitmap(tinted_bitmap));
resource_map->AddWithID(tinted_resource, res_id);
@@ -196,8 +197,8 @@
SkBitmap skbitmap = gfx::CreateSkBitmapFromJavaBitmap(jbitmap);
skbitmap.setImmutable();
- resource->ui_resource =
- cc::ScopedUIResource::Create(host_, cc::UIResourceBitmap(skbitmap));
+ resource->ui_resource = cc::ScopedUIResource::Create(
+ ui_resource_manager_, cc::UIResourceBitmap(skbitmap));
}
CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource(
diff --git a/ui/android/resources/resource_manager_impl.h b/ui/android/resources/resource_manager_impl.h
index 31d26f5..9b616b6 100644
--- a/ui/android/resources/resource_manager_impl.h
+++ b/ui/android/resources/resource_manager_impl.h
@@ -14,6 +14,10 @@
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/native_widget_types.h"
+namespace cc {
+class UIResourceManager;
+} // namespace cc
+
namespace ui {
class UI_ANDROID_EXPORT ResourceManagerImpl : public ResourceManager {
@@ -23,7 +27,7 @@
explicit ResourceManagerImpl(gfx::NativeWindow native_window);
~ResourceManagerImpl() override;
- void Init(cc::LayerTreeHost* host);
+ void Init(cc::UIResourceManager* ui_resource_manager);
// ResourceManager implementation.
base::android::ScopedJavaLocalRef<jobject> GetJavaObject() override;
@@ -92,7 +96,7 @@
typedef std::unordered_map<int, std::unique_ptr<ResourceMap> >
TintedResourceMap;
- cc::LayerTreeHost* host_;
+ cc::UIResourceManager* ui_resource_manager_;
ResourceMap resources_[ANDROID_RESOURCE_TYPE_COUNT];
CrushedSpriteResourceMap crushed_sprite_resources_;
TintedResourceMap tinted_resources_;
diff --git a/ui/android/resources/resource_manager_impl_unittest.cc b/ui/android/resources/resource_manager_impl_unittest.cc
index e4c4788..72fd7e0 100644
--- a/ui/android/resources/resource_manager_impl_unittest.cc
+++ b/ui/android/resources/resource_manager_impl_unittest.cc
@@ -7,9 +7,9 @@
#include "base/macros.h"
#include "cc/animation/animation_host.h"
#include "cc/resources/ui_resource_bitmap.h"
+#include "cc/resources/ui_resource_manager.h"
#include "cc/test/stub_layer_tree_host_client.h"
#include "cc/test/test_task_graph_runner.h"
-#include "cc/trees/layer_tree_host.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/skia/include/core/SkBitmap.h"
@@ -71,17 +71,15 @@
const ui::SystemUIResourceType kTestResourceType = ui::OVERSCROLL_GLOW;
-class MockLayerTreeHost : public cc::LayerTreeHost {
+class MockUIResourceManager : public cc::UIResourceManager {
public:
- MockLayerTreeHost(cc::LayerTreeHost::InitParams* params,
- cc::CompositorMode mode)
- : cc::LayerTreeHost(params, mode) {}
+ MockUIResourceManager() {}
MOCK_METHOD1(CreateUIResource, cc::UIResourceId(cc::UIResourceClient*));
MOCK_METHOD1(DeleteUIResource, void(cc::UIResourceId));
private:
- DISALLOW_COPY_AND_ASSIGN(MockLayerTreeHost);
+ DISALLOW_COPY_AND_ASSIGN(MockUIResourceManager);
};
} // namespace
@@ -91,16 +89,7 @@
ResourceManagerTest()
: window_android_(WindowAndroid::CreateForTesting()),
resource_manager_(window_android_) {
- cc::LayerTreeHost::InitParams params;
- cc::LayerTreeSettings settings;
- params.client = &stub_client_;
- params.settings = &settings;
- params.task_graph_runner = &task_graph_runner_;
- params.animation_host =
- cc::AnimationHost::CreateForTesting(cc::ThreadInstance::MAIN);
- host_.reset(new MockLayerTreeHost(¶ms,
- cc::CompositorMode::SINGLE_THREADED));
- resource_manager_.Init(host_.get());
+ resource_manager_.Init(&ui_resource_manager_);
}
~ResourceManagerTest() override {
@@ -125,7 +114,7 @@
WindowAndroid* window_android_;
protected:
- std::unique_ptr<MockLayerTreeHost> host_;
+ MockUIResourceManager ui_resource_manager_;
TestResourceManagerImpl resource_manager_;
cc::TestTaskGraphRunner task_graph_runner_;
cc::StubLayerTreeHostClient stub_client_;
@@ -133,7 +122,7 @@
TEST_F(ResourceManagerTest, GetResource) {
const cc::UIResourceId kResourceId = 99;
- EXPECT_CALL(*host_.get(), CreateUIResource(_))
+ EXPECT_CALL(ui_resource_manager_, CreateUIResource(_))
.WillOnce(Return(kResourceId))
.RetiresOnSaturation();
EXPECT_EQ(kResourceId, GetUIResourceId(kTestResourceType));
@@ -142,7 +131,7 @@
TEST_F(ResourceManagerTest, PreloadEnsureResource) {
const cc::UIResourceId kResourceId = 99;
PreloadResource(kTestResourceType);
- EXPECT_CALL(*host_.get(), CreateUIResource(_))
+ EXPECT_CALL(ui_resource_manager_, CreateUIResource(_))
.WillOnce(Return(kResourceId))
.RetiresOnSaturation();
SetResourceAsLoaded(kTestResourceType);
