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

ash/wm/dock/docked_window_resizer.cc

 // Copyright 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_resizer.h"
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/root_window_controller.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/dock/docked_window_layout_manager.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/workspace/magnetism_matcher.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "base/command_line.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 internal {
 
 namespace {
 
 DockedWindowLayoutManager* GetDockedLayoutManagerAtPoint(
     const gfx::Point& point) {
   aura::Window* dock_container = Shell::GetContainer(
       wm::GetRootWindowAt(point),
       kShellWindowId_DockedContainer);
   return static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
 }
 
 }  // namespace
 
 DockedWindowResizer::~DockedWindowResizer() {
-  if (destroyed_)
-    *destroyed_ = true;
 }
 
 // static
 DockedWindowResizer*
 DockedWindowResizer::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 DockedWindowResizer(next_window_resizer, details) : NULL;
 }
 
 void DockedWindowResizer::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();
   }
   gfx::Point offset;
   gfx::Rect bounds(CalculateBoundsForDrag(details_, location));
   bool set_tracked_by_workspace = MaybeSnapToEdge(bounds, &offset);
 
   // Temporarily clear kWindowTrackedByWorkspaceKey for windows that are snapped
   // to screen edges e.g. when they are docked. This prevents the windows from
   // getting snapped to other nearby windows during the drag.
   bool tracked_by_workspace = GetTrackedByWorkspace(GetTarget());
   if (set_tracked_by_workspace)
     SetTrackedByWorkspace(GetTarget(), false);
   gfx::Point modified_location(location.x() + offset.x(),
                                location.y() + offset.y());
-  destroyed_ = &destroyed;
+
+  base::WeakPtr<DockedWindowResizer> resizer(weak_ptr_factory_.GetWeakPtr());
   next_window_resizer_->Drag(modified_location, event_flags);
+  if (!resizer)
+    return;
 
-  // TODO(varkha): 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 (set_tracked_by_workspace)
     SetTrackedByWorkspace(GetTarget(), tracked_by_workspace);
 
   DockedWindowLayoutManager* new_dock_layout =
       GetDockedLayoutManagerAtPoint(last_location_);
   if (new_dock_layout != dock_layout_) {
     // The window is being dragged to a new display. If the previous
     // container is the current parent of the window it will be informed of
     // the end of drag when the window is reparented, otherwise let the
     // previous container know the drag is complete. If we told the
@@ skipping 73 matching lines @@
 
 DockedWindowResizer::DockedWindowResizer(WindowResizer* next_window_resizer,
                                          const Details& details)
     : details_(details),
       next_window_resizer_(next_window_resizer),
       dock_layout_(NULL),
       initial_dock_layout_(NULL),
       did_move_or_resize_(false),
       was_docked_(false),
       is_docked_(false),
-      destroyed_(NULL) {
+      weak_ptr_factory_(this) {
   DCHECK(details_.is_resizable);
   aura::Window* dock_container = Shell::GetContainer(
       details.window->GetRootWindow(),
       kShellWindowId_DockedContainer);
   dock_layout_ = static_cast<DockedWindowLayoutManager*>(
       dock_container->layout_manager());
   initial_dock_layout_ = dock_layout_;
   was_docked_ = details.window->parent() == dock_container;
   is_docked_ = was_docked_;
 }
@@ skipping 152 matching lines @@
 
   if (!snap_phantom_window_controller_) {
     snap_phantom_window_controller_.reset(
         new PhantomWindowController(GetTarget()));
   }
   snap_phantom_window_controller_->Show(dock_layout_->dragged_bounds());
 }
 
 }  // namespace internal
 }  // namespace ash