Make cancelling of app list correctly clean up folder UI.

ui/app_list/views/apps_grid_view.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 "ui/app_list/views/apps_grid_view.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
@@ skipping 298 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SynchronousDrag);
 };
 #endif  // defined(OS_WIN)
 
 AppsGridView::AppsGridView(AppsGridViewDelegate* delegate,
                            PaginationModel* pagination_model,
                            content::WebContents* start_page_contents)
     : model_(NULL),
       item_list_(NULL),
       delegate_(delegate),
+      folder_delegate_(NULL),
       pagination_model_(pagination_model),
       page_switcher_view_(new PageSwitcher(pagination_model)),
       start_page_view_(NULL),
       cols_(0),
       rows_per_page_(0),
       selected_view_(NULL),
       drag_view_(NULL),
       drag_start_page_(-1),
       drag_pointer_(NONE),
       drop_attempt_(DROP_FOR_NONE),
       drag_and_drop_host_(NULL),
       forward_events_to_drag_and_drop_host_(false),
       page_flip_target_(-1),
       page_flip_delay_in_ms_(kPageFlipDelayInMs),
       bounds_animator_(this),
-      is_root_level_(true),
       activated_item_view_(NULL),
       dragging_for_reparent_item_(false) {
   SetPaintToLayer(true);
   SetFillsBoundsOpaquely(false);
 
   pagination_model_->AddObserver(this);
   AddChildView(page_switcher_view_);
 
   if (start_page_contents) {
     start_page_view_ =
@@ skipping 147 matching lines @@
     synchronous_drag_->EndDragExternally();
 
   synchronous_drag_ = NULL;
 #endif
 }
 
 bool AppsGridView::UpdateDragFromItem(Pointer pointer,
                                       const ui::LocatedEvent& event) {
   DCHECK(drag_view_);
 
-  if (!is_root_level_)
+  if (folder_delegate_)
     UpdateDragStateInsideFolder(pointer, event);
 
   gfx::Point drag_point_in_grid_view;
   ExtractDragLocation(event, &drag_point_in_grid_view);
   UpdateDrag(pointer, drag_point_in_grid_view);
   if (!dragging())
     return false;
 
   // If a drag and drop host is provided, see if the drag operation needs to be
   // forwarded.
@@ skipping 75 matching lines @@
   // EndDrag was called before if |drag_view_| is NULL.
   if (!drag_view_)
     return;
 
   // Coming here a drag and drop was in progress.
   bool landed_in_drag_and_drop_host = forward_events_to_drag_and_drop_host_;
   if (forward_events_to_drag_and_drop_host_) {
     DCHECK(!IsDraggingForReparentInRootLevelGridView());
     forward_events_to_drag_and_drop_host_ = false;
     drag_and_drop_host_->EndDrag(cancel);
     if (IsDraggingForReprentInHiddenGridView()) {

[tapted, 2014/03/26 02:53:54]

nit: doesn't need curlies

[calamity, 2014/03/27 05:14:44]

Done.

-      static_cast<AppListFolderView*>(parent())->
-          DispatchEndDragEventForReparent(true);
+      folder_delegate_->DispatchEndDragEventForReparent(true);
     }
   } else if (!cancel && dragging()) {
     if (IsDraggingForReprentInHiddenGridView()) {
       // Forward the EndDrag event to the root level grid view.
-      static_cast<AppListFolderView*>(parent())->
-          DispatchEndDragEventForReparent(false);
+      folder_delegate_->DispatchEndDragEventForReparent(false);
       EndDragForReparentInHiddenFolderGridView();
       return;
     } else {
       // Regular drag ending path, ie, not for reparenting.
       CalculateDropTarget(last_drag_point_, true);
       if (IsValidIndex(drop_target_)) {
         if (!EnableFolderDragDropUI()) {
             MoveItemInModel(drag_view_, drop_target_);
         } else {
           if (drop_attempt_ == DROP_FOR_REORDER)
@@ skipping 34 matching lines @@
   drag_view_ = NULL;
   drag_start_grid_view_ = gfx::Point();
   drag_start_page_ = -1;
   drag_view_offset_ = gfx::Point();
   AnimateToIdealBounds();
 
   StopPageFlipTimer();
 
   // If user releases mouse inside a folder's grid view, burst the folder
   // container ink bubble.
-  if (!cancel && !is_root_level_ && !IsDraggingForReprentInHiddenGridView()) {
-    static_cast<AppListFolderView*>(parent())->
-        UpdateFolderViewBackground(false);
-  }
+  if (folder_delegate_ && !IsDraggingForReprentInHiddenGridView())

[tapted, 2014/03/26 02:53:54]

there's a typo in this function name: Reprent -> Reparent

[jennyz, 2014/03/26 22:09:38]

This change will crash chrome on chromeos, since this code path is called from
the stack destroying the app launcher bubble when esc is pressed, which is
originated from AppListView::Close(). At this point AppListFolderView has been
destroyed, thus, crash!

This exposes a bug in the ContentView::CancelDrag(). We did not cancel drag in
the folder view's grid view. We need to add the following code in the after the
existing lines, the it will works fine with your change:
  if (apps_container_view_->app_list_folder_view()
          ->items_grid_view()
          ->has_dragged_view()) {
    apps_container_view_->app_list_folder_view()->items_grid_view()->EndDrag(
        true);
  }

[calamity, 2014/03/27 05:14:44]

Done.

[calamity, 2014/03/27 05:14:44]

Cool, thanks for fixing that.

+    folder_delegate_->UpdateFolderViewBackground(false);
 
   if (IsDraggingForReprentInHiddenGridView())
     dragging_for_reparent_item_ = false;
 }
 
 void AppsGridView::StopPageFlipTimer() {
   page_flip_timer_.Stop();
   page_flip_target_ = -1;
 }
 
@@ skipping 614 matching lines @@
     drop_target_ = GetNearestTileForDragView();
   }
 }
 
 void AppsGridView::OnReorderTimer() {
   if (drop_attempt_ == DROP_FOR_REORDER)
     AnimateToIdealBounds();
 }
 
 void AppsGridView::OnFolderItemReparentTimer() {
-  DCHECK(!is_root_level_);
+  DCHECK(folder_delegate_);
   if (drag_out_of_folder_container_) {
-    static_cast<AppListFolderView*>(parent())->ReparentItem(
-        drag_view_, last_drag_point_);
+    folder_delegate_->ReparentItem(drag_view_, last_drag_point_);
 
     // Set the flag in the folder's grid view.
     dragging_for_reparent_item_ = true;
 
     // Do not observe any data change since it is going to be hidden.
     item_list_->RemoveObserver(this);
     item_list_ = NULL;
   }
 }
 
 void AppsGridView::OnFolderDroppingTimer() {
   if (drop_attempt_ == DROP_FOR_FOLDER)
     SetAsFolderDroppingTarget(drop_target_, true);
 }
 
 void AppsGridView::UpdateDragStateInsideFolder(
     Pointer pointer,
     const ui::LocatedEvent& event) {
   if (IsDraggingForReprentInHiddenGridView()) {
     // Dispatch drag event to root level grid view for re-parenting folder
     // folder item purpose.
     DispatchDragEventForReparent(pointer, event);
     return;
   }
 
   // Regular drag and drop in a folder's grid view.
-  AppListFolderView* folder_view = static_cast<AppListFolderView*>(parent());
-  folder_view->UpdateFolderViewBackground(true);
+  folder_delegate_->UpdateFolderViewBackground(true);
 
   // Calculate if the drag_view_ is dragged out of the folder's container
   // ink bubble.
   gfx::Rect bounds_to_folder_view = ConvertRectToParent(drag_view_->bounds());
   gfx::Point pt = bounds_to_folder_view.CenterPoint();
   bool is_item_dragged_out_of_folder =
-      folder_view->IsPointOutsideOfFolderBoundray(pt);
+      folder_delegate_->IsPointOutsideOfFolderBoundary(pt);
   if (is_item_dragged_out_of_folder) {
     if (!drag_out_of_folder_container_) {
       folder_item_reparent_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(kFolderItemReparentDealy),
           this, &AppsGridView::OnFolderItemReparentTimer);
       drag_out_of_folder_container_ = true;
     }
   } else {
     folder_item_reparent_timer_.Stop();
     drag_out_of_folder_container_ = false;
   }
 }
 
 bool AppsGridView::IsDraggingForReparentInRootLevelGridView() const {
-  return (is_root_level_ && dragging_for_reparent_item_);
+  return (!folder_delegate_ && dragging_for_reparent_item_);
 }
 
 bool AppsGridView::IsDraggingForReprentInHiddenGridView() const {
-  return (!is_root_level_ && dragging_for_reparent_item_);
+  return (folder_delegate_ && dragging_for_reparent_item_);
 }
 
 gfx::Rect AppsGridView::GetTargetIconRectInFolder(
     AppListItemView* drag_item_view,
     AppListItemView* folder_item_view) {
   gfx::Rect view_ideal_bounds = view_model_.ideal_bounds(
       view_model_.GetIndexOfView(folder_item_view));
   gfx::Rect icon_ideal_bounds =
       folder_item_view->GetIconBoundsForTargetViewBounds(view_ideal_bounds);
   AppListFolderItem* folder_item =
       static_cast<AppListFolderItem*>(folder_item_view->item());
   return folder_item->GetTargetIconRectInFolderForItem(
       drag_item_view->item(), icon_ideal_bounds);
 }
 
 void AppsGridView::DispatchDragEventForReparent(
     Pointer pointer,
     const ui::LocatedEvent& event) {
-  static_cast<AppListFolderView*>(parent())->
-      DispatchDragEventForReparent(pointer, event);
+  folder_delegate_->DispatchDragEventForReparent(pointer, event);
 }
 
 void AppsGridView::EndDragFromReparentItemInRootLevel(
     bool events_forwarded_to_drag_drop_host) {
   // EndDrag was called before if |drag_view_| is NULL.
   if (!drag_view_)
     return;
 
   DCHECK(IsDraggingForReparentInRootLevelGridView());
   bool cancel_reparent = false;
@@ skipping 62 matching lines @@
   drop_target_ = Index();
   drag_view_->OnDragEnded();
   drag_view_ = NULL;
   drag_start_grid_view_ = gfx::Point();
   drag_start_page_ = -1;
   drag_view_offset_ = gfx::Point();
   dragging_for_reparent_item_ = false;
 }
 
 void AppsGridView::OnFolderItemRemoved() {
-  DCHECK(!is_root_level_);
+  DCHECK(folder_delegate_);
   item_list_ = NULL;
 }
 
 void AppsGridView::StartDragAndDropHostDrag(const gfx::Point& grid_location) {
   // When a drag and drop host is given, the item can be dragged out of the app
   // list window. In that case a proxy widget needs to be used.
   // Note: This code has very likely to be changed for Windows (non metro mode)
   // when a |drag_and_drop_host_| gets implemented.
   if (!drag_view_ || !drag_and_drop_host_)
     return;
@@ skipping 423 matching lines @@
 }
 
 void AppsGridView::OnImplicitAnimationsCompleted() {
   if (layer()->opacity() == 0.0f)
     SetVisible(false);
 }
 
 bool AppsGridView::EnableFolderDragDropUI() {
   // Enable drag and drop folder UI only if it is at the app list root level
   // and the switch is on and the target folder can still accept new items.
-  return switches::IsFolderUIEnabled() && is_root_level_ &&
-      CanDropIntoTarget(drop_target_);
+  return switches::IsFolderUIEnabled() && !folder_delegate_ &&
+         CanDropIntoTarget(drop_target_);
 }
 
 bool AppsGridView::CanDropIntoTarget(const Index& drop_target) {
   views::View* target_view = GetViewAtSlotOnCurrentPage(drop_target.slot);
   if (!target_view)
     return true;
 
   AppListItem* target_item =
       static_cast<AppListItemView*>(target_view)->item();
   // Items can be dropped into non-folders (which have no children) or folders
@@ skipping 166 matching lines @@
 void AppsGridView::SetAsFolderDroppingTarget(const Index& target_index,
                                              bool is_target_folder) {
   AppListItemView* target_view =
       static_cast<AppListItemView*>(
           GetViewAtSlotOnCurrentPage(target_index.slot));
   if (target_view)
     target_view->SetAsAttemptedFolderTarget(is_target_folder);
 }
 
 }  // namespace app_list