Fix stale compositor references from ui::Layer

ui/gfx/compositor/layer.cc

 // Copyright (c) 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 "ui/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 
 namespace {
 
 const float EPSILON = 1e-3f;
 
 bool IsApproximateMultilpleOf(float value, float base) {
   float remainder = fmod(fabs(value), base);
   return remainder < EPSILON || base - remainder < EPSILON;
 }
 
+const ui::Layer* GetRoot(const ui::Layer* layer) {
+  return layer->parent() ? GetRoot(layer->parent()) : layer;
+}
+
 }  // namespace
 
 namespace ui {
 
-Layer::Layer(Compositor* compositor)
+Layer::Layer()
     : type_(LAYER_HAS_TEXTURE),
-      compositor_(compositor),
+      compositor_(NULL),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       recompute_hole_(false),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
 #if defined(USE_WEBKIT_COMPOSITOR)
   CreateWebLayer();
 #endif
 }
 
-Layer::Layer(Compositor* compositor, LayerType type)
+Layer::Layer(LayerType type)
     : type_(type),
-      compositor_(compositor),
+      compositor_(NULL),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       recompute_hole_(false),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
 #if defined(USE_WEBKIT_COMPOSITOR)
   CreateWebLayer();
 #endif
 }
 
 Layer::~Layer() {
+  if (compositor_)
+    compositor_->SetRootLayer(NULL);
   if (parent_)
     parent_->Remove(this);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->parent_ = NULL;
 #if defined(USE_WEBKIT_COMPOSITOR)
   web_layer_.removeFromParent();
 #endif
 }
 
 Compositor* Layer::GetCompositor() {
-  return compositor_ ? compositor_ : parent_ ? parent_->GetCompositor() : NULL;
+  return GetRoot(this)->compositor_;
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
-  // This function must only be called once, with a valid compositor, and only
-  // for the compositor's root layer.
-  DCHECK(!compositor_);
-  DCHECK(compositor);
-  DCHECK_EQ(compositor->root_layer(), this);
+  // This function must only be called to set the compositor on the root layer,
+  // or to reset it.
+  DCHECK(!compositor || !compositor_);
+  DCHECK(!compositor || compositor->root_layer() == this);
+  DCHECK(!parent_);
   compositor_ = compositor;
 }
 
 void Layer::Add(Layer* child) {
+  DCHECK(!child->compositor_);
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
 #if defined(USE_WEBKIT_COMPOSITOR)
   web_layer_.addChild(child->web_layer_);
 #endif
 
   SetNeedsToRecomputeHole();
 }
@@ skipping 125 matching lines @@
       !hole_rect_.Contains(gfx::Rect(gfx::Point(0, 0), bounds_.size()));
 }
 
 // static
 void Layer::ConvertPointToLayer(const Layer* source,
                                 const Layer* target,
                                 gfx::Point* point) {
   if (source == target)
     return;
 
-  const Layer* root_layer = source->compositor()->root_layer();
-  CHECK_EQ(root_layer, target->compositor()->root_layer());
+  const Layer* root_layer = GetRoot(source);
+  CHECK_EQ(root_layer, GetRoot(target));
 
   if (source != root_layer)
     source->ConvertPointForAncestor(root_layer, point);
   if (target != root_layer)
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
@@ skipping 474 matching lines @@
         0,
         0,
         static_cast<float>(bounds_.width())/texture_cc->size().width(),
         static_cast<float>(bounds_.height())/texture_cc->size().height());
     texture_layer.setUVRect(rect);
   }
 }
 #endif
 
 }  // namespace ui