Remove WmLookup.

ash/common/shelf/shelf_layout_manager.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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
 #include "ash/animation/animation_change_type.h"
 #include "ash/common/session/session_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_layout_manager_observer.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_screen_util.h"
-#include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
@@ skipping 150 matching lines @@
   // status_area_widget() may be NULL during the shutdown.
   return shelf_widget_->status_area_widget() &&
          shelf_widget_->status_area_widget()->IsVisible() &&
          (state_.visibility_state == SHELF_VISIBLE ||
           (state_.visibility_state == SHELF_AUTO_HIDE &&
            state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN));
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   const int shelf_size = GetShelfConstant(SHELF_SIZE);
-  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   gfx::Rect rect(wm::GetDisplayBoundsInParent(shelf_window));
   return SelectValueForShelfAlignment(
       gfx::Rect(rect.x(), rect.bottom() - shelf_size, rect.width(), shelf_size),
       gfx::Rect(rect.x(), rect.y(), shelf_size, rect.height()),
       gfx::Rect(rect.right() - shelf_size, rect.y(), shelf_size,
                 rect.height()));
 }
 
 gfx::Size ShelfLayoutManager::GetPreferredSize() {
   TargetBounds target_bounds;
@@ skipping 22 matching lines @@
     case SHELF_AUTO_HIDE_BEHAVIOR_NEVER:
       return SHELF_VISIBLE;
     case SHELF_AUTO_HIDE_ALWAYS_HIDDEN:
       return SHELF_HIDDEN;
   }
   return SHELF_VISIBLE;
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
   // Bail out early before the shelf is initialized or after it is destroyed.
-  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   if (in_shutdown_ || !wm_shelf_->IsShelfInitialized() || !shelf_window)
     return;
   if (state_.IsScreenLocked() || state_.IsAddingSecondaryUser()) {
     SetState(SHELF_VISIBLE);
   } else if (WmShell::Get()->IsPinned()) {
     SetState(SHELF_HIDDEN);
   } else {
     // TODO(zelidrag): Verify shelf drag animation still shows on the device
     // when we are in SHELF_AUTO_HIDE_ALWAYS_HIDDEN.
     wm::WorkspaceWindowState window_state(
@@ skipping 132 matching lines @@
 void ShelfLayoutManager::OnWindowResized() {
   LayoutShelf();
 }
 
 void ShelfLayoutManager::SetChildBounds(WmWindow* child,
                                         const gfx::Rect& requested_bounds) {
   wm::WmSnapToPixelLayoutManager::SetChildBounds(child, requested_bounds);
   // We may contain other widgets (such as frame maximize bubble) but they don't
   // effect the layout in anyway.
   if (!updating_bounds_ &&
-      ((WmLookup::Get()->GetWindowForWidget(shelf_widget_) == child) ||
-       (WmLookup::Get()->GetWindowForWidget(
-            shelf_widget_->status_area_widget()) == child))) {
+      ((WmWindow::Get(shelf_widget_->GetNativeWindow()) == child) ||
+       (WmWindow::Get(shelf_widget_->status_area_widget()->GetNativeWindow()) ==
+        child))) {
     LayoutShelf();
   }
 }
 
 void ShelfLayoutManager::OnShelfAutoHideBehaviorChanged(WmWindow* root_window) {
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnPinnedStateChanged(WmWindow* pinned_window) {
   // Shelf needs to be hidden on entering to pinned mode, or restored
@@ skipping 18 matching lines @@
        keyboard::KeyboardController::GetInstance()->keyboard_locked());
 
   keyboard_bounds_ = new_bounds;
   LayoutShelfAndUpdateBounds(change_work_area);
 
   // On login screen if keyboard has been just hidden, update bounds just once
   // but ignore target_bounds.work_area_insets since shelf overlaps with login
   // window.
   if (WmShell::Get()->GetSessionStateDelegate()->IsUserSessionBlocked() &&
       keyboard_is_about_to_hide) {
-    WmWindow* window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+    WmWindow* window = WmWindow::Get(shelf_widget_->GetNativeWindow());
     WmShell::Get()->SetDisplayWorkAreaInsets(window, gfx::Insets());
   }
 }
 
 void ShelfLayoutManager::OnKeyboardClosed() {}
 
 ShelfBackgroundType ShelfLayoutManager::GetShelfBackgroundType() const {
   if (state_.pre_lock_screen_animation_active)
     return SHELF_BACKGROUND_DEFAULT;
 
@@ skipping 25 matching lines @@
 ShelfLayoutManager::TargetBounds::TargetBounds()
     : opacity(0.0f), status_opacity(0.0f) {}
 
 ShelfLayoutManager::TargetBounds::~TargetBounds() {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
 
-  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   RootWindowController* controller = shelf_window->GetRootWindowController();
   state.window_state = controller ? controller->GetWorkspaceWindowState()
                                   : wm::WORKSPACE_WINDOW_STATE_DEFAULT;
   // Preserve the log in screen states.
   state.session_state = state_.session_state;
   state.pre_lock_screen_animation_active =
       state_.pre_lock_screen_animation_active;
 
   // Force an update because gesture drags affect the shelf bounds and we
   // should animate back to the normal bounds at the end of a gesture.
@@ skipping 86 matching lines @@
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     } else {
       StopAnimating();
       shelf_animation_setter.SetTransitionDuration(base::TimeDelta());
       status_animation_setter.SetTransitionDuration(base::TimeDelta());
     }
     if (observer)
       status_animation_setter.AddObserver(observer);
 
     GetLayer(shelf_widget_)->SetOpacity(target_bounds.opacity);
-    WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+    WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
     shelf_widget_->SetBounds(shelf_window->GetParent()->ConvertRectToScreen(
         target_bounds.shelf_bounds_in_root));
 
     GetLayer(shelf_widget_->status_area_widget())
         ->SetOpacity(target_bounds.status_opacity);
 
     // Having a window which is visible but does not have an opacity is an
     // illegal state. We therefore hide the shelf here if required.
     if (!target_bounds.status_opacity)
       shelf_widget_->status_area_widget()->Hide();
     // Setting visibility during an animation causes the visibility property to
     // animate. Override the animation settings to immediately set the
     // visibility property. Opacity will still animate.
 
     // TODO(harrym): Once status area widget is a child view of shelf
     // this can be simplified.
     gfx::Rect status_bounds = target_bounds.status_bounds_in_shelf;
     status_bounds.Offset(target_bounds.shelf_bounds_in_root.OffsetFromOrigin());
-    WmWindow* status_window = WmLookup::Get()->GetWindowForWidget(
-        shelf_widget_->status_area_widget());
+    WmWindow* status_window =
+        WmWindow::Get(shelf_widget_->status_area_widget()->GetNativeWindow());
     shelf_widget_->status_area_widget()->SetBounds(
         status_window->GetParent()->ConvertRectToScreen(status_bounds));
 
     // For crbug.com/622431, when the shelf alignment is BOTTOM_LOCKED, we
     // don't set display work area, as it is not real user-set alignment.
     if (!state_.IsScreenLocked() &&
         wm_shelf_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM_LOCKED &&
         change_work_area) {
       gfx::Insets insets;
       // If user session is blocked (login to new user session or add user to
@@ skipping 31 matching lines @@
     // Auto-hidden shelf always starts with the default size. If a gesture-drag
     // is in progress, then the call to UpdateTargetBoundsForGesture() below
     // takes care of setting the height properly.
     shelf_size = kShelfAutoHideSize;
   } else if (state.visibility_state == SHELF_HIDDEN ||
              (!keyboard_bounds_.IsEmpty() &&
               !keyboard::IsKeyboardOverscrollEnabled())) {
     shelf_size = 0;
   }
 
-  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   gfx::Rect available_bounds = wm::GetDisplayBoundsWithShelf(shelf_window);
   available_bounds.Inset(0, chromevox_panel_height_, 0, 0);
   int shelf_width = PrimaryAxisValue(available_bounds.width(), shelf_size);
   int shelf_height = PrimaryAxisValue(shelf_size, available_bounds.height());
   int bottom_shelf_vertical_offset = available_bounds.bottom();
   if (keyboard_bounds_.IsEmpty())
     bottom_shelf_vertical_offset -= shelf_height;
   else
     bottom_shelf_vertical_offset -= keyboard_bounds_.height();
 
@@ skipping 73 matching lines @@
   available_bounds.Subtract(keyboard_bounds_);
 
   WmWindow* root = shelf_window->GetRootWindow();
   user_work_area_bounds_ = root->ConvertRectToScreen(available_bounds);
 }
 
 void ShelfLayoutManager::UpdateTargetBoundsForGesture(
     TargetBounds* target_bounds) const {
   CHECK_EQ(GESTURE_DRAG_IN_PROGRESS, gesture_drag_status_);
   bool horizontal = wm_shelf_->IsHorizontalAlignment();
-  WmWindow* window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmWindow* window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   gfx::Rect available_bounds = wm::GetDisplayBoundsWithShelf(window);
   int resistance_free_region = 0;
 
   if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
       visibility_state() == SHELF_AUTO_HIDE &&
       auto_hide_state() != SHELF_AUTO_HIDE_SHOWN) {
     // If the shelf was hidden when the drag started (and the state hasn't
     // changed since then, e.g. because the tray-menu was shown because of the
     // drag), then allow the drag some resistance-free region at first to make
     // sure the shelf sticks with the finger until the shelf is visible.
@@ skipping 111 matching lines @@
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_widget_->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_widget_->IsActive() ||
       (shelf_widget_->status_area_widget() &&
        shelf_widget_->status_area_widget()->IsActive()))
     return SHELF_AUTO_HIDE_SHOWN;
 
-  const int64_t shelf_display_id = WmLookup::Get()
-                                       ->GetWindowForWidget(shelf_widget_)
-                                       ->GetDisplayNearestWindow()
-                                       .id();
+  const int64_t shelf_display_id =
+      WmWindow::Get(shelf_widget_->GetNativeWindow())
+          ->GetDisplayNearestWindow()
+          .id();
   const std::vector<WmWindow*> windows =
       WmShell::Get()->mru_window_tracker()->BuildWindowListIgnoreModal();
   // Process the window list and check if there are any visible windows.
   // Ignore app list windows that may be animating to hide after dismissal.
   bool visible_window = false;
   for (size_t i = 0; i < windows.size(); ++i) {
     if (windows[i] && windows[i]->IsVisible() && !IsAppListWindow(windows[i]) &&
         !windows[i]->GetWindowState()->IsMinimized() &&
         windows[i]->GetDisplayNearestWindow().id() == shelf_display_id) {
       visible_window = true;
@@ skipping 52 matching lines @@
           cursor_position_in_screen)) {
     return SHELF_AUTO_HIDE_SHOWN;
   }
 
   return SHELF_AUTO_HIDE_HIDDEN;
 }
 
 bool ShelfLayoutManager::IsShelfWindow(WmWindow* window) {
   if (!window)
     return false;
-  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   WmWindow* status_window =
-      WmLookup::Get()->GetWindowForWidget(shelf_widget_->status_area_widget());
+      WmWindow::Get(shelf_widget_->status_area_widget()->GetNativeWindow());
   return (shelf_window && shelf_window->Contains(window)) ||
          (status_window && status_window->Contains(window));
 }
 
 int ShelfLayoutManager::GetWorkAreaInsets(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
   if (state.visibility_state == SHELF_AUTO_HIDE)
     return GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
   return 0;
@@ skipping 64 matching lines @@
   // target bounds are also hidden. So the window can extend to the edge of
   // screen.
   return (state.visibility_state == SHELF_AUTO_HIDE &&
           state.auto_hide_state == SHELF_AUTO_HIDE_SHOWN)
              ? 1.0f
              : 0.0f;
 }
 
 bool ShelfLayoutManager::IsShelfHiddenForFullscreen() const {
   const WmWindow* fullscreen_window = wm::GetWindowForFullscreenMode(
-      WmLookup::Get()->GetWindowForWidget(shelf_widget_));
+      WmWindow::Get(shelf_widget_->GetNativeWindow()));
   return fullscreen_window &&
          fullscreen_window->GetWindowState()->hide_shelf_when_fullscreen();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, Gesture functions:
 
 void ShelfLayoutManager::StartGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_status_ = GESTURE_DRAG_IN_PROGRESS;
   gesture_drag_amount_ = 0.f;
@@ skipping 79 matching lines @@
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 }  // namespace ash