chromeos: converts WindowState to aura::Window

ash/wm_window.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_WM_WINDOW_H_
 #define ASH_WM_WINDOW_H_
 
 #include <memory>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
-#include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/wm/core/transient_window_observer.h"
 #include "ui/wm/core/window_animations.h"
 #include "ui/wm/public/window_types.h"
 
 namespace display {
 class Display;
 }
 
 namespace gfx {
 class Point;
 class Rect;
 class Size;
 class Transform;
 }
 
 namespace ui {
 class EventHandler;
 class Layer;
 }
 
 namespace ash {
 
 class ImmersiveFullscreenController;
 class RootWindowController;
 class WmTransientWindowObserver;
-class WmWindowTestApi;
 enum class WmWindowProperty;
 
 namespace wm {
 class WindowState;
 }
 
 // WmWindow abstracts away differences between ash running in classic mode
 // and ash running with aura-mus.
 //
 // WmWindow is tied to the life of the underlying aura::Window. Use the
 // static Get() function to obtain a WmWindow from an aura::Window.
-class ASH_EXPORT WmWindow : public aura::WindowObserver,
-                            public ::wm::TransientWindowObserver {
+class ASH_EXPORT WmWindow : public ::wm::TransientWindowObserver {
  public:
   // See comments in SetBoundsInScreen().
   enum class BoundsInScreenBehavior {
     USE_LOCAL_COORDINATES,
     USE_SCREEN_COORDINATES,
   };
 
   using Windows = std::vector<WmWindow*>;
 
   // NOTE: this class is owned by the corresponding window. You shouldn't delete
@@ skipping 125 matching lines @@
   void Animate(::wm::WindowAnimationType type);
   void StopAnimatingProperty(
       ui::LayerAnimationElement::AnimatableProperty property);
   void SetChildWindowVisibilityChangesAnimated();
 
   // See description in ui::Layer.
   void SetMasksToBounds(bool value);
   void SetBounds(const gfx::Rect& bounds);
   void SetBoundsWithTransitionDelay(const gfx::Rect& bounds,
                                     base::TimeDelta delta);
-  // Sets the bounds in such a way that LayoutManagers are circumvented.
-  void SetBoundsDirect(const gfx::Rect& bounds);
-  void SetBoundsDirectAnimated(const gfx::Rect& bounds);
-  void SetBoundsDirectCrossFade(const gfx::Rect& bounds);
 
   // Sets the bounds in two distinct ways. The exact behavior is dictated by
   // the value of BoundsInScreenBehavior set on the parent:
   //
   // USE_LOCAL_COORDINATES: the bounds are applied as is to the window. In other
   //   words this behaves the same as if SetBounds(bounds_in_screen) was used.
   //   This is the default.
   // USE_SCREEN_COORDINATES: the bounds are actual screen bounds and converted
   //   from the display. In this case the window may move to a different
   //   display if allowed (see SetLockedToRoot()).
   void SetBoundsInScreen(const gfx::Rect& bounds_in_screen,
                          const display::Display& dst_display);
   gfx::Rect GetBoundsInScreen() const;
   const gfx::Rect& GetBounds() const;
   gfx::Rect GetTargetBounds();
   void ClearRestoreBounds();
   void SetRestoreBoundsInScreen(const gfx::Rect& bounds);
   gfx::Rect GetRestoreBoundsInScreen() const;
 
   bool Contains(const WmWindow* other) const;
 
   void SetShowState(ui::WindowShowState show_state);
   ui::WindowShowState GetShowState() const;
 
   void SetPreFullscreenShowState(ui::WindowShowState show_state);
 
-  // Sets the restore bounds and show state overrides. These values take
-  // precedence over the restore bounds and restore show state (if set).
-  // If |bounds_override| is empty the values are cleared.
-  void SetRestoreOverrides(const gfx::Rect& bounds_override,
-                           ui::WindowShowState window_state_override);
-
   // If |value| is true the window can not be moved to another root, regardless
   // of the bounds set on it.
   void SetLockedToRoot(bool value);
   bool IsLockedToRoot() const;
 
   void SetCapture();
   bool HasCapture();
   void ReleaseCapture();
 
   bool HasRestoreBounds() const;
@@ skipping 63 matching lines @@
   // this window handles the events itself; the handler does not recieve events
   // from embedded windows. This only supports windows with internal widgets;
   // see ash::GetInternalWidgetForWindow(). Ownership of the handler is not
   // transferred.
   //
   // Also note that the target of these events is always an aura::Window.
   void AddLimitedPreTargetHandler(ui::EventHandler* handler);
   void RemoveLimitedPreTargetHandler(ui::EventHandler* handler);
 
  private:
-  friend class WmWindowTestApi;
-
   explicit WmWindow(aura::Window* window);
 
-  // aura::WindowObserver:
-  void OnWindowPropertyChanged(aura::Window* window,
-                               const void* key,
-                               intptr_t old) override;
-
   // ::wm::TransientWindowObserver overrides:
   void OnTransientChildAdded(aura::Window* window,
                              aura::Window* transient) override;
   void OnTransientChildRemoved(aura::Window* window,
                                aura::Window* transient) override;
 
   aura::Window* window_;
 
   bool added_transient_observer_ = false;
   base::ObserverList<WmTransientWindowObserver> transient_observers_;
 
   // If true child windows should get a slightly larger hit region to make
   // resizing easier.
   bool children_use_extended_hit_region_ = false;
 
   // Default value for |use_empty_minimum_size_for_testing_|.
   static bool default_use_empty_minimum_size_for_testing_;
 
   // If true the minimum size is 0x0, default is minimum size comes from widget.
   bool use_empty_minimum_size_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(WmWindow);
 };
 
 }  // namespace ash
 
 #endif  // ASH_WM_WINDOW_H_