Cleanup: remove Details::window. Use GetTarget() when possible

ash/wm/workspace/workspace_window_resizer.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/wm/workspace/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
@@ skipping 368 matching lines @@
       details_.source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     sticky_size = kScreenEdgeInsetForTouchResize;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |window()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(details_, location_in_parent);
   if (window_state()->IsNormalShowState())
     AdjustBoundsForMainWindow(sticky_size, &bounds);
 
-  if (bounds != window()->bounds()) {
+  if (bounds != GetTarget()->bounds()) {
     if (!did_move_or_resize_) {
       if (!details_.restore_bounds.IsEmpty())
         window_state()->ClearRestoreBounds();
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
   gfx::Point location_in_screen = location_in_parent;
-  wm::ConvertPointToScreen(window()->parent(), &location_in_screen);
+  wm::ConvertPointToScreen(GetTarget()->parent(), &location_in_screen);
 
   aura::Window* root = NULL;
   gfx::Display display =
       ScreenAsh::FindDisplayContainingPoint(location_in_screen);
   // Track the last screen that the pointer was on to keep the snap phantom
   // window there.
   if (display.is_valid()) {
     root = Shell::GetInstance()->display_controller()->
         GetRootWindowForDisplayId(display.id());
   }
   if (!attached_windows_.empty())
     LayoutAttachedWindows(&bounds);
-  if (bounds != window()->bounds()) {
+  if (bounds != GetTarget()->bounds()) {
     // SetBounds needs to be called to update the layout which affects where the
     // phantom window is drawn. Keep track if the window was destroyed during
     // the drag and quit early if so.
     base::WeakPtr<WorkspaceWindowResizer> resizer(
         weak_ptr_factory_.GetWeakPtr());
-    window()->SetBounds(bounds);
+    GetTarget()->SetBounds(bounds);
     if (!resizer)
       return;
   }
-  const bool in_original_root = !root || root == window()->GetRootWindow();
+  const bool in_original_root = !root || root == GetTarget()->GetRootWindow();
   // Hide a phantom window for snapping if the cursor is in another root window.
   if (in_original_root) {
     UpdateSnapPhantomWindow(location_in_parent, bounds);
   } else {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     SetDraggedWindowDocked(false);
   }
 }
 
 void WorkspaceWindowResizer::CompleteDrag() {
   window_state()->set_bounds_changed_by_user(true);
   snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   bool snapped = false;
   // When the window is not in the normal show state, we do not snap the window.
   // This happens when the user minimizes or maximizes the window by keyboard
   // shortcut while dragging it. If the window is the result of dragging a tab
   // out of a maximized window, it's already in the normal show state when this
   // is called, so it does not matter.
   if (window_state()->IsNormalShowState() &&
-      (window()->type() != ui::wm::WINDOW_TYPE_PANEL ||
+      (GetTarget()->type() != ui::wm::WINDOW_TYPE_PANEL ||
        !window_state()->panel_attached() ||
        dock_layout_->is_dragged_window_docked()) &&
       (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT)) {
     if (!window_state()->HasRestoreBounds()) {
       gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
-          window()->parent(), details_.initial_bounds_in_parent);
+          GetTarget()->parent(), details_.initial_bounds_in_parent);
       window_state()->SetRestoreBoundsInScreen(
           details_.restore_bounds.IsEmpty() ?
           initial_bounds :
           details_.restore_bounds);
     }
     DCHECK(snap_sizer_);
     if (window_state()->CanResize() &&
         !dock_layout_->is_dragged_window_docked()) {
       snap_sizer_->SnapWindowToTargetBounds();
       snapped = true;
     }
   }
   if (window_state()->IsSnapped() && !snapped)
     window_state()->Restore();
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   window_state()->set_bounds_changed_by_user(initial_bounds_changed_by_user_);
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
-  window()->SetBounds(details_.initial_bounds_in_parent);
+  GetTarget()->SetBounds(details_.initial_bounds_in_parent);
   if (!details_.restore_bounds.IsEmpty()) {
     window_state()->SetRestoreBoundsInScreen(details_.restore_bounds);
   }
 
   if (details_.window_component == HTRIGHT) {
     int last_x = details_.initial_bounds_in_parent.right();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
       gfx::Rect bounds(attached_windows_[i]->bounds());
       bounds.set_x(last_x);
       bounds.set_width(initial_size_[i]);
       attached_windows_[i]->SetBounds(bounds);
       last_x = attached_windows_[i]->bounds().right();
     }
   } else {
     int last_y = details_.initial_bounds_in_parent.bottom();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
       gfx::Rect bounds(attached_windows_[i]->bounds());
       bounds.set_y(last_y);
       bounds.set_height(initial_size_[i]);
       attached_windows_[i]->SetBounds(bounds);
       last_y = attached_windows_[i]->bounds().bottom();
     }
   }
 }
 
 aura::Window* WorkspaceWindowResizer::GetTarget() {

[varkha, 2014/01/08 23:46:56]

Should this be const (and virtual OVERRIDE)?

-  return details_.window;
+  return details_.window();
 }
 
 const gfx::Point& WorkspaceWindowResizer::GetInitialLocation() const {
   return details_.initial_location_in_parent;
 }
 
 WorkspaceWindowResizer::WorkspaceWindowResizer(
     const Details& details,
     const std::vector<aura::Window*>& attached_windows)
     : details_(details),
@@ skipping 12 matching lines @@
 
   // A mousemove should still show the cursor even if the window is
   // being moved or resized with touch, so do not lock the cursor.
   if (details.source != aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     Shell* shell = Shell::GetInstance();
     shell->cursor_manager()->LockCursor();
     did_lock_cursor_ = true;
   }
 
   aura::Window* dock_container = Shell::GetContainer(
-      window()->GetRootWindow(), kShellWindowId_DockedContainer);
+      GetTarget()->GetRootWindow(), kShellWindowId_DockedContainer);
   dock_layout_ = static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
 
   // Only support attaching to the right/bottom.
   DCHECK(attached_windows_.empty() ||
          (details.window_component == HTRIGHT ||
           details.window_component == HTBOTTOM));
 
   // TODO: figure out how to deal with window going off the edge.
 
@@ skipping 18 matching lines @@
     const gfx::Rect& bounds) const {
   if (snap_phantom_window_controller_.get() &&
       snap_phantom_window_controller_->IsShowing()) {
     return snap_phantom_window_controller_->bounds_in_screen();
   }
   return bounds;
 }
 
 void WorkspaceWindowResizer::LayoutAttachedWindows(
     gfx::Rect* bounds) {
-  gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
+  gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(GetTarget()));
   int initial_size = PrimaryAxisSize(details_.initial_bounds_in_parent.size());
   int current_size = PrimaryAxisSize(bounds->size());
   int start = PrimaryAxisCoordinate(bounds->right(), bounds->bottom());
   int end = PrimaryAxisCoordinate(work_area.right(), work_area.bottom());
 
   int delta = current_size - initial_size;
   int available_size = end - start;
   std::vector<int> sizes;
   int leftovers = CalculateAttachedSizes(delta, available_size, &sizes);
 
@@ skipping 119 matching lines @@
     int min = PrimaryAxisSize(delegate->GetMinimumSize());
     int max = PrimaryAxisSize(delegate->GetMaximumSize());
 
     sizes->push_back(WindowSize(initial_size, min, max));
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapToOtherWindows(gfx::Rect* bounds) {
   if (UpdateMagnetismWindow(*bounds, kAllMagnetismEdges)) {
     gfx::Point point = OriginForMagneticAttach(
-        ScreenAsh::ConvertRectToScreen(window()->parent(), *bounds),
+        ScreenAsh::ConvertRectToScreen(GetTarget()->parent(), *bounds),
         magnetism_window_->GetBoundsInScreen(),
         magnetism_edge_);
-    aura::client::GetScreenPositionClient(window()->GetRootWindow())->
-        ConvertPointFromScreen(window()->parent(), &point);
+    aura::client::GetScreenPositionClient(GetTarget()->GetRootWindow())->
+        ConvertPointFromScreen(GetTarget()->parent(), &point);
     bounds->set_origin(point);
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapResizeToOtherWindows(
     gfx::Rect* bounds) {
   const uint32 edges = WindowComponentToMagneticEdge(details_.window_component);
   if (UpdateMagnetismWindow(*bounds, edges)) {
     *bounds = ScreenAsh::ConvertRectFromScreen(
-        window()->parent(),
+        GetTarget()->parent(),
         BoundsForMagneticResizeAttach(
-            ScreenAsh::ConvertRectToScreen(window()->parent(), *bounds),
+            ScreenAsh::ConvertRectToScreen(GetTarget()->parent(), *bounds),
             magnetism_window_->GetBoundsInScreen(),
             magnetism_edge_));
   }
 }
 
 bool WorkspaceWindowResizer::UpdateMagnetismWindow(const gfx::Rect& bounds,
                                                    uint32 edges) {
   // |bounds| are in coordinates of original window's parent.
   gfx::Rect bounds_in_screen =
-      ScreenAsh::ConvertRectToScreen(window()->parent(), bounds);
+      ScreenAsh::ConvertRectToScreen(GetTarget()->parent(), bounds);
   MagnetismMatcher matcher(bounds_in_screen, edges);
 
   // If we snapped to a window then check it first. That way we don't bounce
   // around when close to multiple edges.
   if (magnetism_window_) {
     if (window_tracker_.Contains(magnetism_window_) &&
         matcher.ShouldAttach(magnetism_window_->GetBoundsInScreen(),
                              &magnetism_edge_)) {
       return true;
     }
     window_tracker_.Remove(magnetism_window_);
     magnetism_window_ = NULL;
   }
 
   // Avoid magnetically snapping windows that are not resizable.
   // TODO(oshima): change this to window.type() == TYPE_NORMAL.
   if (!window_state()->CanResize())
     return false;
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     const aura::Window* root_window = *iter;
     // Test all children from the desktop in each root window.
     const aura::Window::Windows& children = Shell::GetContainer(
         root_window, kShellWindowId_DefaultContainer)->children();
     for (aura::Window::Windows::const_reverse_iterator i = children.rbegin();
          i != children.rend() && !matcher.AreEdgesObscured(); ++i) {
       wm::WindowState* other_state = wm::GetWindowState(*i);
-      if (other_state->window() == window() ||
+      if (other_state->window() == GetTarget() ||
           !other_state->window()->IsVisible() ||
           !other_state->IsNormalShowState() ||
           !other_state->CanResize()) {
         continue;
       }
       if (matcher.ShouldAttach(
               other_state->window()->GetBoundsInScreen(), &magnetism_edge_)) {
         magnetism_window_ = other_state->window();
         window_tracker_.Add(magnetism_window_);
         return true;
       }
     }
   }
   return false;
 }
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
     int sticky_size,
     gfx::Rect* bounds) {
   gfx::Point last_mouse_location_in_screen = last_mouse_location_;
-  wm::ConvertPointToScreen(window()->parent(), &last_mouse_location_in_screen);
+  wm::ConvertPointToScreen(GetTarget()->parent(),
+                           &last_mouse_location_in_screen);
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestPoint(
       last_mouse_location_in_screen);
-  gfx::Rect work_area =
-      ScreenAsh::ConvertRectFromScreen(window()->parent(), display.work_area());
+  gfx::Rect work_area = ScreenAsh::ConvertRectFromScreen(GetTarget()->parent(),
+                                                         display.work_area());
   if (details_.window_component == HTCAPTION) {
     // Adjust the bounds to the work area where the mouse cursor is located.
     // Always keep kMinOnscreenHeight or the window height (whichever is less)
     // on the bottom.
     int max_y = work_area.bottom() - std::min(kMinOnscreenHeight,
                                               bounds->height());
     if (bounds->y() > max_y) {
       bounds->set_y(max_y);
     } else if (bounds->y() <= work_area.y()) {
       // Don't allow dragging above the top of the display until the mouse
@@ skipping 111 matching lines @@
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     if (snap_type_ == SNAP_NONE) {
       SetDraggedWindowDocked(false);
       return;
     }
   }
-  const bool can_dock = dock_layout_->CanDockWindow(window(), snap_type_);
+  const bool can_dock = dock_layout_->CanDockWindow(GetTarget(), snap_type_);
   const bool can_snap = window_state()->CanSnap();
   if (!can_snap && !can_dock) {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     SetDraggedWindowDocked(false);
     return;
   }
   SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT) ?
       SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
   if (!snap_sizer_) {
     snap_sizer_.reset(new SnapSizer(window_state(),
                                     location,
                                     edge,
                                     internal::SnapSizer::OTHER_INPUT));
   } else {
     snap_sizer_->Update(location);
   }
 
   // Update phantom window with snapped or docked guide bounds.
   // Windows that cannot be snapped or are less wide than kMaxDockWidth can get
   // docked without going through a snapping sequence.
   gfx::Rect phantom_bounds;
   if (can_snap &&
       (!can_dock ||
-       window()->bounds().width() > DockedWindowLayoutManager::kMaxDockWidth))
+       GetTarget()->bounds().width() >
+       DockedWindowLayoutManager::kMaxDockWidth))
     phantom_bounds = snap_sizer_->target_bounds();
   const bool should_dock = can_dock &&
       (phantom_bounds.IsEmpty() ||
        snap_sizer_->end_of_sequence() ||
        dock_layout_->is_dragged_window_docked());
   SetDraggedWindowDocked(should_dock);
   snap_type_ = GetSnapType(location);
   if (dock_layout_->is_dragged_window_docked()) {
     phantom_bounds = ScreenAsh::ConvertRectFromScreen(
-        window()->parent(), dock_layout_->dragged_bounds());
+        GetTarget()->parent(), dock_layout_->dragged_bounds());
   }
 
   if (phantom_bounds.IsEmpty()) {
     snap_phantom_window_controller_.reset();
     return;
   }
 
   if (!snap_phantom_window_controller_) {
     snap_phantom_window_controller_.reset(
-        new PhantomWindowController(window()));
+        new PhantomWindowController(GetTarget()));
   }
   snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
-      window()->parent(), phantom_bounds));
+      GetTarget()->parent(), phantom_bounds));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
   typedef std::map<size_t, aura::Window*> IndexToWindowMap;
   IndexToWindowMap map;
-  aura::Window* parent = window()->parent();
+  aura::Window* parent = GetTarget()->parent();
   const aura::Window::Windows& windows(parent->children());
-  map[std::find(windows.begin(), windows.end(), window()) -
-      windows.begin()] = window();
+  map[std::find(windows.begin(), windows.end(), GetTarget()) -
+      windows.begin()] = GetTarget();
   for (std::vector<aura::Window*>::const_iterator i =
            attached_windows_.begin(); i != attached_windows_.end(); ++i) {
     if ((*i)->parent() != parent)
       return;
     size_t index =
         std::find(windows.begin(), windows.end(), *i) - windows.begin();
     map[index] = *i;
   }
 
   // Reorder the windows starting at the topmost.
   parent->StackChildAtTop(map.rbegin()->second);
   for (IndexToWindowMap::const_reverse_iterator i = map.rbegin();
        i != map.rend(); ) {
     aura::Window* window = i->second;
     ++i;
     if (i != map.rend())
       parent->StackChildBelow(i->second, window);
   }
 }
 
 SnapType WorkspaceWindowResizer::GetSnapType(
     const gfx::Point& location) const {
   // TODO: this likely only wants total display area, not the area of a single
   // display.
-  gfx::Rect area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
+  gfx::Rect area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(GetTarget()));
   if (details_.source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     // Increase tolerance for touch-snapping near the screen edges. This is only
     // necessary when the work area left or right edge is same as screen edge.
-    gfx::Rect display_bounds(ScreenAsh::GetDisplayBoundsInParent(window()));
+    gfx::Rect display_bounds(ScreenAsh::GetDisplayBoundsInParent(GetTarget()));
     int inset_left = 0;
     if (area.x() == display_bounds.x())
       inset_left = kScreenEdgeInsetForTouchResize;
     int inset_right = 0;
     if (area.right() == display_bounds.right())
       inset_right = kScreenEdgeInsetForTouchResize;
     area.Inset(inset_left, 0, inset_right, 0);
   }
   if (location.x() <= area.x())
     return SNAP_LEFT;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT;
   return SNAP_NONE;
 }
 
 void WorkspaceWindowResizer::SetDraggedWindowDocked(bool should_dock) {
   if (should_dock &&
-      dock_layout_->GetAlignmentOfWindow(window()) != DOCKED_ALIGNMENT_NONE) {
+      dock_layout_->GetAlignmentOfWindow(GetTarget()) !=
+      DOCKED_ALIGNMENT_NONE) {
     if (!dock_layout_->is_dragged_window_docked()) {
       window_state()->set_bounds_changed_by_user(false);
-      dock_layout_->DockDraggedWindow(window());
+      dock_layout_->DockDraggedWindow(GetTarget());
     }
   } else {
     if (dock_layout_->is_dragged_window_docked()) {
       dock_layout_->UndockDraggedWindow();
       window_state()->set_bounds_changed_by_user(true);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace ash