Remove WmLookup.

ash/common/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/common/wm/overview/window_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/metrics/user_metrics_action.h"
 #include "ash/common/strings/grit/ash_strings.h"
 #include "ash/common/wm/overview/cleanup_animation_observer.h"
 #include "ash/common/wm/overview/overview_animation_type.h"
 #include "ash/common/wm/overview/scoped_overview_animation_settings.h"
 #include "ash/common/wm/overview/scoped_overview_animation_settings_factory.h"
 #include "ash/common/wm/overview/scoped_transform_overview_window.h"
 #include "ash/common/wm/overview/window_selector.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/window_state.h"
-#include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/common/wm_window_property.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/resources/vector_icons/vector_icons.h"
 #include "ash/root_window_controller.h"
 #include "base/auto_reset.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 70 matching lines @@
 static const int kExitFadeInMilliseconds = 30;
 
 // Before closing a window animate both the window and the caption to shrink by
 // this fraction of size.
 static const float kPreCloseScale = 0.02f;
 
 // 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) {
-  WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget);
+  WmWindow* window = WmWindow::Get(widget->GetNativeWindow());
   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 158 matching lines @@
   const char* GetClassName() const override { return "RoundedContainerView"; }
 
  private:
   // gfx::AnimationDelegate:
   void AnimationEnded(const gfx::Animation* animation) override {
     initial_color_ = target_color_;
     // Tabbed browser windows show the overview mode header behind the window
     // during the initial animation. Once the initial fade-in completes and the
     // overview header is fully exposed update stacking to keep the label above
     // the item which prevents input events from reaching the window.
-    WmWindow* widget_window = WmLookup::Get()->GetWindowForWidget(GetWidget());
+    WmWindow* widget_window = WmWindow::Get(GetWidget()->GetNativeWindow());
     if (widget_window && item_window_)
       widget_window->GetParent()->StackChildAbove(widget_window, item_window_);
     item_window_ = nullptr;
   }
 
   void AnimationProgressed(const gfx::Animation* animation) override {
     current_value_ = animation_->CurrentValueBetween(0, 255);
     SchedulePaint();
   }
 
@@ skipping 143 matching lines @@
   transform_window_.EnsureVisible();
 }
 
 void WindowSelectorItem::Shutdown() {
   if (transform_window_.GetTopInset()) {
     // Activating a window (even when it is the window that was active before
     // overview) results in stacking it at the top. Maintain the label window
     // stacking position above the item to make the header transformation more
     // gradual upon exiting the overview mode.
     WmWindow* widget_window =
-        WmLookup::Get()->GetWindowForWidget(item_widget_.get());
+        WmWindow::Get(item_widget_.get()->GetNativeWindow());
 
     // |widget_window| was originally created in the same container as the
     // |transform_window_| but when closing overview the |transform_window_|
     // could have been reparented if a drag was active. Only change stacking
     // if the windows still belong to the same container.
     if (widget_window->GetParent() == transform_window_.window()->GetParent()) {
       widget_window->GetParent()->StackChildAbove(widget_window,
                                                   transform_window_.window());
     }
   }
@@ skipping 154 matching lines @@
   params_label.accept_events = true;
   item_widget_.reset(new views::Widget);
   root_window_->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           item_widget_.get(),
           transform_window_.window()->GetParent()->GetShellWindowId(),
           &params_label);
   item_widget_->set_focus_on_creation(false);
   item_widget_->Init(params_label);
   WmWindow* widget_window =
-      WmLookup::Get()->GetWindowForWidget(item_widget_.get());
+      WmWindow::Get(item_widget_.get()->GetNativeWindow());
   if (transform_window_.GetTopInset()) {
     // For windows with headers the overview header fades in above the
     // original window header.
     widget_window->GetParent()->StackChildAbove(widget_window,
                                                 transform_window_.window());
   } else {
     // For tabbed windows the overview header slides from behind. The stacking
     // is then corrected when the animation completes.
     widget_window->GetParent()->StackChildBelow(widget_window,
                                                 transform_window_.window());
@@ skipping 45 matching lines @@
       background_view_->AnimateColor(gfx::Tween::EASE_OUT,
                                      kExitFadeInMilliseconds);
       background_view_->set_color(kLabelExitColor);
     }
   }
   if (!label_view_->visible()) {
     label_view_->SetVisible(true);
     SetupFadeInAfterLayout(item_widget_.get());
   }
   WmWindow* widget_window =
-      WmLookup::Get()->GetWindowForWidget(item_widget_.get());
+      WmWindow::Get(item_widget_.get()->GetNativeWindow());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type, widget_window);
   // |widget_window| covers both the transformed window and the header
   // as well as the gap between the windows to prevent events from reaching
   // the window including its sizing borders.
   if (mode != HeaderFadeInMode::ENTER) {
     label_rect.set_height(close_button_->GetPreferredSize().height() +
                           transformed_window_bounds.height());
   }
   label_rect.Inset(-kWindowSelectorMargin, -kWindowSelectorMargin);
   widget_window->SetBounds(label_rect);
   gfx::Transform label_transform;
   label_transform.Translate(transformed_window_bounds.x(),
                             transformed_window_bounds.y());
   widget_window->SetTransform(label_transform);
 }
 
 void WindowSelectorItem::AnimateOpacity(float opacity,
                                         OverviewAnimationType animation_type) {
   DCHECK_GE(opacity, 0.f);
   DCHECK_LE(opacity, 1.f);
   ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
   transform_window_.BeginScopedAnimation(animation_type, &animation_settings);
   transform_window_.SetOpacity(opacity);
 
   const float header_opacity = selected_ ? 0.f : kHeaderOpacity * opacity;
   WmWindow* widget_window =
-      WmLookup::Get()->GetWindowForWidget(item_widget_.get());
+      WmWindow::Get(item_widget_.get()->GetNativeWindow());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings_label =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type, widget_window);
   widget_window->SetOpacity(header_opacity);
 }
 
 void WindowSelectorItem::UpdateAccessibilityName() {
   caption_container_view_->listener_button()->SetAccessibleName(
       GetWindow()->GetTitle());
 }
 
 void WindowSelectorItem::FadeOut(std::unique_ptr<views::Widget> widget) {
   widget->SetOpacity(1.f);
 
   // Fade out the widget. This animation continues past the lifetime of |this|.
-  WmWindow* widget_window = WmLookup::Get()->GetWindowForWidget(widget.get());
+  WmWindow* widget_window = WmWindow::Get(widget.get()->GetNativeWindow());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(
               OverviewAnimationType::
                   OVERVIEW_ANIMATION_EXIT_OVERVIEW_MODE_FADE_OUT,
               widget_window);
   // CleanupAnimationObserver will delete itself (and the widget) when the
   // opacity animation is complete.
   // Ownership over the observer is passed to the window_selector_->delegate()
   // which has longer lifetime so that animations can continue even after the
   // overview mode is shut down.
   views::Widget* widget_ptr = widget.get();
   std::unique_ptr<CleanupAnimationObserver> observer(
       new CleanupAnimationObserver(std::move(widget)));
   animation_settings->AddObserver(observer.get());
   window_selector_->delegate()->AddDelayedAnimationObserver(
       std::move(observer));
   widget_ptr->SetOpacity(0.f);
 }
 
 gfx::SlideAnimation* WindowSelectorItem::GetBackgroundViewAnimation() {
   return background_view_ ? background_view_->animation() : nullptr;
 }
 
 WmWindow* WindowSelectorItem::GetOverviewWindowForMinimizedStateForTest() {
   return transform_window_.GetOverviewWindowForMinimizedState();
 }
 
 }  // namespace ash