Shuffles and renames ash/common/wm classes

ash/wm/overview/window_selector_item.cc

 // 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.
 
 #include "ash/wm/overview/window_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/window_state.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/wm_window_property.h"
+#include "ash/common/wm_lookup.h"
+#include "ash/common/wm_root_window_controller.h"
+#include "ash/common/wm_window.h"
+#include "ash/common/wm_window_property.h"
 #include "ash/material_design/material_design_controller.h"
 #include "ash/wm/overview/overview_animation_type.h"
 #include "ash/wm/overview/scoped_overview_animation_settings.h"
 #include "ash/wm/overview/scoped_overview_animation_settings_factory.h"
 #include "ash/wm/overview/scoped_transform_overview_window.h"
 #include "ash/wm/overview/window_selector.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "base/auto_reset.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 39 matching lines @@
 
 // Amount of blur applied to the label shadow
 static const int kShadowBlur = 10;
 
 // Opacity for dimmed items.
 static const float kDimmedItemOpacity = 0.5f;
 
 // Calculates the |window| bounds after being transformed to the selector's
 // space. With Material Design at most |title_height| is reserved above the
 // |window|. The returned Rect is in virtual screen coordinates.
-gfx::Rect GetTransformedBounds(wm::WmWindow* window, int title_height) {
+gfx::Rect GetTransformedBounds(WmWindow* window, int title_height) {
   gfx::RectF bounds(
       window->GetRootWindow()->ConvertRectToScreen(window->GetTargetBounds()));
   gfx::Transform new_transform = TransformAboutPivot(
       gfx::Point(bounds.x(), bounds.y()), window->GetTargetTransform());
   new_transform.TransformRect(&bounds);
 
   // With Material Design the preview title is shown above the preview window.
   // Hide the window header for apps or browser windows with no tabs (web apps)
   // to avoid showing both the window header and the preview title.
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     gfx::RectF header_bounds(bounds);
     header_bounds.set_height(
-        std::min(window->GetIntProperty(wm::WmWindowProperty::TOP_VIEW_INSET),
+        std::min(window->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET),
                  title_height));
     new_transform.TransformRect(&header_bounds);
     bounds.Inset(0, header_bounds.height(), 0, 0);
   }
   return ToEnclosingRect(bounds);
 }
 
 // Convenience method to fade in a Window with predefined animation settings.
 // Note: The fade in animation will occur after a delay where the delay is how
 // long the lay out animations take.
 void SetupFadeInAfterLayout(views::Widget* widget) {
-  wm::WmWindow* window = wm::WmLookup::Get()->GetWindowForWidget(widget);
+  WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget);
   window->SetOpacity(0.0f);
   std::unique_ptr<ScopedOverviewAnimationSettings>
       scoped_overview_animation_settings =
           ScopedOverviewAnimationSettingsFactory::Get()
               ->CreateOverviewAnimationSettings(
                   OverviewAnimationType::
                       OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN,
                   window);
   window->SetOpacity(1.0f);
 }
@@ skipping 36 matching lines @@
 
 gfx::Rect WindowSelectorItem::OverviewLabelButton::GetChildAreaBounds() {
   gfx::Rect bounds = GetLocalBounds();
   if (ash::MaterialDesignController::IsOverviewMaterial())
     bounds.Inset(kHorizontalLabelPaddingMD, 0, kHorizontalLabelPaddingMD, 0);
   else
     bounds.Inset(0, top_padding_, 0, 0);
   return bounds;
 }
 
-WindowSelectorItem::WindowSelectorItem(wm::WmWindow* window,
+WindowSelectorItem::WindowSelectorItem(WmWindow* window,
                                        WindowSelector* window_selector)
     : dimmed_(false),
       root_window_(window->GetRootWindow()),
       transform_window_(window),
       in_bounds_update_(false),
       window_label_button_view_(nullptr),
       close_button_(new OverviewCloseButton(this)),
       window_selector_(window_selector) {
   const bool material = ash::MaterialDesignController::IsOverviewMaterial();
   CreateWindowLabel(window->GetTitle());
@@ skipping 15 matching lines @@
   // Align the center of the button with position (0, 0) so that the
   // translate transform does not need to take the button dimensions into
   // account.
   if (material) {
     close_button_rect.set_x(-close_button_rect.width());
     close_button_rect.set_y(-close_button_rect.height());
   } else {
     close_button_rect.set_x(-close_button_rect.width() / 2);
     close_button_rect.set_y(-close_button_rect.height() / 2);
   }
-  wm::WmLookup::Get()
+  WmLookup::Get()
       ->GetWindowForWidget(&close_button_widget_)
       ->SetBounds(close_button_rect);
 
   GetWindow()->AddObserver(this);
 }
 
 WindowSelectorItem::~WindowSelectorItem() {
   GetWindow()->RemoveObserver(this);
 }
 
-wm::WmWindow* WindowSelectorItem::GetWindow() {
+WmWindow* WindowSelectorItem::GetWindow() {
   return transform_window_.window();
 }
 
 void WindowSelectorItem::RestoreWindow() {
   transform_window_.RestoreWindow();
 }
 
 void WindowSelectorItem::ShowWindowOnExit() {
   transform_window_.ShowWindowOnExit();
 }
 
 void WindowSelectorItem::PrepareForOverview() {
   transform_window_.PrepareForOverview();
 }
 
-bool WindowSelectorItem::Contains(const wm::WmWindow* target) const {
+bool WindowSelectorItem::Contains(const WmWindow* target) const {
   return transform_window_.Contains(target);
 }
 
 void WindowSelectorItem::SetBounds(const gfx::Rect& target_bounds,
                                    OverviewAnimationType animation_type) {
   if (in_bounds_update_)
     return;
   base::AutoReset<bool> auto_reset_in_bounds_update(&in_bounds_update_, true);
   target_bounds_ = target_bounds;
 
@@ skipping 37 matching lines @@
 void WindowSelectorItem::ButtonPressed(views::Button* sender,
                                        const ui::Event& event) {
   if (sender == close_button_) {
     transform_window_.Close();
     return;
   }
   CHECK(sender == window_label_button_view_);
   window_selector_->SelectWindow(transform_window_.window());
 }
 
-void WindowSelectorItem::OnWindowDestroying(wm::WmWindow* window) {
+void WindowSelectorItem::OnWindowDestroying(WmWindow* window) {
   window->RemoveObserver(this);
   transform_window_.OnWindowDestroyed();
 }
 
-void WindowSelectorItem::OnWindowTitleChanged(wm::WmWindow* window) {
+void WindowSelectorItem::OnWindowTitleChanged(WmWindow* window) {
   // TODO(flackr): Maybe add the new title to a vector of titles so that we can
   // filter any of the titles the window had while in the overview session.
   window_label_button_view_->SetText(window->GetTitle());
   UpdateCloseButtonAccessibilityName();
 }
 
 void WindowSelectorItem::SetItemBounds(const gfx::Rect& target_bounds,
                                        OverviewAnimationType animation_type) {
   DCHECK(root_window_ == GetWindow()->GetRootWindow());
   gfx::Rect screen_rect = transform_window_.GetTargetBoundsInScreen();
 
   // Avoid division by zero by ensuring screen bounds is not empty.
   gfx::Size screen_size(screen_rect.size());
   screen_size.SetToMax(gfx::Size(1, 1));
   screen_rect.set_size(screen_size);
 
   int top_view_inset = 0;
   int title_height = 0;
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     top_view_inset =
-        GetWindow()->GetIntProperty(wm::WmWindowProperty::TOP_VIEW_INSET);
+        GetWindow()->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET);
     title_height = close_button_->GetPreferredSize().height();
   }
   gfx::Rect selector_item_bounds =
       ScopedTransformOverviewWindow::ShrinkRectToFitPreservingAspectRatio(
           screen_rect, target_bounds, top_view_inset, title_height);
   gfx::Transform transform = ScopedTransformOverviewWindow::GetTransformForRect(
       screen_rect, selector_item_bounds);
   ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
   transform_window_.BeginScopedAnimation(animation_type, &animation_settings);
   transform_window_.SetTransform(root_window_, transform);
@@ skipping 15 matching lines @@
     SetupFadeInAfterLayout(window_label_.get());
   }
 
   gfx::Rect label_bounds = root_window_->ConvertRectFromScreen(window_bounds);
   window_label_button_view_->set_top_padding(label_bounds.height() -
                                              kVerticalLabelPadding);
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(
               animation_type,
-              wm::WmLookup::Get()->GetWindowForWidget(window_label_.get()));
+              WmLookup::Get()->GetWindowForWidget(window_label_.get()));
 
   window_label_->SetBounds(label_bounds);
 }
 
 void WindowSelectorItem::CreateWindowLabel(const base::string16& title) {
   const bool material = ash::MaterialDesignController::IsOverviewMaterial();
   window_label_.reset(new views::Widget);
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
@@ skipping 31 matching lines @@
     OverviewAnimationType animation_type) {
   gfx::Rect transformed_window_bounds =
       root_window_->ConvertRectFromScreen(GetTransformedBounds(
           GetWindow(), close_button_->GetPreferredSize().height()));
 
   {
     if (!close_button_->visible()) {
       close_button_->SetVisible(true);
       SetupFadeInAfterLayout(&close_button_widget_);
     }
-    wm::WmWindow* close_button_widget_window =
-        wm::WmLookup::Get()->GetWindowForWidget(&close_button_widget_);
+    WmWindow* close_button_widget_window =
+        WmLookup::Get()->GetWindowForWidget(&close_button_widget_);
     std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
         ScopedOverviewAnimationSettingsFactory::Get()
             ->CreateOverviewAnimationSettings(animation_type,
                                               close_button_widget_window);
 
     gfx::Transform close_button_transform;
     close_button_transform.Translate(transformed_window_bounds.right(),
                                      transformed_window_bounds.y());
     close_button_widget_window->SetTransform(close_button_transform);
   }
 
   // TODO(varkha): Figure out how to draw |window_label_| opaquely over the
   // occluded header or truly hide the headers in overview mode.
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     gfx::Rect label_rect(close_button_->GetPreferredSize());
     label_rect.set_y(-label_rect.height());
     label_rect.set_width(transformed_window_bounds.width() -
                          label_rect.width());
     window_label_->SetBounds(label_rect);
 
     if (!window_label_button_view_->visible()) {
       window_label_button_view_->SetVisible(true);
       SetupFadeInAfterLayout(window_label_.get());
     }
-    wm::WmWindow* window_label_window =
-        wm::WmLookup::Get()->GetWindowForWidget(window_label_.get());
+    WmWindow* window_label_window =
+        WmLookup::Get()->GetWindowForWidget(window_label_.get());
     std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
         ScopedOverviewAnimationSettingsFactory::Get()
             ->CreateOverviewAnimationSettings(animation_type,
                                               window_label_window);
     gfx::Transform label_transform;
     label_transform.Translate(transformed_window_bounds.x(),
                               transformed_window_bounds.y());
     window_label_window->SetTransform(label_transform);
   }
 }
 
 void WindowSelectorItem::UpdateCloseButtonAccessibilityName() {
   close_button_->SetAccessibleName(l10n_util::GetStringFUTF16(
       IDS_ASH_OVERVIEW_CLOSE_ITEM_BUTTON_ACCESSIBLE_NAME,
       GetWindow()->GetTitle()));
 }
 
 }  // namespace ash