Transfer LayerImpl ownership to LayerTreeImpl

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1179 matching lines @@
 void LayerTreeHostImpl::EvictTexturesForTesting() {
   UpdateTileManagerMemoryPolicy(ManagedMemoryPolicy(0));
 }
 
 void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
   NOTREACHED();
 }
 
 void LayerTreeHostImpl::ResetTreesForTesting() {
   if (active_tree_)
-    active_tree_->DetachLayerTree();
+    active_tree_->ClearLayers();
   active_tree_ =
       LayerTreeImpl::create(this, active_tree()->page_scale_factor(),
                             active_tree()->top_controls_shown_ratio(),
                             active_tree()->elastic_overscroll());
   active_tree_->property_trees()->is_active = true;
   if (pending_tree_)
-    pending_tree_->DetachLayerTree();
+    pending_tree_->ClearLayers();
   pending_tree_ = nullptr;
   if (recycle_tree_)
-    recycle_tree_->DetachLayerTree();
+    recycle_tree_->ClearLayers();
   recycle_tree_ = nullptr;
 }
 
 size_t LayerTreeHostImpl::SourceAnimationFrameNumberForTesting() const {
   return fps_counter_->current_frame_number();
 }
 
 void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
   if (!resource_pool_)
@@ skipping 729 matching lines @@
 void LayerTreeHostImpl::ActivateSyncTree() {
   if (pending_tree_) {
     TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
 
     // Process any requests in the UI resource queue.  The request queue is
     // given in LayerTreeHost::FinishCommitOnImplThread.  This must take place
     // before the swap.
     pending_tree_->ProcessUIResourceRequestQueue();
 
     if (pending_tree_->needs_full_tree_sync()) {
-      active_tree_->SetRootLayer(
-          TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
-                                             active_tree_->DetachLayerTree(),
-                                             active_tree_.get()));
+      TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
+                                         active_tree_.get());
     }
+
     // We need to preserve the damage status of property trees on active tree.
     // We do this by pushing the damage status from active tree property trees
     // to pending tree property trees.
     if (active_tree_->property_trees()->changed) {
       if (pending_tree_->property_trees()->sequence_number ==
           active_tree_->property_trees()->sequence_number)
         active_tree_->property_trees()->PushChangeTrackingTo(
             pending_tree_->property_trees());
       else
         active_tree_->root_layer()->PushLayerPropertyChangedForSubtree();
@@ skipping 1947 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc