Prevents crash when docking a detached panel while fullscreen window is active

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 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/wm/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
@@ skipping 283 matching lines @@
         GetWindowHeightCloseTo(win2.window(), 0);
   }
 };
 
 // A functor used to sort the windows in order of their center Y position.
 // |delta| is a pre-calculated distance from the bottom of one window to the top
 // of the next. Its value can be positive (gap) or negative (overlap).
 // Half of |delta| is used as a transition point at which windows could ideally
 // swap positions.
 struct CompareWindowPos {
-  CompareWindowPos(aura::Window* dragged_window, float delta)
+  CompareWindowPos(aura::Window* dragged_window,
+                   aura::Window* docked_container,
+                   float delta)
       : dragged_window_(dragged_window),
+        docked_container_(docked_container),
         delta_(delta / 2) {}
 
   bool operator()(WindowWithHeight window_with_height1,
                   WindowWithHeight window_with_height2) {
     // Use target coordinates since animations may be active when windows are
     // reordered.
     aura::Window* win1(window_with_height1.window());
     aura::Window* win2(window_with_height2.window());
     gfx::Rect win1_bounds = ScreenUtil::ConvertRectToScreen(
-        win1->parent(), win1->GetTargetBounds());
+        docked_container_, win1->GetTargetBounds());
     gfx::Rect win2_bounds = ScreenUtil::ConvertRectToScreen(
-        win2->parent(), win2->GetTargetBounds());
+        docked_container_, win2->GetTargetBounds());
     win1_bounds.set_height(window_with_height1.height_);
     win2_bounds.set_height(window_with_height2.height_);
     // If one of the windows is the |dragged_window_| attempt to make an
     // earlier swap between the windows than just based on their centers.
     // This is possible if the dragged window is at least as tall as the other
     // window.
     if (win1 == dragged_window_)
       return compare_two_windows(win1_bounds, win2_bounds);
     if (win2 == dragged_window_)
       return !compare_two_windows(win2_bounds, win1_bounds);
@@ skipping 19 matching lines @@
     if (result1 != result2)
       return result1;
 
     // Otherwise it is not possible to be sure that the windows will not bounce.
     // In this case just compare the centers.
     return bounds1.CenterPoint().y() < bounds2.CenterPoint().y();
   }
 
  private:
   aura::Window* dragged_window_;
+  aura::Window* docked_container_;
   float delta_;
 };
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // A class that observes shelf for bounds changes.
 class DockedWindowLayoutManager::ShelfWindowObserver : public WindowObserver {
  public:
   explicit ShelfWindowObserver(
@@ skipping 781 matching lines @@
   if (visible_windows->empty() ||
       (visible_windows->size() == 1 &&
           (*visible_windows)[0].window() == dragged_window_)) {
     new_width = 0;
   }
   UpdateDockedWidth(new_width);
   // Sort windows by their center positions and fan out overlapping
   // windows.
   std::sort(visible_windows->begin(), visible_windows->end(),
             CompareWindowPos(is_dragged_from_dock_ ? dragged_window_ : NULL,
+                             dock_container_,
                              delta));
   for (std::vector<WindowWithHeight>::iterator iter = visible_windows->begin();
        iter != visible_windows->end(); ++iter) {
     aura::Window* window = iter->window();
     gfx::Rect bounds = ScreenUtil::ConvertRectToScreen(
-        window->parent(), window->GetTargetBounds());
+        dock_container_, window->GetTargetBounds());
     // A window is extended or shrunk to be as close as possible to the ideal
     // docked area width. Windows that were resized by a user are kept at their
     // existing size.
     // This also enforces the min / max restrictions on the docked area width.
     bounds.set_width(GetWindowWidthCloseTo(
         window,
         wm::GetWindowState(window)->bounds_changed_by_user() ?
             bounds.width() : ideal_docked_width));
     DCHECK_LE(bounds.width(), ideal_docked_width);
 
@@ skipping 132 matching lines @@
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace internal
 }  // namespace ash