Use a weak pointer to determine if resizer was destroyed by nested Drag calls.

ash/wm/panels/panel_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/panels/panel_window_resizer.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/panels/panel_layout_manager.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_properties.h"
+#include "base/memory/weak_ptr.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 
 namespace {
 const int kPanelSnapToLauncherDistance = 30;
 
 internal::PanelLayoutManager* GetPanelLayoutManager(
     aura::Window* panel_container) {
   DCHECK(panel_container->id() == internal::kShellWindowId_PanelContainer);
   return static_cast<internal::PanelLayoutManager*>(
       panel_container->layout_manager());
 }
 
 }  // namespace
 
 PanelWindowResizer::~PanelWindowResizer() {
-  if (destroyed_)
-    *destroyed_ = true;
 }
 
 // static
 PanelWindowResizer*
 PanelWindowResizer::Create(WindowResizer* next_window_resizer,
                            aura::Window* window,
                            const gfx::Point& location,
                            int window_component,
                            aura::client::WindowMoveSource source) {
   Details details(window, location, window_component, source);
   return details.is_resizable ?
       new PanelWindowResizer(next_window_resizer, details) : NULL;
 }
 
 void PanelWindowResizer::Drag(const gfx::Point& location, int event_flags) {
   last_location_ = location;
   wm::ConvertPointToScreen(GetTarget()->parent(), &last_location_);
-  bool destroyed = false;
   if (!did_move_or_resize_) {
     did_move_or_resize_ = true;
     StartedDragging();
   }
 
   // Check if the destination has changed displays.
   gfx::Screen* screen = Shell::GetScreen();
   const gfx::Display dst_display =
       screen->GetDisplayNearestPoint(last_location_);
   if (dst_display.id() !=
@@ skipping 13 matching lines @@
     // The panel's parent already knows that the drag is in progress for this
     // panel.
     if (panel_container_ && GetTarget()->parent() != panel_container_)
       GetPanelLayoutManager(panel_container_)->StartDragging(GetTarget());
   }
   gfx::Point offset;
   gfx::Rect bounds(CalculateBoundsForDrag(details_, location));
   should_attach_ = AttachToLauncher(bounds, &offset);
   gfx::Point modified_location(location.x() + offset.x(),
                                location.y() + offset.y());
-  destroyed_ = &destroyed;
+
+  base::WeakPtr<PanelWindowResizer> resizer(weak_ptr_factory_.GetWeakPtr());
   next_window_resizer_->Drag(modified_location, event_flags);
+  if (!resizer)
+    return;
 
-  // TODO(flackr): Refactor the way WindowResizer calls into other window
-  // resizers to avoid the awkward pattern here for checking if
-  // next_window_resizer_ destroys the resizer object.
-  if (destroyed)
-    return;
-  destroyed_ = NULL;
   if (should_attach_ &&
       !(details_.bounds_change & WindowResizer::kBoundsChange_Resizes)) {
     UpdateLauncherPosition();
   }
 }
 
 void PanelWindowResizer::CompleteDrag(int event_flags) {
   // The root window can change when dragging into a different screen.
   next_window_resizer_->CompleteDrag(event_flags);
   FinishDragging();
@@ skipping 15 matching lines @@
 
 PanelWindowResizer::PanelWindowResizer(WindowResizer* next_window_resizer,
                                        const Details& details)
     : details_(details),
       next_window_resizer_(next_window_resizer),
       panel_container_(NULL),
       initial_panel_container_(NULL),
       did_move_or_resize_(false),
       was_attached_(GetTarget()->GetProperty(internal::kPanelAttachedKey)),
       should_attach_(was_attached_),
-      destroyed_(NULL) {
+      weak_ptr_factory_(this) {
   DCHECK(details_.is_resizable);
   panel_container_ = Shell::GetContainer(
       details.window->GetRootWindow(),
       internal::kShellWindowId_PanelContainer);
   initial_panel_container_ = panel_container_;
 }
 
 bool PanelWindowResizer::AttachToLauncher(const gfx::Rect& bounds,
                                           gfx::Point* offset) {
   bool should_attach = false;
@@ skipping 78 matching lines @@
 }
 
 void PanelWindowResizer::UpdateLauncherPosition() {
   if (panel_container_) {
     GetPanelLayoutManager(panel_container_)->launcher()->
         UpdateIconPositionForWindow(GetTarget());
   }
 }
 
 }  // namespace aura