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),
       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),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
 #if defined(USE_WEBKIT_COMPOSITOR)
   CreateWebLayer();
 #endif
 }
 
 Layer::~Layer() {
   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;

[sky, 2011/11/15 04:57:04]

Should this be updated to GetRoot(layer)->compositor_ ?

[piman, 2011/11/15 22:06:33]

Originally I didn't want to do that because the compositor might in theory use a
sub-tree as the root (e.g. if we want to screen-shot a window, we may want to do
that). But it doesn't do that today, and we'd need multiple compositors on the
same tree to be able to do that which is far off, so I changed it to that and
added DCHECKs to ensure it's the case.

 }
 
 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);
   compositor_ = compositor;
 }
 
 void Layer::Add(Layer* child) {
   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_);
@@ skipping 126 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 433 matching lines @@
 #else
     unsigned int texture_id = 0;
 #endif
     web_layer_.to<WebKit::WebExternalTextureLayer>().setTextureId(
         should_draw ? texture_id : 0);
   }
 }
 #endif
 
 }  // namespace ui