Remove Views dependency from window_animations.cc

ui/views/corewm/window_animations.cc

 // Copyright (c) 2012 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/views/corewm/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 17 matching lines @@
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/vector2d.h"
 #include "ui/gfx/vector3d_f.h"
 #include "ui/views/corewm/corewm_switches.h"
 #include "ui/views/corewm/window_util.h"
-#include "ui/views/view.h"
-#include "ui/views/widget/widget.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(int)
 DECLARE_WINDOW_PROPERTY_TYPE(views::corewm::WindowVisibilityAnimationType)
 DECLARE_WINDOW_PROPERTY_TYPE(views::corewm::WindowVisibilityAnimationTransition)
 DECLARE_WINDOW_PROPERTY_TYPE(float)
 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(VIEWS_EXPORT, bool)
 
 using aura::Window;
 using base::TimeDelta;
 using ui::Layer;
@@ skipping 93 matching lines @@
         animation_host->OnWindowHidingAnimationCompleted();
       window_->RemoveObserver(this);
     }
     delete this;
   }
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
     DCHECK_EQ(window, window_);
     DCHECK(layers_.empty());
-    AcquireAllLayers(window_);
-
-    // If the Widget has views with layers, then it is necessary to take
-    // ownership of those layers too.
-    views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window_);
-    const views::Widget* const_widget = widget;
-    if (widget && const_widget->GetRootView() && widget->GetContentsView())
-      AcquireAllViewLayers(widget->GetContentsView());
+    AcquireAllLayers(window_->layer());
     window_->RemoveObserver(this);
     window_ = NULL;
   }
 
-  void AcquireAllLayers(aura::Window* window) {
-    ui::Layer* layer = window->AcquireLayer();
-    DCHECK(layer);
-    layers_.push_back(layer);
-    for (aura::Window::Windows::const_iterator it = window->children().begin();
-         it != window->children().end();
-         ++it)
+  void AcquireAllLayers(ui::Layer* layer) {
+    if (layer->owner()) {
+      ui::Layer* released = layer->owner()->AcquireLayer();
+      DCHECK_EQ(layer, released);
+      layers_.push_back(released);
+    }
+    std::vector<Layer*>::const_iterator it = layer->children().begin();
+    for (; it != layer->children().end(); ++it)
       AcquireAllLayers(*it);
   }
 
-  void AcquireAllViewLayers(views::View* view) {
-    for (int i = 0; i < view->child_count(); ++i)
-      AcquireAllViewLayers(view->child_at(i));
-    if (view->layer()) {
-      ui::Layer* layer = view->RecreateLayer();
-      if (layer) {
-        layer->SuppressPaint();
-        layers_.push_back(layer);
-      }
-    }
-  }
-
   aura::Window* window_;
   std::vector<ui::Layer*> layers_;
 
   DISALLOW_COPY_AND_ASSIGN(HidingWindowAnimationObserver);
 };
 
 void GetTransformRelativeToRoot(ui::Layer* layer, gfx::Transform* transform) {
   const Layer* root = layer;
   while (root->parent())
     root = root->parent();
@@ skipping 372 matching lines @@
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (!gfx::Animation::ShouldRenderRichAnimation() || (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled));
 }
 
 }  // namespace corewm
 }  // namespace views