Revert 107715 - Enable the new layer animation framework.

views/view.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 "views/view.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/base/accessibility/accessibility_types.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
-#include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/point3.h"
 #include "ui/gfx/transform.h"
 #include "views/background.h"
 #include "views/context_menu_controller.h"
 #include "views/drag_controller.h"
+#include "views/layer_property_setter.h"
 #include "views/layout/layout_manager.h"
 #include "views/views_delegate.h"
 #include "views/widget/native_widget_private.h"
 #include "views/widget/native_widget_views.h"
 #include "views/widget/root_view.h"
 #include "views/widget/tooltip_manager.h"
 #include "views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
@@ skipping 378 matching lines @@
 // Transformations -------------------------------------------------------------
 
 const ui::Transform& View::GetTransform() const {
   static const ui::Transform* no_op = new ui::Transform;
   return layer() ? layer()->transform() : *no_op;
 }
 
 void View::SetTransform(const ui::Transform& transform) {
   if (!transform.HasChange()) {
     if (layer()) {
-      layer()->SetTransform(transform);
+      layer_property_setter_->SetTransform(layer(), transform);
       if (!paint_to_layer_)
         DestroyLayer();
     } else {
       // Nothing.
     }
   } else {
     if (!layer())
       CreateLayer();
-    layer()->SetTransform(transform);
+    layer_property_setter_->SetTransform(layer(), transform);
     layer()->ScheduleDraw();
   }
 }
 
 void View::SetPaintToLayer(bool paint_to_layer) {
   paint_to_layer_ = paint_to_layer;
   if (paint_to_layer_ && !layer()) {
     CreateLayer();
   } else if (!paint_to_layer_ && layer()) {
     DestroyLayer();
   }
 }
 
+void View::SetLayerPropertySetter(LayerPropertySetter* setter) {
+  DCHECK(layer());
+  LayerPropertySetter* old_setter = layer_property_setter_.get();
+  if (!layer() || (old_setter && old_setter == setter))
+    return;
+  if (!setter)
+    setter = LayerPropertySetter::CreateDefaultSetter();
+
+  if (old_setter)
+    old_setter->Uninstalled(layer());
+  layer_property_setter_.reset(setter);
+  layer_property_setter_->Installed(layer());
+}
+
 // RTL positioning -------------------------------------------------------------
 
 gfx::Rect View::GetMirroredBounds() const {
   gfx::Rect bounds(bounds_);
   bounds.set_x(GetMirroredX());
   return bounds;
 }
 
 gfx::Point View::GetMirroredPosition() const {
   return gfx::Point(GetMirroredX(), y());
@@ skipping 676 matching lines @@
   if (layer()) {
     layer()->SetVisible(ancestor_visible && IsVisible());
   } else {
     for (int i = 0, count = child_count(); i < count; ++i)
       child_at(i)->UpdateChildLayerVisibility(ancestor_visible && IsVisible());
   }
 }
 
 void View::UpdateChildLayerBounds(const gfx::Point& offset) {
   if (layer()) {
-    layer()->SetBounds(gfx::Rect(offset.x(), offset.y(), width(), height()));
+    layer_property_setter_->SetBounds(layer(), gfx::Rect(offset.x(), offset.y(),
+                                                         width(), height()));
   } else {
     for (int i = 0, count = child_count(); i < count; ++i) {
       gfx::Point new_offset(offset.x() + child_at(i)->x(),
                             offset.y() + child_at(i)->y());
       child_at(i)->UpdateChildLayerBounds(new_offset);
     }
   }
 }
 
 void View::OnPaintLayer(gfx::Canvas* canvas) {
   if (!layer() || !layer()->fills_bounds_opaquely())
     canvas->GetSkCanvas()->drawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
   PaintCommon(canvas);
 }
 
-void View::OnLayerAnimationEnded(const ui::LayerAnimationSequence* animation) {
+void View::OnLayerAnimationEnded(const ui::Animation* animation) {
 }
 
 void View::ReorderLayers() {
   View* v = this;
   while (v && !v->layer())
     v = v->parent();
 
   // Forward to widget in case we're in a NativeWidgetView.
   if (!v) {
     if (GetWidget())
@@ skipping 404 matching lines @@
         bounds_.size() == previous_bounds.size() ? SCHEDULE_PAINT_SIZE_SAME :
         SCHEDULE_PAINT_SIZE_CHANGED);
   }
 
   if (use_acceleration_when_possible) {
     if (layer()) {
       if (parent_) {
         gfx::Point offset;
         parent_->CalculateOffsetToAncestorWithLayer(&offset, NULL);
         offset.Offset(x(), y());
-        layer()->SetBounds(gfx::Rect(offset, size()));
+        layer_property_setter_->SetBounds(layer(), gfx::Rect(offset, size()));
       } else {
-        layer()->SetBounds(bounds_);
+        layer_property_setter_->SetBounds(layer(), bounds_);
       }
       // TODO(beng): this seems redundant with the SchedulePaint at the top of
       //             this function. explore collapsing.
       if (previous_bounds.size() != bounds_.size() &&
           !layer()->layer_updated_externally()) {
         // If our bounds have changed then we need to update the complete
         // texture.
         layer()->SchedulePaint(GetLocalBounds());
       }
     } else {
@@ skipping 163 matching lines @@
 // Accelerated painting --------------------------------------------------------
 
 void View::CreateLayer() {
   // A new layer is being created for the view. So all the layers of the
   // sub-tree can inherit the visibility of the corresponding view.
   for (int i = 0, count = child_count(); i < count; ++i)
     child_at(i)->UpdateChildLayerVisibility(true);
 
   layer_.reset(new ui::Layer(NULL));
   layer_->set_delegate(this);
+  if (layer_property_setter_.get())
+    layer_property_setter_->Installed(layer());
+  else
+    SetLayerPropertySetter(NULL);
 
   UpdateParentLayers();
   UpdateLayerVisibility();
 
   // The new layer needs to be ordered in the layer tree according
   // to the view tree. Children of this layer were added in order
   // in UpdateParentLayers().
   if (parent())
     parent()->ReorderLayers();
 }
@@ skipping 50 matching lines @@
 
 void View::DestroyLayer() {
   ui::Layer* new_parent = layer()->parent();
   std::vector<ui::Layer*> children = layer()->children();
   for (size_t i = 0; i < children.size(); ++i) {
     layer()->Remove(children[i]);
     if (new_parent)
       new_parent->Add(children[i]);
   }
 
+  if (layer_property_setter_.get())
+    layer_property_setter_->Uninstalled(layer());
+
   layer_.reset();
 
   if (new_parent)
     ReorderLayers();
 
   gfx::Point offset;
   CalculateOffsetToAncestorWithLayer(&offset, NULL);
   UpdateChildLayerBounds(offset);
 
   SchedulePaint();
@@ skipping 203 matching lines @@
 
   OSExchangeData data;
   WriteDragData(press_pt, &data);
 
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   GetWidget()->RunShellDrag(this, data, drag_operations);
 }
 
 }  // namespace views