cc: Split ReleaseResources into Release and Recreate.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 98 matching lines @@
     delta = outer_->ScrollBy(delta);
     inner_->ScrollBy(delta);
   }
 
  private:
   LayerImpl* inner_;
   LayerImpl* outer_;
   gfx::ScrollOffset viewport_in_content_coordinates_;
 };
 
+template <typename Object>
+class ScopedCaller {

[danakj, 2015/02/05 20:45:49]

did you look around in base/ for something like this btw? maybe there is
something.. tho it'd probably use Callback.

[vmpstr, 2015/02/05 21:41:32]

I couldn't really find anything that would do a similar thing. The closest is
ScopedClosureRunner, but it just runs a given closure in the dtor.

+ public:
+  using Function = void (Object::*)();
+  ScopedCaller(Object* object, Function on_entry, Function on_exit)
+      : object_(object), on_exit_(on_exit) {
+    (object_->*on_entry)();
+  }
+
+  ~ScopedCaller() { (object_->*on_exit_)(); }
+
+ private:
+  Object* object_;
+  Function on_exit_;
+};
 
 void DidVisibilityChange(LayerTreeHostImpl* id, bool visible) {
   if (visible) {
     TRACE_EVENT_ASYNC_BEGIN1("cc", "LayerTreeHostImpl::SetVisible", id,
                              "LayerTreeHostImpl", id);
     return;
   }
 
   TRACE_EVENT_ASYNC_END0("cc", "LayerTreeHostImpl::SetVisible", id);
 }
@@ skipping 1475 matching lines @@
 void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu) {
   if (use_gpu == use_gpu_rasterization_)
     return;
 
   // Note that this must happen first, in case the rest of the calls want to
   // query the new state of |use_gpu_rasterization_|.
   use_gpu_rasterization_ = use_gpu;
 
   // Clean up and replace existing tile manager with another one that uses
   // appropriate rasterizer.
-  ReleaseTreeResources();
+  ScopedCaller<LayerTreeHostImpl> scoped_release_resources(
+      this, &LayerTreeHostImpl::ReleaseTreeResources,
+      &LayerTreeHostImpl::RecreateTreeResources);
   if (tile_manager_) {
     DestroyTileManager();
     CreateAndSetTileManager();
   }
 
   // We have released tilings for both active and pending tree.
   // We would not have any content to draw until the pending tree is activated.
   // Prevent the active tree from drawing until activation.
   SetRequiresHighResToDraw();
 }
@@ skipping 302 matching lines @@
 void LayerTreeHostImpl::ReleaseTreeResources() {
   active_tree_->ReleaseResources();
   if (pending_tree_)
     pending_tree_->ReleaseResources();
   if (recycle_tree_)
     recycle_tree_->ReleaseResources();
 
   EvictAllUIResources();
 }
 
+void LayerTreeHostImpl::RecreateTreeResources() {
+  active_tree_->RecreateResources();
+  if (pending_tree_)
+    pending_tree_->RecreateResources();
+  if (recycle_tree_)
+    recycle_tree_->RecreateResources();
+}
+
 void LayerTreeHostImpl::CreateAndSetRenderer() {
   DCHECK(!renderer_);
   DCHECK(output_surface_);
   DCHECK(resource_provider_);
 
   if (output_surface_->capabilities().delegated_rendering) {
     renderer_ = DelegatingRenderer::Create(this, &settings_.renderer_settings,
                                            output_surface_.get(),
                                            resource_provider_.get());
   } else if (output_surface_->context_provider()) {
@@ skipping 171 matching lines @@
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   ReleaseTreeResources();
 
   // Note: order is important here.
   renderer_ = nullptr;
   DestroyTileManager();
   resource_provider_ = nullptr;
   output_surface_ = nullptr;
 
-  if (!output_surface->BindToClient(this))
+  if (!output_surface->BindToClient(this)) {
+    // Avoid recreating tree resources because we might not have enough
+    // information to do this yet (eg. we don't have a TileManager at this
+    // point).
     return false;
+  }
 
   output_surface_ = output_surface.Pass();
   resource_provider_ = ResourceProvider::Create(
       output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_,
       proxy_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.use_rgba_4444_textures,
       settings_.renderer_settings.texture_id_allocation_chunk_size);
 
   if (output_surface_->capabilities().deferred_gl_initialization)
     EnforceZeroBudget(true);
 
   CreateAndSetRenderer();
 
   if (settings_.impl_side_painting)
     CreateAndSetTileManager();
+  RecreateTreeResources();
 
   // Initialize vsync parameters to sane values.
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           settings_.renderer_settings.refresh_rate);
   CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
 
   // TODO(brianderson): Don't use a hard-coded parent draw time.
   base::TimeDelta parent_draw_time =
@@ skipping 20 matching lines @@
 void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
                                               base::TimeDelta interval) {
   client_->CommitVSyncParameters(timebase, interval);
 }
 
 void LayerTreeHostImpl::DeferredInitialize() {
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
-  ReleaseTreeResources();
+  ScopedCaller<LayerTreeHostImpl> scoped_release_resources(

[enne (OOO), 2015/02/05 20:43:52]

This seems like overkill.  Neither of the functions this is in has an early out,
so maybe just call the two functions you need?

Also, this is only valid for picture layers, so maybe DestroyTileManager and
CreateAndSetTileManager could just make these recreate/release calls?

[vmpstr, 2015/02/05 21:41:32]

It's ReleaseResources is also implemented in textured layer and video layer, so
I'd prefer to keep the two calls outside of tile manager specific stuff. I
changed this to be explicit calls.

+      this, &LayerTreeHostImpl::ReleaseTreeResources,
+      &LayerTreeHostImpl::RecreateTreeResources);
   renderer_ = nullptr;
   DestroyTileManager();
 
   resource_provider_->InitializeGL();
 
   CreateAndSetRenderer();
   EnforceZeroBudget(false);
   CreateAndSetTileManager();
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::ReleaseGL() {
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
-  ReleaseTreeResources();
+  ScopedCaller<LayerTreeHostImpl> scoped_release_resources(
+      this, &LayerTreeHostImpl::ReleaseTreeResources,
+      &LayerTreeHostImpl::RecreateTreeResources);
   renderer_ = nullptr;
   DestroyTileManager();
 
   resource_provider_->InitializeSoftware();
   output_surface_->ReleaseContextProvider();
 
   CreateAndSetRenderer();
   EnforceZeroBudget(true);
   CreateAndSetTileManager();
 
@@ skipping 1286 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc