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.
 class ASH_EXPORT WmWindowAura : public WmWindow,

[James Cook, 2016/12/05 17:21:48]

Please add a comment here that these are only allowed in "classic ash" /
"non-aura-mus". Things are going to be temporarily confusing while there are two
aura impls.

[sky, 2016/12/05 17:56:55]

The truth is you can actually use this class in aura-mus. WmWindowAura::Get()
returns an WmWindowMus when in aura-mus. So, it's ok to call
WmWindowAura::Get(). I made the constructor protected to ensure no one is
creating directly.

                                 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.
@@ skipping 152 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:
+  // 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_