Use correct restore bounds in resizer.

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 309 matching lines @@
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   // When the window is not in the normal show state, we do not snap thw 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 (wm::IsWindowNormal(window()) &&
       (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE)) {
-    if (!GetRestoreBoundsInScreen(window()))
-      SetRestoreBoundsInParent(window(), details_.restore_bounds.IsEmpty() ?
-                                         details_.initial_bounds :
-                                         details_.restore_bounds);
+    if (!GetRestoreBoundsInScreen(window())) {
+      gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
+          window()->parent(), details_.initial_bounds_in_parent);
+      SetRestoreBoundsInScreen(window(), details_.restore_bounds.IsEmpty() ?
+                               initial_bounds :
+                               details_.restore_bounds);
+    }
     window()->SetBounds(snap_sizer_->target_bounds());
     return;
   }
 
   gfx::Rect bounds(GetFinalBounds(window()->bounds()));
 
   // 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);
   gfx::Screen* screen = Shell::GetScreen();
@@ skipping 11 matching lines @@
 
 void WorkspaceWindowResizer::RevertDrag() {
   window()->layer()->SetOpacity(details_.initial_opacity);
   drag_phantom_window_controller_.reset();
   snap_phantom_window_controller_.reset();
   Shell::GetInstance()->mouse_cursor_filter()->HideSharedEdgeIndicator();
 
   if (!did_move_or_resize_)
     return;
 
-  window()->SetBounds(details_.initial_bounds);
+  window()->SetBounds(details_.initial_bounds_in_parent);
   if (!details_.restore_bounds.IsEmpty())
     SetRestoreBoundsInScreen(details_.window, details_.restore_bounds);
 
   if (details_.window_component == HTRIGHT) {
-    int last_x = details_.initial_bounds.right();
+    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.bottom();
+    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();
     }
   }
 }
 
@@ skipping 77 matching lines @@
     return snap_phantom_window_controller_->bounds();
   }
   return bounds;
 }
 
 void WorkspaceWindowResizer::LayoutAttachedWindows(
     const gfx::Rect& bounds) {
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
   std::vector<int> sizes;
   CalculateAttachedSizes(
-      PrimaryAxisSize(details_.initial_bounds.size()),
+      PrimaryAxisSize(details_.initial_bounds_in_parent.size()),
       PrimaryAxisSize(bounds.size()),
       PrimaryAxisCoordinate(bounds.right(), bounds.bottom()),
       PrimaryAxisCoordinate(work_area.right(), work_area.bottom()),
       &sizes);
   DCHECK_EQ(attached_windows_.size(), sizes.size());
   int last = PrimaryAxisCoordinate(bounds.right(), bounds.bottom());
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     gfx::Rect attached_bounds(attached_windows_[i]->bounds());
     if (details_.window_component == HTRIGHT) {
       attached_bounds.set_x(last);
@@ skipping 340 matching lines @@
   gfx::Rect layer_bounds = layer_->bounds();
   layer_bounds.set_origin(gfx::Point(0, 0));
   layer_->SetBounds(layer_bounds);
   layer_->SetVisible(false);
   // Detach it from the current container.
   layer_->parent()->Remove(layer_);
 }
 
 }  // namespace internal
 }  // namespace ash