Clean up: Replace details_.window with window().

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 "ash/display/display_controller.h"
@@ skipping 89 matching lines @@
   // |location_in_parent| have the same value and both of them are in
   // |window()->parent()|'s coordinates, but once the pointer enters the
   // other root window, you will see an unexpected value on the former. See
   // comments in wm::GetRootWindowRelativeToWindow() for details.
 
   int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
                   0 : ash::Shell::GetInstance()->GetGridSize();
   gfx::Rect bounds =  // in |window()->parent()|'s coordinates.
       CalculateBoundsForDrag(details_, location_in_parent, grid_size);
 
-  if (wm::IsWindowNormal(details_.window))
+  if (wm::IsWindowNormal(window()))
     AdjustBoundsForMainWindow(&bounds, grid_size);
-  if (bounds != details_.window->bounds()) {
+  if (bounds != window()->bounds()) {
     if (!did_move_or_resize_)
       RestackWindows();
     did_move_or_resize_ = true;
   }
 
   const bool in_original_root = (window()->GetRootWindow() == current_root);
   // Hide a phantom window for snapping if the cursor is in another root window.
   if (in_original_root)
     UpdateSnapPhantomWindow(location_in_parent, bounds, grid_size);
   else
     snap_phantom_window_controller_.reset();
 
   // Show a phantom window for dragging in another root window.
   if (HasSecondaryRootWindow())
     UpdateDragPhantomWindow(bounds, in_original_root);
   else
     drag_phantom_window_controller_.reset();
 
   if (!attached_windows_.empty())
     LayoutAttachedWindows(bounds, grid_size);
-  if (bounds != details_.window->bounds())
-    details_.window->SetBounds(bounds);
+  if (bounds != window()->bounds())
+    window()->SetBounds(bounds);
   // WARNING: we may have been deleted.
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
   window()->layer()->SetOpacity(details_.initial_opacity);
   drag_phantom_window_controller_.reset();
   snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   if (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE) {
-    if (!GetRestoreBoundsInScreen(details_.window))
-      SetRestoreBoundsInParent(details_.window, details_.initial_bounds);
-    details_.window->SetBounds(snap_sizer_->target_bounds());
+    if (!GetRestoreBoundsInScreen(window()))
+      SetRestoreBoundsInParent(window(), details_.initial_bounds);
+    window()->SetBounds(snap_sizer_->target_bounds());
     return;
   }
 
   int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
                   0 : ash::Shell::GetInstance()->GetGridSize();
-  gfx::Rect bounds(GetFinalBounds(details_.window->bounds(), grid_size));
+  gfx::Rect bounds(GetFinalBounds(window()->bounds(), grid_size));
 
   // Check if the destination is another display.
   gfx::Point last_mouse_location_in_screen = last_mouse_location_;
   wm::ConvertPointToScreen(window()->parent(), &last_mouse_location_in_screen);
   const gfx::Display dst_display =
       gfx::Screen::GetDisplayNearestPoint(last_mouse_location_in_screen);
 
   if (dst_display.id() !=
       gfx::Screen::GetDisplayNearestWindow(window()->GetRootWindow()).id()) {
     // Don't animate when moving to another display.
     const gfx::Rect dst_bounds =
-        ScreenAsh::ConvertRectToScreen(details_.window->parent(), bounds);
-    details_.window->SetBoundsInScreen(dst_bounds, dst_display);
+        ScreenAsh::ConvertRectToScreen(window()->parent(), bounds);
+    window()->SetBoundsInScreen(dst_bounds, dst_display);
     return;
   }
 
-  if (grid_size <= 1 || bounds == details_.window->bounds())
+  if (grid_size <= 1 || bounds == window()->bounds())
     return;
 
-  if (bounds.size() != details_.window->bounds().size()) {
+  if (bounds.size() != window()->bounds().size()) {
     // Don't attempt to animate a size change.
-    details_.window->SetBounds(bounds);
+    window()->SetBounds(bounds);
     return;
   }
 
   ui::ScopedLayerAnimationSettings scoped_setter(
-      details_.window->layer()->GetAnimator());
+      window()->layer()->GetAnimator());
   // Use a small duration since the grid is small.
   scoped_setter.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kSnapDurationMS));
-  details_.window->SetBounds(bounds);
+  window()->SetBounds(bounds);
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   window()->layer()->SetOpacity(details_.initial_opacity);
   drag_phantom_window_controller_.reset();
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
-  details_.window->SetBounds(details_.initial_bounds);
+  window()->SetBounds(details_.initial_bounds);
   if (details_.window_component == HTRIGHT) {
     int last_x = details_.initial_bounds.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 {
@@ skipping 148 matching lines @@
       sizes->push_back(size);
     }
   }
 }
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
     gfx::Rect* bounds, int grid_size) const {
   // Always keep kMinOnscreenHeight on the bottom except when an extended
   // display is available and a window is being dragged.
   gfx::Rect work_area(
-      ScreenAsh::GetDisplayWorkAreaBoundsInParent(details_.window));
+      ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
   int max_y = AlignToGridRoundUp(work_area.bottom() - kMinOnscreenHeight,
                                  grid_size);
   if ((details_.window_component != HTCAPTION || !HasSecondaryRootWindow()) &&
       bounds->y() > max_y) {
     bounds->set_y(max_y);
   }
 
   // Don't allow dragging above the top of the display except when an extended
   // display is available and a window is being dragged.
   if ((details_.window_component != HTCAPTION || !HasSecondaryRootWindow()) &&
@@ skipping 38 matching lines @@
              bounds->height() < (bottom_edge - top_edge)) {
     // Only snap to the bottom if the window is smaller than the work area.
     // Doing otherwise can lead to window snapping in weird ways as it bounces
     // between snapping to top then bottom.
     bounds->set_y(bottom_edge - bounds->height());
   }
 }
 
 bool WorkspaceWindowResizer::TouchesBottomOfScreen() const {
   gfx::Rect work_area(
-      ScreenAsh::GetDisplayWorkAreaBoundsInParent(details_.window));
+      ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
   return (attached_windows_.empty() &&
-          details_.window->bounds().bottom() == work_area.bottom()) ||
+          window()->bounds().bottom() == work_area.bottom()) ||
       (!attached_windows_.empty() &&
        attached_windows_.back()->bounds().bottom() == work_area.bottom());
 }
 
 int WorkspaceWindowResizer::PrimaryAxisSize(const gfx::Size& size) const {
   return PrimaryAxisCoordinate(size.width(), size.height());
 }
 
 int WorkspaceWindowResizer::PrimaryAxisCoordinate(int x, int y) const {
   switch (details_.window_component) {
@@ skipping 64 matching lines @@
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     if (snap_type_ == SNAP_NONE)
       return;
   }
   if (!snap_sizer_.get()) {
     SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
         SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
     snap_sizer_.reset(
-        new SnapSizer(details_.window, location, edge, grid_size));
+        new SnapSizer(window(), location, edge, grid_size));
   } else {
     snap_sizer_->Update(location);
   }
   if (!snap_phantom_window_controller_.get()) {
     snap_phantom_window_controller_.reset(
-        new PhantomWindowController(details_.window));
+        new PhantomWindowController(window()));
   }
   snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
-      details_.window->parent(), snap_sizer_->target_bounds()));
+      window()->parent(), snap_sizer_->target_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 = details_.window->parent();
+  aura::Window* parent = window()->parent();
   const aura::Window::Windows& windows(parent->children());
-  map[std::find(windows.begin(), windows.end(), details_.window) -
-      windows.begin()] = details_.window;
+  map[std::find(windows.begin(), windows.end(), window()) -
+      windows.begin()] = window();
   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);
   }
 }
 
 WorkspaceWindowResizer::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::GetDisplayBoundsInParent(details_.window));
+  gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(window()));
   if (location.x() <= area.x())
     return SNAP_LEFT_EDGE;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT_EDGE;
   return SNAP_NONE;
 }
 
 bool WorkspaceWindowResizer::ShouldAllowMouseWarp() const {
   return (details_.window_component == HTCAPTION) &&
       (window()->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_NONE) &&
       (window()->type() == aura::client::WINDOW_TYPE_NORMAL);
 }
 
 }  // namespace internal
 }  // namespace ash