Converts ash to use aura-mus

ash/aura/wm_window_aura.h

 // Copyright 2016 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 ASH_AURA_WM_WINDOW_AURA_H_
 #define ASH_AURA_WM_WINDOW_AURA_H_
 
 #include "ash/ash_export.h"
 #include "ash/common/wm_window.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "ui/aura/window_observer.h"
 #include "ui/wm/core/transient_window_observer.h"
 
 namespace ash {
 
-// WmWindowAura is tied to the life of the underlying aura::Window.
+// WmWindowAura is tied to the life of the underlying aura::Window. Use the
+// static Get() function to obtain a WmWindowAura from an aura::Window.
 class ASH_EXPORT WmWindowAura : public WmWindow,
                                 public aura::WindowObserver,
                                 public ::wm::TransientWindowObserver {
  public:
-  explicit WmWindowAura(aura::Window* window);
   // NOTE: this class is owned by the corresponding window. You shouldn't delete
   // TODO(sky): friend deleter and make private.
   ~WmWindowAura() override;
 
   // Returns a WmWindow for an aura::Window, creating if necessary. |window| may
   // be null, in which case null is returned.
   static WmWindow* Get(aura::Window* window) {
     return const_cast<WmWindow*>(Get(const_cast<const aura::Window*>(window)));
   }
   static const WmWindow* Get(const aura::Window* window);
@@ skipping 148 matching lines @@
   std::unique_ptr<views::View> CreateViewWithRecreatedLayers() override;
   void AddObserver(WmWindowObserver* observer) override;
   void RemoveObserver(WmWindowObserver* observer) override;
   bool HasObserver(const WmWindowObserver* observer) const override;
   void AddTransientWindowObserver(WmTransientWindowObserver* observer) override;
   void RemoveTransientWindowObserver(
       WmTransientWindowObserver* observer) override;
   void AddLimitedPreTargetHandler(ui::EventHandler* handler) override;
   void RemoveLimitedPreTargetHandler(ui::EventHandler* handler) override;
 
- private:
+ protected:
+  explicit WmWindowAura(aura::Window* window);
+
+  // Returns true if a WmWindowAura has been created for |window|.
+  static bool HasInstance(const aura::Window* window);
+
+  base::ObserverList<WmWindowObserver>& observers() { return observers_; }
+
   // aura::WindowObserver:
   void OnWindowHierarchyChanging(const HierarchyChangeParams& params) override;
   void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override;
   void OnWindowStackingChanged(aura::Window* window) override;
   void OnWindowPropertyChanged(aura::Window* window,
                                const void* key,
                                intptr_t old) override;
   void OnWindowBoundsChanged(aura::Window* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override;
   void OnWindowDestroying(aura::Window* window) override;
   void OnWindowDestroyed(aura::Window* window) override;
   void OnWindowVisibilityChanging(aura::Window* window, bool visible) override;
   void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
   void OnWindowTitleChanged(aura::Window* window) override;
 
   // ::wm::TransientWindowObserver overrides:
   void OnTransientChildAdded(aura::Window* window,
                              aura::Window* transient) override;
   void OnTransientChildRemoved(aura::Window* window,
                                aura::Window* transient) override;
 
+ private:
   aura::Window* window_;
 
   base::ObserverList<WmWindowObserver> observers_;
 
   bool added_transient_observer_ = false;
   base::ObserverList<WmTransientWindowObserver> transient_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(WmWindowAura);
 };
 
 }  // namespace ash
 
 #endif  // ASH_AURA_WM_WINDOW_AURA_H_