cc: Move UI Resource management out of LayerTreeHost.

cc/layers/ui_resource_layer.cc

 // Copyright 2013 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/layers/ui_resource_layer.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #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 {
 
 
 namespace {
 
 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_;
 };
 
 class SharedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
  public:
   static std::unique_ptr<SharedUIResourceHolder> Create(UIResourceId id) {
     return base::WrapUnique(new SharedUIResourceHolder(id));
   }
@@ skipping 70 matching lines @@
   UpdateDrawsContent(HasDrawableContent());
 }
 
 void UIResourceLayer::RecreateUIResourceHolder() {
   if (!bitmap_.empty())
     SetBitmap(bitmap_);
 }
 
 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_);

[danakj, 2016/09/08 20:57:35]

How about storing the UIResourceManager* in SetLayerTreeHost? Then you don't
need this accessor on LayerTree?

[Khushal, 2016/09/08 22:05:24]

Finally the SetLayerTreeHost will change to SetLayerTree so Layers just talk to
the tree, keeping it somewhat consistent with the impl side where LayerImpls go
through the LayerTreeImpl for things they need from the host. Also helped me
refactor the code clearly so the use of LayerTreeHost is restricted to fewer
places, its much easier to see when something gets added whether it actually
needs to go on the host or the tree. WDYT?

[danakj, 2016/09/08 22:37:12]

I see, and since layers can change trees it wont make sense for the layer to be
given the uiresourcemanager at creation time. Or would it make sense to have the
UIResourceManager owned by the embedder and shared between all LayerTreeHosts?

I was a bit :/ about this new category of "pass thru" methods on LayerTree, but
actually reading the impl of LayerTree there are a lot of methods that are using
LTH already, like SetNeedsCommit for example. I think if you add new methods to
LayerTree they should just be part of the LayerTree API and not pointed out as
"pass thru" in comments, that's an implementation detail of how LayerTree works.

[Khushal, 2016/09/08 23:56:05]

I was mostly just moving code here so my understanding might not be completely
accurate but looks like the state that is tied to the host in the
UIResourceManager is requests for UI resources for layers tied to it, so if the
impl thread comes back and says, "I dropped all the resources, make the ones
that you want to use in this commit again", then something on the main thread
needs to be keeping track of those. I kind of don't want to change much logic in
this patch too, if its not necessary. Now that all of it is pulled out
seperately, perhaps it would be easier to change ownership of things if that
makes sense.
Eeks, fair enough. There is a lot that's pass through already, so the comment is
just confusing. Removed.

   } else {
     ui_resource_holder_ = nullptr;
   }
   UpdateDrawsContent(HasDrawableContent());
   SetNeedsCommit();
 }
 
 void UIResourceLayer::SetUIResourceId(UIResourceId resource_id) {
   if (ui_resource_holder_ && ui_resource_holder_->id() == resource_id)
     return;
@@ skipping 16 matching lines @@
 }
 
 void UIResourceLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
   TRACE_EVENT0("cc", "UIResourceLayer::PushPropertiesTo");
   UIResourceLayerImpl* layer_impl = static_cast<UIResourceLayerImpl*>(layer);
 
   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_);
     layer_impl->SetVertexOpacity(vertex_opacity_);
   }
 }
 
 }  // namespace cc