Animated Rotation

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/logging.h"
+#include "ui/gfx/compositor/layer_observer.h"
 #include "ui/gfx/point3.h"
 
 namespace ui {
 
 Layer::Layer(Compositor* compositor)
     : compositor_(compositor),
       texture_(compositor->CreateTexture()),
       parent_(NULL),
       fills_bounds_opaquely_(false) {
 }
@@ skipping 81 matching lines @@
   if (texture == NULL)
     texture_ = compositor_->CreateTexture();
   else
     texture_ = texture;
 }
 
 void Layer::SetCanvas(const SkCanvas& canvas, const gfx::Point& origin) {
   texture_->SetCanvas(canvas, origin, bounds_.size());
 }
 
+void Layer::AddObserver(LayerObserver* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void Layer::RemoveObserver(LayerObserver* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 void Layer::Draw() {
   ui::TextureDrawParams texture_draw_params;
   for (Layer* layer = this; layer; layer = layer->parent_) {
     texture_draw_params.transform.ConcatTransform(layer->transform_);
     texture_draw_params.transform.ConcatTranslate(
         static_cast<float>(layer->bounds_.x()),
         static_cast<float>(layer->bounds_.y()));
   }
 
   // Only blend for transparent child layers.
@@ skipping 24 matching lines @@
       bounds_.width() - hole_rect_.right(),
       hole_rect_.height()));
 
   // bottom
   DrawRegion(texture_draw_params, gfx::Rect(
       0,
       hole_rect_.bottom(),
       bounds_.width(),
       bounds_.height() - hole_rect_.bottom()));
 #endif
+  FOR_EACH_OBSERVER(LayerObserver, observer_list_, OnDraw(this));
 }
 
 void Layer::DrawRegion(const ui::TextureDrawParams& params,
                        const gfx::Rect& region_to_draw) {
   if (!region_to_draw.IsEmpty())
     texture_->Draw(params, region_to_draw);
 }
 
 void Layer::RecomputeHole() {
   for (size_t i = 0; i < children_.size(); ++i) {
@@ skipping 33 matching lines @@
   for (; p && p != ancestor; p = p->parent()) {
     if (p->transform().HasChange())
       transform->ConcatTransform(p->transform());
     transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
                                static_cast<float>(p->bounds().y()));
   }
   return p == ancestor;
 }
 
 }  // namespace ui