cc: Split ReleaseResources into Release and Recreate.

cc/trees/layer_tree_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_impl.h"
 
 #include <limits>
 #include <set>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 104 matching lines @@
   DCHECK(!root_layer_);
   DCHECK(layers_with_copy_output_request_.empty());
 }
 
 void LayerTreeImpl::Shutdown() {
   root_layer_ = nullptr;
 }
 
 void LayerTreeImpl::ReleaseResources() {
   if (root_layer_)
-    ReleaseResourcesRecursive(root_layer_.get());
+    ProcessLayersRecursive(root_layer_.get(), &LayerImpl::ReleaseResources);
+}
+
+void LayerTreeImpl::RecreateResources() {
+  if (root_layer_)
+    ProcessLayersRecursive(root_layer_.get(), &LayerImpl::RecreateResources);
 }
 
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   if (inner_viewport_scroll_layer_)
     inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   if (outer_viewport_scroll_layer_)
     outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   inner_viewport_scroll_delegate_proxy_ = nullptr;
   outer_viewport_scroll_delegate_proxy_ = nullptr;
 
@@ skipping 1016 matching lines @@
 
 const std::vector<LayerImpl*>& LayerTreeImpl::LayersWithCopyOutputRequest()
     const {
   // Only the active tree needs to know about layers with copy requests, as
   // they are aborted if not serviced during draw.
   DCHECK(IsActiveTree());
 
   return layers_with_copy_output_request_;
 }
 
-void LayerTreeImpl::ReleaseResourcesRecursive(LayerImpl* current) {
+void LayerTreeImpl::ProcessLayersRecursive(LayerImpl* current,
+                                           void (LayerImpl::*function)()) {
   DCHECK(current);
-  current->ReleaseResources();
+  (current->*function)();
   if (current->mask_layer())
-    ReleaseResourcesRecursive(current->mask_layer());
+    ProcessLayersRecursive(current->mask_layer(), function);
   if (current->replica_layer())
-    ReleaseResourcesRecursive(current->replica_layer());
+    ProcessLayersRecursive(current->replica_layer(), function);
   for (size_t i = 0; i < current->children().size(); ++i)
-    ReleaseResourcesRecursive(current->children()[i]);
+    ProcessLayersRecursive(current->children()[i], function);
 }
 
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 static bool PointHitsRect(
     const gfx::PointF& screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
@@ skipping 369 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc