layers: Consolidate the ownership of layers in views::View and aura::Window.

ui/aura/window.h

 // 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.
 
 #ifndef UI_AURA_WINDOW_H_
 #define UI_AURA_WINDOW_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/string16.h"
 #include "ui/aura/aura_export.h"
 #include "ui/aura/client/window_types.h"
 #include "ui/base/events.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/layer_delegate.h"
+#include "ui/compositor/layer_owner.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/rect.h"
 
 class SkCanvas;
 
 namespace ui {
 class Layer;
 class Texture;
@@ skipping 13 matching lines @@
 }
 
 // Defined in window_property.h (which we do not include)
 template<typename T>
 struct WindowProperty;
 
 // Aura window implementation. Interesting events are sent to the
 // WindowDelegate.
 // TODO(beng): resolve ownership.
 class AURA_EXPORT Window : public ui::LayerDelegate,
+                           public ui::LayerOwner,
                            public ui::GestureConsumer {
  public:
   typedef std::vector<Window*> Windows;
 
   class AURA_EXPORT TestApi {
    public:
     explicit TestApi(Window* window);
 
     bool OwnsLayer() const;
 
@@ skipping 26 matching lines @@
 
   const std::string& name() const { return name_; }
   void SetName(const std::string& name);
 
   const string16 title() const { return title_; }
   void set_title(const string16& title) { title_ = title; }
 
   bool transparent() const { return transparent_; }
   void SetTransparent(bool transparent);
 
-  ui::Layer* layer() { return layer_; }
-  const ui::Layer* layer() const { return layer_; }
-
-  // Releases the Window's owning reference to its layer, and returns it.
-  // This is used when you need to animate the presentation of the Window just
-  // prior to destroying it. The window can be destroyed soon after calling this
-  // function, and the caller is then responsible for disposing of the layer
-  // once any animation completes. Note that layer() will remain valid until the
-  // end of ~Window().
-  ui::Layer* AcquireLayer();
-
   WindowDelegate* delegate() { return delegate_; }
 
   const gfx::Rect& bounds() const;
 
   Window* parent() { return parent_; }
   const Window* parent() const { return parent_; }
 
   // Returns the RootWindow that contains this Window or NULL if the Window is
   // not contained by a RootWindow.
   virtual RootWindow* GetRootWindow();
@@ skipping 284 matching lines @@
 #endif
 
   client::WindowType type_;
 
   // True if the Window is owned by its parent - i.e. it will be deleted by its
   // parent during its parents destruction. True is the default.
   bool owned_by_parent_;
 
   WindowDelegate* delegate_;
 
-  // The Window will own its layer unless ownership is relinquished via a call
-  // to AcquireLayer(). After that moment |layer_| will still be valid but
-  // |layer_owner_| will be NULL. The reason for releasing ownership is that
-  // the client may wish to animate the window's layer beyond the lifetime of
-  // the window, e.g. fading it out when it is destroyed.
-  scoped_ptr<ui::Layer> layer_owner_;
-  ui::Layer* layer_;
-
   // The Window's parent.
   Window* parent_;
 
   // Child windows. Topmost is last.
   Windows children_;
 
   // Transient windows.
   Windows transient_children_;
 
   Window* transient_parent_;
@@ skipping 35 matching lines @@
   };
 
   std::map<const void*, Value> prop_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_WINDOW_H_