Shuffles and renames ash/common/wm classes

ash/common/wm/workspace/multi_window_resize_controller.cc

 // 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.
 
 #include "ash/common/wm/workspace/multi_window_resize_controller.h"
 
 #include "ash/common/shell_window_ids.h"
-#include "ash/common/wm/wm_lookup.h"
-#include "ash/common/wm/wm_root_window_controller.h"
-#include "ash/common/wm/wm_window.h"
 #include "ash/common/wm/workspace/workspace_window_resizer.h"
+#include "ash/common/wm_lookup.h"
+#include "ash/common/wm_root_window_controller.h"
+#include "ash/common/wm_window.h"
 #include "grit/ash_resources.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/compound_event_filter.h"
 
 namespace ash {
 namespace {
 
 // Delay before showing.
 const int kShowDelayMS = 400;
 
 // Delay before hiding.
 const int kHideDelayMS = 500;
 
 // Padding from the bottom/right edge the resize widget is shown at.
 const int kResizeWidgetPadding = 15;
 
-bool ContainsX(wm::WmWindow* window, int x) {
+bool ContainsX(WmWindow* window, int x) {
   return x >= 0 && x <= window->GetBounds().width();
 }
 
-bool ContainsScreenX(wm::WmWindow* window, int x_in_screen) {
+bool ContainsScreenX(WmWindow* window, int x_in_screen) {
   gfx::Point window_loc =
       window->ConvertPointFromScreen(gfx::Point(x_in_screen, 0));
   return ContainsX(window, window_loc.x());
 }
 
-bool ContainsY(wm::WmWindow* window, int y) {
+bool ContainsY(WmWindow* window, int y) {
   return y >= 0 && y <= window->GetBounds().height();
 }
 
-bool ContainsScreenY(wm::WmWindow* window, int y_in_screen) {
+bool ContainsScreenY(WmWindow* window, int y_in_screen) {
   gfx::Point window_loc =
       window->ConvertPointFromScreen(gfx::Point(0, y_in_screen));
   return ContainsY(window, window_loc.y());
 }
 
 bool Intersects(int x1, int max_1, int x2, int max_2) {
   return x2 <= max_1 && max_2 > x1;
 }
 
 }  // namespace
@@ skipping 81 matching lines @@
          direction == other.direction;
 }
 
 MultiWindowResizeController::MultiWindowResizeController() {}
 
 MultiWindowResizeController::~MultiWindowResizeController() {
   window_resizer_.reset();
   Hide();
 }
 
-void MultiWindowResizeController::Show(wm::WmWindow* window,
+void MultiWindowResizeController::Show(WmWindow* window,
                                        int component,
                                        const gfx::Point& point_in_window) {
   // When the resize widget is showing we ignore Show() requests. Instead we
   // only care about mouse movements from MouseWatcher. This is necessary as
   // WorkspaceEventHandler only sees mouse movements over the windows, not all
   // windows or over the desktop.
   if (resize_widget_)
     return;
 
   ResizeWindows windows(DetermineWindows(window, component, point_in_window));
@@ skipping 38 matching lines @@
     windows_.other_windows[i]->RemoveObserver(this);
   mouse_watcher_.reset();
   resize_widget_.reset();
   windows_ = ResizeWindows();
 }
 
 void MultiWindowResizeController::MouseMovedOutOfHost() {
   Hide();
 }
 
-void MultiWindowResizeController::OnWindowDestroying(wm::WmWindow* window) {
+void MultiWindowResizeController::OnWindowDestroying(WmWindow* window) {
   // Have to explicitly reset the WindowResizer, otherwise Hide() does nothing.
   window_resizer_.reset();
   Hide();
 }
 
 MultiWindowResizeController::ResizeWindows
 MultiWindowResizeController::DetermineWindowsFromScreenPoint(
-    wm::WmWindow* window) const {
+    WmWindow* window) const {
   gfx::Point mouse_location(
       display::Screen::GetScreen()->GetCursorScreenPoint());
   mouse_location = window->ConvertPointFromScreen(mouse_location);
   const int component = window->GetNonClientComponent(mouse_location);
   return DetermineWindows(window, component, mouse_location);
 }
 
 void MultiWindowResizeController::CreateMouseWatcher() {
   mouse_watcher_.reset(
       new views::MouseWatcher(new ResizeMouseWatcherHost(this), this));
   mouse_watcher_->set_notify_on_exit_time(
       base::TimeDelta::FromMilliseconds(kHideDelayMS));
   mouse_watcher_->Start();
 }
 
 MultiWindowResizeController::ResizeWindows
-MultiWindowResizeController::DetermineWindows(wm::WmWindow* window,
+MultiWindowResizeController::DetermineWindows(WmWindow* window,
                                               int window_component,
                                               const gfx::Point& point) const {
   ResizeWindows result;
   gfx::Point point_in_parent =
       window->ConvertPointToTarget(window->GetParent(), point);
   switch (window_component) {
     case HTRIGHT:
       result.direction = LEFT_RIGHT;
       result.window1 = window;
       result.window2 = FindWindowByEdge(
@@ skipping 16 matching lines @@
       result.window1 = window;
       result.window2 = FindWindowByEdge(window, HTTOP, point_in_parent.x(),
                                         window->GetBounds().bottom());
       break;
     default:
       break;
   }
   return result;
 }
 
-wm::WmWindow* MultiWindowResizeController::FindWindowByEdge(
-    wm::WmWindow* window_to_ignore,
+WmWindow* MultiWindowResizeController::FindWindowByEdge(
+    WmWindow* window_to_ignore,
     int edge_want,
     int x_in_parent,
     int y_in_parent) const {
-  wm::WmWindow* parent = window_to_ignore->GetParent();
-  std::vector<wm::WmWindow*> windows = parent->GetChildren();
+  WmWindow* parent = window_to_ignore->GetParent();
+  std::vector<WmWindow*> windows = parent->GetChildren();
   for (auto i = windows.rbegin(); i != windows.rend(); ++i) {
-    wm::WmWindow* window = *i;
+    WmWindow* window = *i;
     if (window == window_to_ignore || !window->IsVisible())
       continue;
 
     // Ignore windows without a non-client area.
     if (!window->HasNonClientArea())
       continue;
 
     gfx::Point p = parent->ConvertPointToTarget(
         window, gfx::Point(x_in_parent, y_in_parent));
     switch (edge_want) {
@@ skipping 17 matching lines @@
         NOTREACHED();
     }
     // Window doesn't contain the edge, but if window contains |point|
     // it's obscuring any other window that could be at the location.
     if (window->GetBounds().Contains(x_in_parent, y_in_parent))
       return NULL;
   }
   return NULL;
 }
 
-wm::WmWindow* MultiWindowResizeController::FindWindowTouching(
-    wm::WmWindow* window,
+WmWindow* MultiWindowResizeController::FindWindowTouching(
+    WmWindow* window,
     Direction direction) const {
   int right = window->GetBounds().right();
   int bottom = window->GetBounds().bottom();
-  wm::WmWindow* parent = window->GetParent();
-  std::vector<wm::WmWindow*> windows = parent->GetChildren();
+  WmWindow* parent = window->GetParent();
+  std::vector<WmWindow*> windows = parent->GetChildren();
   for (auto i = windows.rbegin(); i != windows.rend(); ++i) {
-    wm::WmWindow* other = *i;
+    WmWindow* other = *i;
     if (other == window || !other->IsVisible())
       continue;
     switch (direction) {
       case TOP_BOTTOM:
         if (other->GetBounds().y() == bottom &&
             Intersects(other->GetBounds().x(), other->GetBounds().right(),
                        window->GetBounds().x(), window->GetBounds().right())) {
           return other;
         }
         break;
       case LEFT_RIGHT:
         if (other->GetBounds().x() == right &&
             Intersects(other->GetBounds().y(), other->GetBounds().bottom(),
                        window->GetBounds().y(), window->GetBounds().bottom())) {
           return other;
         }
         break;
       default:
         NOTREACHED();
     }
   }
   return NULL;
 }
 
 void MultiWindowResizeController::FindWindowsTouching(
-    wm::WmWindow* start,
+    WmWindow* start,
     Direction direction,
-    std::vector<wm::WmWindow*>* others) const {
+    std::vector<WmWindow*>* others) const {
   while (start) {
     start = FindWindowTouching(start, direction);
     if (start)
       others->push_back(start);
   }
 }
 
 void MultiWindowResizeController::ShowIfValidMouseLocation() {
   if (DetermineWindowsFromScreenPoint(windows_.window1).Equals(windows_) ||
       DetermineWindowsFromScreenPoint(windows_.window2).Equals(windows_)) {
@@ skipping 11 matching lines @@
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.name = "MultiWindowResizeController";
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   windows_.window1->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           resize_widget_.get(), kShellWindowId_AlwaysOnTopContainer, &params);
   ResizeView* view = new ResizeView(this, windows_.direction);
   resize_widget_->set_focus_on_creation(false);
   resize_widget_->Init(params);
-  wm::WmLookup::Get()
+  WmLookup::Get()
       ->GetWindowForWidget(resize_widget_.get())
       ->SetVisibilityAnimationType(::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   resize_widget_->SetContentsView(view);
   show_bounds_in_screen_ = windows_.window1->GetParent()->ConvertRectToScreen(
       CalculateResizeWidgetBounds(show_location_in_parent_));
   resize_widget_->SetBounds(show_bounds_in_screen_);
   resize_widget_->Show();
   CreateMouseWatcher();
 }
 
 bool MultiWindowResizeController::IsShowing() const {
   return resize_widget_.get() || show_timer_.IsRunning();
 }
 
 void MultiWindowResizeController::StartResize(
     const gfx::Point& location_in_screen) {
   DCHECK(!window_resizer_.get());
   DCHECK(windows_.is_valid());
   gfx::Point location_in_parent =
       windows_.window2->GetParent()->ConvertPointFromScreen(location_in_screen);
-  std::vector<wm::WmWindow*> windows;
+  std::vector<WmWindow*> windows;
   windows.push_back(windows_.window2);
   DCHECK(windows_.other_windows.empty());
   FindWindowsTouching(windows_.window2, windows_.direction,
                       &windows_.other_windows);
   for (size_t i = 0; i < windows_.other_windows.size(); ++i) {
     windows_.other_windows[i]->AddObserver(this);
     windows.push_back(windows_.other_windows[i]);
   }
   int component = windows_.direction == LEFT_RIGHT ? HTRIGHT : HTBOTTOM;
   wm::WindowState* window_state = windows_.window1->GetWindowState();
@@ skipping 90 matching lines @@
   } else {
     if (!ContainsScreenY(windows_.window1, location_in_screen.y()) ||
         !ContainsScreenY(windows_.window2, location_in_screen.y())) {
       return false;
     }
   }
 
   // Check whether |location_in_screen| is in the event target's resize region.
   // This is tricky because a window's resize region can extend outside a
   // window's bounds.
-  wm::WmWindow* target =
+  WmWindow* target =
       windows_.window1->GetRootWindowController()->FindEventTarget(
           location_in_screen);
   if (target == windows_.window1) {
     return IsOverComponent(
         windows_.window1, location_in_screen,
         windows_.direction == TOP_BOTTOM ? HTBOTTOM : HTRIGHT);
   }
   if (target == windows_.window2) {
     return IsOverComponent(windows_.window2, location_in_screen,
                            windows_.direction == TOP_BOTTOM ? HTTOP : HTLEFT);
   }
   return false;
 }
 
 bool MultiWindowResizeController::IsOverComponent(
-    wm::WmWindow* window,
+    WmWindow* window,
     const gfx::Point& location_in_screen,
     int component) const {
   gfx::Point window_loc = window->ConvertPointFromScreen(location_in_screen);
   return window->GetNonClientComponent(window_loc) == component;
 }
 
 }  // namespace ash