Prevent recreation of UI resource holder when created with resource ID

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 "cc/layers/ui_resource_layer_impl.h"
 #include "cc/resources/prioritized_resource.h"
 #include "cc/resources/resource_update.h"
 #include "cc/resources/resource_update_queue.h"
 #include "cc/resources/scoped_ui_resource.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
 
 namespace {
 
 class ScopedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
  public:
   static scoped_ptr<ScopedUIResourceHolder> Create(LayerTreeHost* host,
                                             const SkBitmap& skbitmap) {
     return make_scoped_ptr(new ScopedUIResourceHolder(host, skbitmap));
   }
   UIResourceId id() override { return resource_->id(); }
 
+  bool NeedsRecreation() override { return false; }
+
  private:
   ScopedUIResourceHolder(LayerTreeHost* host, const SkBitmap& skbitmap) {
     resource_ = ScopedUIResource::Create(host, UIResourceBitmap(skbitmap));
   }
 
   scoped_ptr<ScopedUIResource> resource_;
 };
 
 class SharedUIResourceHolder : public UIResourceLayer::UIResourceHolder {
  public:
   static scoped_ptr<SharedUIResourceHolder> Create(UIResourceId id) {
     return make_scoped_ptr(new SharedUIResourceHolder(id));
   }
 
   UIResourceId id() override { return id_; }
 
+  bool NeedsRecreation() override { return true; }
+
  private:
   explicit SharedUIResourceHolder(UIResourceId id) : id_(id) {}
 
   UIResourceId id_;
 };
 
 }  // anonymous namespace
 
 UIResourceLayer::UIResourceHolder::~UIResourceHolder() {}
 
@@ skipping 51 matching lines @@
   if (host == layer_tree_host())
     return;
 
   Layer::SetLayerTreeHost(host);
 
   // Recreate the resource hold against the new LTH.
   RecreateUIResourceHolder();
 }
 
 void UIResourceLayer::RecreateUIResourceHolder() {
-  ui_resource_holder_ = nullptr;
   if (layer_tree_host() && !bitmap_.empty()) {
     ui_resource_holder_ =
         ScopedUIResourceHolder::Create(layer_tree_host(), bitmap_);
+  } else if (ui_resource_holder_ && !ui_resource_holder_->NeedsRecreation()) {

[danakj, 2014/10/31 14:23:35]

So when you attach a layer to a LayerTreeHost its resource ID namespace becomes
that of the LTH.

Does it make sense to call UIResourceLayer::SetUIResourceId() when it's not
attached to a LayerTreeHost? Why does this need to be done? Without a LTH it has
no namespace for that uiresourceid.

[Changwan Ryu, 2014/11/06 00:27:27]

Hmm.. Let me give you more background:

Because we aren't in control of the timing of when SetLayerTreeHost would be
called, we simply do not know when to set UI resource ID.

Previously, we did this by overriding SetLayerTreeHost in an inheriting class,
but we are trying to switching from inheritance to containment model. (See the
bug for more details.)

If UI resource ID should be tied to a resource namespace (which is specific to
LTH), probably what we should do is try to get some callback when
SetLayerTreeHost is called. Do you have any suggestion of where we can do it?

+    ui_resource_holder_ = nullptr;
   }
   UpdateDrawsContent(HasDrawableContent());
 }
 
 void UIResourceLayer::SetBitmap(const SkBitmap& skbitmap) {
   bitmap_ = skbitmap;
 
   RecreateUIResourceHolder();
   SetNeedsCommit();
 }
@@ skipping 28 matching lines @@
     gfx::Size image_size =
         layer_tree_host()->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