Shuffles and renames ash/common/wm classes

ash/wm/overview/window_selector.h

 // Copyright 2013 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_OVERVIEW_WINDOW_SELECTOR_H_
 #define ASH_WM_OVERVIEW_WINDOW_SELECTOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "ash/ash_export.h"
-#include "ash/common/wm/wm_activation_observer.h"
-#include "ash/common/wm/wm_window_observer.h"
+#include "ash/common/wm_activation_observer.h"
+#include "ash/common/wm_window_observer.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "ui/display/display_observer.h"
 #include "ui/views/controls/textfield/textfield_controller.h"
 
 namespace views {
 class Textfield;
 class Widget;
 }
 
 namespace ash {
 class WindowSelectorDelegate;
 class WindowSelectorItem;
 class WindowSelectorTest;
 class WindowGrid;
 
 // The WindowSelector shows a grid of all of your windows, allowing to select
 // one by clicking or tapping on it.
 class ASH_EXPORT WindowSelector : public display::DisplayObserver,
-                                  public wm::WmWindowObserver,
-                                  public wm::WmActivationObserver,
+                                  public WmWindowObserver,
+                                  public WmActivationObserver,
                                   public views::TextfieldController {
  public:
   // The distance between the top edge of the screen and the bottom edge of
   // the text filtering textfield.
   static const int kTextFilterBottomEdge;
 
   // Returns true if the window can be selected in overview mode.
-  static bool IsSelectable(wm::WmWindow* window);
+  static bool IsSelectable(WmWindow* window);
 
   enum Direction {
     LEFT,
     UP,
     RIGHT,
     DOWN
   };
 
-  using WindowList = std::vector<wm::WmWindow*>;
+  using WindowList = std::vector<WmWindow*>;
 
   explicit WindowSelector(WindowSelectorDelegate* delegate);
   ~WindowSelector() override;
 
   // Initialize with the windows that can be selected.
   void Init(const WindowList& windows);
 
   // Perform cleanup that cannot be done in the destructor.
   void Shutdown();
 
   // Cancels window selection.
   void CancelSelection();
 
   // Called when the last window selector item from a grid is deleted.
   void OnGridEmpty(WindowGrid* grid);
 
   // Activates |window|.
-  void SelectWindow(wm::WmWindow* window);
+  void SelectWindow(WmWindow* window);
 
   bool restoring_minimized_windows() const {
     return restoring_minimized_windows_;
   }
 
   // display::DisplayObserver:
   void OnDisplayAdded(const display::Display& display) override;
   void OnDisplayRemoved(const display::Display& display) override;
   void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t metrics) override;
 
-  // wm::WmWindowObserver:
-  void OnWindowTreeChanged(wm::WmWindow* window,
+  // WmWindowObserver:
+  void OnWindowTreeChanged(WmWindow* window,
                            const TreeChangeParams& params) override;
-  void OnWindowDestroying(wm::WmWindow* window) override;
+  void OnWindowDestroying(WmWindow* window) override;
 
-  // wm::WmActivationObserver
-  void OnWindowActivated(wm::WmWindow* gained_active,
-                         wm::WmWindow* lost_active) override;
-  void OnAttemptToReactivateWindow(wm::WmWindow* request_active,
-                                   wm::WmWindow* actual_active) override;
+  // WmActivationObserver
+  void OnWindowActivated(WmWindow* gained_active,
+                         WmWindow* lost_active) override;
+  void OnAttemptToReactivateWindow(WmWindow* request_active,
+                                   WmWindow* actual_active) override;
 
   // views::TextfieldController:
   void ContentsChanged(views::Textfield* sender,
                        const base::string16& new_contents) override;
   bool HandleKeyEvent(views::Textfield* sender,
                       const ui::KeyEvent& key_event) override;
 
  private:
   friend class WindowSelectorTest;
 
   // Returns the WmWindow for |text_filter_widget_|.
-  wm::WmWindow* GetTextFilterWidgetWindow();
+  WmWindow* GetTextFilterWidgetWindow();
 
   // Position all of the windows in the overview.
   void PositionWindows(bool animate);
 
   // Repositions and resizes |text_filter_widget_| on
   // DisplayMetricsChanged event.
   void RepositionTextFilterOnDisplayMetricsChange();
 
   // |focus|, restores focus to the stored window.
   void ResetFocusRestoreWindow(bool focus);
 
   // Helper function that moves the selection widget to |direction| on the
   // corresponding window grid.
   void Move(Direction direction, bool animate);
 
   // Removes all observers that were registered during construction and/or
   // initialization.
   void RemoveAllObservers();
 
   // Tracks observed windows.
-  std::set<wm::WmWindow*> observed_windows_;
+  std::set<WmWindow*> observed_windows_;
 
   // Weak pointer to the selector delegate which will be called when a
   // selection is made.
   WindowSelectorDelegate* delegate_;
 
   // A weak pointer to the window which was focused on beginning window
   // selection. If window selection is canceled the focus should be restored to
   // this window.
-  wm::WmWindow* restore_focus_window_;
+  WmWindow* restore_focus_window_;
 
   // True when performing operations that may cause window activations. This is
   // used to prevent handling the resulting expected activation.
   bool ignore_activations_;
 
   // List of all the window overview grids, one for each root window.
   std::vector<std::unique_ptr<WindowGrid>> grid_list_;
 
   // Tracks the index of the root window the selection widget is in.
   size_t selected_grid_index_;
@@ skipping 27 matching lines @@
   // Tracks whether minimized windows are currently being restored for overview
   // mode.
   bool restoring_minimized_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSelector);
 };
 
 }  // namespace ash
 
 #endif  // ASH_WM_OVERVIEW_WINDOW_SELECTOR_H_