Implement ui for re-parenting an item from an app list folder to another position or folder in the …

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>
 
 #include "base/guid.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/pagination_model.h"
 #include "ui/app_list/views/app_list_drag_and_drop_host.h"
 #include "ui/app_list/views/app_list_folder_view.h"
 #include "ui/app_list/views/app_list_item_view.h"
 #include "ui/app_list/views/apps_grid_view_delegate.h"
 #include "ui/app_list/views/page_switcher.h"
 #include "ui/app_list/views/pulsing_block_view.h"
+#include "ui/app_list/views/top_icon_animation_view.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/root_window.h"
@@ skipping 45 matching lines @@
 
 // The drag and drop proxy should get scaled by this factor.
 const float kDragAndDropProxyScale = 1.5f;
 
 // Delays in milliseconds to show folder dropping preview circle.
 const int kFolderDroppingDelay = 250;
 
 // Delays in milliseconds to show re-order preview.
 const int kReorderDelay = 50;
 
+// Delays in milliseconds to show folder item reparent UI.
+const int kFolderItemReparentDealy = 50;
+
 // Radius of the circle, in which if entered, show folder dropping preview
 // UI.
 const int kFolderDroppingCircleRadius = 15;
 
 // Radius of the circle, in which if entered, show re-order preview.
 const int kReorderDroppingCircleRadius = 30;
 
 // Max items allowed in a folder.
 size_t kMaxFolderItems = 16;
 
@@ skipping 210 matching lines @@
       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) {
+      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_ =
         new views::WebView(start_page_contents->GetBrowserContext());
     start_page_view_->SetWebContents(start_page_contents);
@@ skipping 141 matching lines @@
 void AppsGridView::CleanUpSynchronousDrag() {
 #if defined(OS_WIN)
   synchronous_drag_ = NULL;
 #endif
 }
 
 void AppsGridView::UpdateDragFromItem(Pointer pointer,
                                       const ui::LocatedEvent& event) {
   DCHECK(drag_view_);
 
+  if (!is_root_level_)
+    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;
 
   // If a drag and drop host is provided, see if the drag operation needs to be
   // forwarded.
   gfx::Point location_in_screen = drag_point_in_grid_view;
   views::View::ConvertPointToScreen(this, &location_in_screen);
@@ skipping 10 matching lines @@
   if (RunSynchronousDrag())
     return;
 
   gfx::Vector2d drag_vector(point - drag_start_grid_view_);
   if (!dragging() && ExceededDragThreshold(drag_vector)) {
     drag_pointer_ = pointer;
     // Move the view to the front so that it appears on top of other views.
     ReorderChildView(drag_view_, -1);
     bounds_animator_.StopAnimatingView(drag_view_);
     StartSettingUpSynchronousDrag();
-    StartDragAndDropHostDrag(point);
+    if (!dragging_for_reparent_item_)
+      StartDragAndDropHostDrag(point);
   }
 
   if (drag_pointer_ != pointer)
     return;
 
   last_drag_point_ = point;
   const Index last_drop_target = drop_target_;
   DropAttempt last_drop_attempt = drop_attempt_;
   CalculateDropTarget(last_drag_point_, false);
 
@@ skipping 33 matching lines @@
     SetAsFolderDroppingTarget(last_drop_target, false);
   }
 
   drag_view_->SetPosition(drag_view_start_ + drag_vector);
 }
 
 void AppsGridView::EndDrag(bool cancel) {
   // 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()) {
+      static_cast<AppListFolderView*>(parent())->
+          DispatchEndDragEventForReparent(true);
+    }
   } else if (!cancel && dragging()) {
-    CalculateDropTarget(last_drag_point_, true);
-    if (IsValidIndex(drop_target_)) {
-      if (!EnableFolderDragDropUI()) {
-          MoveItemInModel(drag_view_, drop_target_);
-      } else {
-        if (drop_attempt_ == DROP_FOR_REORDER)
-          MoveItemInModel(drag_view_, drop_target_);
-        else if (drop_attempt_ == DROP_FOR_FOLDER)
-          MoveItemToFolder(drag_view_, drop_target_);
+    if (IsDraggingForReprentInHiddenGridView()) {
+      // Forward the EndDrag event to the root level grid view.
+      static_cast<AppListFolderView*>(parent())->
+          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)
+            MoveItemInModel(drag_view_, drop_target_);
+          else if (drop_attempt_ == DROP_FOR_FOLDER)
+            MoveItemToFolder(drag_view_, drop_target_);
+        }
       }
     }
   }
 
   if (drag_and_drop_host_) {
     // If we had a drag and drop proxy icon, we delete it and make the real
     // item visible again.
     drag_and_drop_host_->DestroyDragIconProxy();
     if (landed_in_drag_and_drop_host) {
       // Move the item directly to the target location, avoiding the "zip back"
       // animation if the user was pinning it to the shelf.
       int i = drop_target_.slot;
       gfx::Rect bounds = view_model_.ideal_bounds(i);
       drag_view_->SetBoundsRect(bounds);
     }
     // Fade in slowly if it landed in the shelf.
     SetViewHidden(drag_view_,
-             false /* hide */,
-             !landed_in_drag_and_drop_host /* animate */);
+                  false /* show */,
+                  !landed_in_drag_and_drop_host /* animate */);
   }
 
   // The drag can be ended after the synchronous drag is created but before it
   // is Run().
   CleanUpSynchronousDrag();
 
   SetAsFolderDroppingTarget(drop_target_, false);
   drop_attempt_ = DROP_FOR_NONE;
   drag_pointer_ = NONE;
   drop_target_ = Index();
   drag_view_->OnDragEnded();
   drag_view_ = NULL;
   drag_start_grid_view_ = gfx::Point();
   drag_start_page_ = -1;
   drag_view_offset_ = gfx::Point();
+  if (IsDraggingForReprentInHiddenGridView())
+    dragging_for_reparent_item_ = false;
   AnimateToIdealBounds();
 
   StopPageFlipTimer();
+
+  // If user releases mouse inside a folder's grid view, burst the folder
+  // container ink bubble.
+  if (!is_root_level_ && !IsDraggingForReprentInHiddenGridView()) {
+    static_cast<AppListFolderView*>(parent())->
+        UpdateFolderViewBackground(false);
+  }
 }
 
 void AppsGridView::StopPageFlipTimer() {
   page_flip_timer_.Stop();
   page_flip_target_ = -1;
 }
 
 AppListItemView* AppsGridView::GetItemViewAt(int index) const {
   DCHECK(index >= 0 && index < view_model_.view_size());
   return static_cast<AppListItemView*>(view_model_.view_at(index));
@@ skipping 16 matching lines @@
 
   ui::ScopedLayerAnimationSettings animation(layer()->GetAnimator());
   animation.AddObserver(this);
   animation.SetTweenType(gfx::Tween::EASE_IN_2);
   animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
       show ? kFolderTransitionInDurationMs : kFolderTransitionOutDurationMs));
 
   layer()->SetOpacity(show ? 1.0f : 0.0f);
 }
 
+void AppsGridView::InitiateDragFromReparentItemInRootLevelGridView(
+    AppListItemView* original_drag_view,
+    const gfx::Rect& drag_view_rect,
+    const gfx::Point& drag_point) {
+  DCHECK(original_drag_view && !drag_view_);
+  DCHECK(!dragging_for_reparent_item_);
+
+  // Create a new AppListItemView to duplicate the original_drag_view in the
+  // folder's grid view.
+  AppListItemView* view = new AppListItemView(this, original_drag_view->item());
+  AddChildView(view);
+  drag_view_ = view;
+  drag_view_->SetPaintToLayer(true);
+  // Note: For testing purpose, SetFillsBoundsOpaquely can be set to true to
+  // show the gray background.
+  drag_view_->SetFillsBoundsOpaquely(false);
+  drag_view_->SetIconSize(icon_size_);
+  drag_view_->SetBoundsRect(drag_view_rect);
+  drag_view_->SetDragUIState();  // Hide the title of the drag_view_.
+
+  // Hide the drag_view_ for drag icon proxy.
+  SetViewHidden(drag_view_,
+                true /* hide */,
+                true /* no animate */);
+
+  // Add drag_view_ to the end of the view_model_.
+  view_model_.Add(drag_view_, view_model_.view_size());
+
+  drag_start_page_ = pagination_model_->selected_page();
+  drag_start_grid_view_ = drag_point;
+
+  drag_view_start_ = gfx::Point(drag_view_->x(), drag_view_->y());
+
+  // Set the flag in root level grid view.
+  dragging_for_reparent_item_ = true;
+}
+
+void AppsGridView::UpdateDragFromReparentItem(
+    Pointer pointer,
+    const ui::LocatedEvent& event) {
+  DCHECK(drag_view_);
+  DCHECK(IsDraggingForReparentInRootLevelGridView());
+
+  gfx::Point drag_point_in_grid_view;
+  ExtractDragLocation(event, &drag_point_in_grid_view);
+  UpdateDrag(pointer, drag_point_in_grid_view);
+}
+
 bool AppsGridView::IsDraggedView(const views::View* view) const {
   return drag_view_ == view;
 }
 
 void AppsGridView::SetDragAndDropHostOfCurrentAppList(
     ApplicationDragAndDropHost* drag_and_drop_host) {
   drag_and_drop_host_ = drag_and_drop_host;
 }
 
 void AppsGridView::Prerender(int page_index) {
@@ skipping 532 matching lines @@
     // Try to find the nearest target for folder dropping or re-ordering.
     drop_target_ = GetNearestTileForDragView();
   }
 }
 
 void AppsGridView::OnReorderTimer() {
   if (drop_attempt_ == DROP_FOR_REORDER)
     AnimateToIdealBounds();
 }
 
+void AppsGridView::OnFolderItemReparentTimer() {
+  DCHECK(!is_root_level_);
+  if (drag_out_of_folder_container_) {
+    static_cast<AppListFolderView*>(parent())->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);
+
+  // 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);
+  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_);
+}
+
+bool AppsGridView::IsDraggingForReprentInHiddenGridView() const {
+  return (!is_root_level_ && 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);
+}
+
+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;
+  scoped_ptr<AppListItemView> cached_drag_view;
+  if (!events_forwarded_to_drag_drop_host) {
+    CalculateDropTarget(last_drag_point_, true);
+    if (IsValidIndex(drop_target_)) {
+      if (drop_attempt_ == DROP_FOR_REORDER)
+        ReparentItemForReorder(drag_view_, drop_target_);
+      else if (drop_attempt_ == DROP_FOR_FOLDER)
+        ReparentItemToAnotherFolder(drag_view_, drop_target_);
+      else {      // DROP_FOR_NONE_
+        cancel_reparent = true;
+        // Note(jennyz): cached_drag_view makes sure drag_view_ will be deleted
+        // after AnimateToIdealBounds() is called.
+        // There is a problem in layer() animation which cause DCHECK failure
+        // if a child view is deleted immediately before re-creating layer in
+        // layer animation. The layer tree seems marked dirty, and complaining
+        // when we try to re-create layer in AnimationBetweenRows when calling
+        // AnimateToIdealBounds.
+        cached_drag_view.reset(drag_view_);
+      }
+    }
+
+    if (!cancel_reparent) {
+      SetViewHidden(drag_view_,
+          false /* show */,
+          true  /* no animate */);
+    }
+  }
+
+  // The drag can be ended after the synchronous drag is created but before it
+  // is Run().
+  CleanUpSynchronousDrag();
+
+  SetAsFolderDroppingTarget(drop_target_, false);
+  drop_attempt_ = DROP_FOR_NONE;
+  drag_pointer_ = NONE;
+  drop_target_ = Index();
+  if (!cancel_reparent)
+    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;
+  if (cancel_reparent)
+    CancelFolderItemReparent(cached_drag_view.get());
+  AnimateToIdealBounds();
+
+  StopPageFlipTimer();
+}
+
+void AppsGridView::EndDragForReparentInHiddenFolderGridView() {
+  if (drag_and_drop_host_) {
+    // If we had a drag and drop proxy icon, we delete it and make the real
+    // item visible again.
+    drag_and_drop_host_->DestroyDragIconProxy();
+  }
+
+  // The drag can be ended after the synchronous drag is created but before it
+  // is Run().
+  CleanUpSynchronousDrag();
+
+  SetAsFolderDroppingTarget(drop_target_, false);
+  drop_attempt_ = DROP_FOR_NONE;
+  drag_pointer_ = NONE;
+  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_);
+  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;
 
   gfx::Point screen_location = grid_location;
   views::View::ConvertPointToScreen(this, &screen_location);
 
   // Determine the mouse offset to the center of the icon so that the drag and
   // drop host follows this layer.
   gfx::Vector2d delta = drag_view_offset_ -
                         drag_view_->GetLocalBounds().CenterPoint();
   delta.set_y(delta.y() + drag_view_->title()->size().height() / 2);
 
   // We have to hide the original item since the drag and drop host will do
   // the OS dependent code to "lift off the dragged item".
+  DCHECK(!IsDraggingForReparentInRootLevelGridView());
   drag_and_drop_host_->CreateDragIconProxy(screen_location,
                                            drag_view_->item()->icon(),
                                            drag_view_,
                                            delta,
                                            kDragAndDropProxyScale);
   SetViewHidden(drag_view_,
            true /* hide */,
            true /* no animation */);
 }
 
 void AppsGridView::DispatchDragEventToDragAndDropHost(
     const gfx::Point& location_in_screen_coordinates) {
   if (!drag_view_ || !drag_and_drop_host_)
     return;
-  if (bounds().Contains(last_drag_point_)) {
+
+  if (GetLocalBounds().Contains(last_drag_point_)) {
     // The event was issued inside the app menu and we should get all events.
     if (forward_events_to_drag_and_drop_host_) {
       // The DnD host was previously called and needs to be informed that the
       // session returns to the owner.
       forward_events_to_drag_and_drop_host_ = false;
       drag_and_drop_host_->EndDrag(true);
     }
   } else {
     // The event happened outside our app menu and we might need to dispatch.
     if (forward_events_to_drag_and_drop_host_) {
@@ skipping 70 matching lines @@
   item_list_->MoveItem(current_model_index, target_model_index);
   view_model_.Move(current_model_index, target_model_index);
   item_list_->AddObserver(this);
 
   if (pagination_model_->selected_page() != target.page)
     pagination_model_->SelectPage(target.page, false);
 }
 
 void AppsGridView::MoveItemToFolder(views::View* item_view,
                                     const Index& target) {
-  const std::string& source_id =
+  const std::string& source_item_id =
       static_cast<AppListItemView*>(item_view)->item()->id();
   AppListItemView* target_view =
       static_cast<AppListItemView*>(GetViewAtSlotOnCurrentPage(target.slot));
-  const std::string& target_id = target_view->item()->id();
+  const std::string&  target_view_item_id = target_view->item()->id();
 
   // Make change to data model.
   item_list_->RemoveObserver(this);
-  std::string folder_id = model_->MergeItems(target_id, source_id);
+
+  std::string folder_item_id =
+      model_->MergeItems(target_view_item_id, source_item_id);
   item_list_->AddObserver(this);
 
-  if (folder_id != target_id) {
+  if (folder_item_id != target_view_item_id) {
     // New folder was created, change the view model to replace the old target
     // view with the new folder item view.
-    size_t folder_index;
-    if (item_list_->FindItemIndex(folder_id, &folder_index)) {
-      int target_index = view_model_.GetIndexOfView(target_view);
-      view_model_.Remove(target_index);
+    size_t folder_item_index;
+    if (item_list_->FindItemIndex(folder_item_id, &folder_item_index)) {
+      int target_view_index = view_model_.GetIndexOfView(target_view);
+      view_model_.Remove(target_view_index);
       delete target_view;
-      views::View* target_folder_view = CreateViewForItemAtIndex(folder_index);
-      view_model_.Add(target_folder_view, target_index);
+      views::View* target_folder_view =
+          CreateViewForItemAtIndex(folder_item_index);
+      view_model_.Add(target_folder_view, target_view_index);
       AddChildView(target_folder_view);
     } else {
-      LOG(ERROR) << "Folder no longer in item_list: " << folder_id;
+      LOG(ERROR) << "Folder no longer in item_list: " << folder_item_id;
     }
   }
 
   // Fade out the drag_view_ and delete it when animation ends.
   int drag_view_index = view_model_.GetIndexOfView(drag_view_);
   view_model_.Remove(drag_view_index);
   bounds_animator_.AnimateViewTo(drag_view_, drag_view_->bounds());
   bounds_animator_.SetAnimationDelegate(
       drag_view_, new ItemRemoveAnimationDelegate(drag_view_), true);
+  UpdatePaging();
+}
 
+void AppsGridView::ReparentItemForReorder(views::View* item_view,
+                                          const Index& target) {
+  item_list_->RemoveObserver(this);
+  model_->RemoveObserver(this);
+
+  AppListItem* reparent_item = static_cast<AppListItemView*>(item_view)->item();
+  DCHECK(reparent_item->IsInFolder());
+  AppListFolderItem* source_folder = static_cast<AppListFolderItem*>(
+        item_list_->FindItem(reparent_item->folder_id()));
+
+  // Move the item from its parent folder to top level item list.
+  // Must move to target_model_index, the location we expect the target item
+  // to be, not the item location we want to insert before.
+  int target_model_index = GetModelIndexFromIndex(target);
+  int current_model_index = view_model_.GetIndexOfView(item_view);
+  syncer::StringOrdinal target_position;
+  if (target_model_index < static_cast<int>(item_list_->item_count()))
+    target_position = item_list_->item_at(target_model_index)->position();
+  model_->MoveItemToFolderAt(reparent_item, "", target_position);
+  view_model_.Move(current_model_index, target_model_index);
+
+  if (source_folder->ChildItemCount() == 1)
+    RemoveLastItemFromReparentItemFolder(source_folder);
+
+  item_list_->AddObserver(this);
+  model_->AddObserver(this);
   UpdatePaging();
 }
 
+void AppsGridView::ReparentItemToAnotherFolder(views::View* item_view,
+                                               const Index& target) {
+  DCHECK(IsDraggingForReparentInRootLevelGridView());
+
+  // Make change to data model.
+  item_list_->RemoveObserver(this);
+
+  AppListItem* reparent_item = static_cast<AppListItemView*>(item_view)->item();
+  DCHECK(reparent_item->IsInFolder());
+  AppListFolderItem* source_folder = static_cast<AppListFolderItem*>(
+      item_list_->FindItem(reparent_item->folder_id()));
+
+  AppListItemView* target_view =
+      static_cast<AppListItemView*>(GetViewAtSlotOnCurrentPage(target.slot));
+  AppListItem* target_item = target_view->item();
+
+  // Move item to the target folder.
+  const std::string& target_id_after_merge =
+      model_->MergeItems(target_item->id(), reparent_item->id());
+
+  if (target_id_after_merge != target_item->id()) {
+    // New folder was created, change the view model to replace the old target
+    // view with the new folder item view.
+    const std::string& new_folder_id = reparent_item->folder_id();
+    size_t new_folder_index;
+    if (item_list_->FindItemIndex(new_folder_id, &new_folder_index)) {
+      int target_view_index = view_model_.GetIndexOfView(target_view);
+      view_model_.Remove(target_view_index);
+      delete target_view;
+      views::View* new_folder_view =
+          CreateViewForItemAtIndex(new_folder_index);
+      view_model_.Add(new_folder_view, target_view_index);
+      AddChildView(new_folder_view);
+    } else {
+      LOG(ERROR) << "Folder no longer in item_list: " << new_folder_id;
+    }
+  }
+
+  if (source_folder->ChildItemCount() == 1)
+    RemoveLastItemFromReparentItemFolder(source_folder);
+
+  item_list_->AddObserver(this);
+
+  // Fade out the drag_view_ and delete it when animation ends.
+  int drag_view_index = view_model_.GetIndexOfView(drag_view_);
+  view_model_.Remove(drag_view_index);
+  bounds_animator_.AnimateViewTo(drag_view_, drag_view_->bounds());
+  bounds_animator_.SetAnimationDelegate(
+      drag_view_, new ItemRemoveAnimationDelegate(drag_view_), true);
+  UpdatePaging();
+}
+
+// After moving the re-parenting item out of the folder, if there is only 1 item
+// left, remove the last item out of the folder, delete the folder and insert it
+// to the data model at the same position. Make the same change to view_model_
+// accordingly.
+void AppsGridView::RemoveLastItemFromReparentItemFolder(
+    AppListFolderItem* source_folder) {
+  DCHECK(source_folder->ChildItemCount() == 1);
+
+  // Delete view associated with the folder item to be removed.
+  AppListItemView* folder_item_view = activated_item_view();
+  int folder_model_index = view_model_.GetIndexOfView(folder_item_view);
+  view_model_.Remove(folder_model_index);
+  delete folder_item_view;
+
+  // Now make the data change to remove the folder item in model.
+  AppListItem* last_item = source_folder->item_list()->item_at(0);
+  model_->MoveItemToFolderAt(last_item, "", source_folder->position());
+
+  // Create a new item view for the last item in folder.
+  size_t last_item_index;
+  item_list_->FindItemIndex(last_item->id(), &last_item_index);
+  views::View* last_item_view = CreateViewForItemAtIndex(last_item_index);
+  view_model_.Add(last_item_view, last_item_index);
+  AddChildView(last_item_view);
+}
+
+void AppsGridView::CancelFolderItemReparent(AppListItemView* drag_item_view) {
+  // The icon of the dragged item must target to its final ideal bounds after
+  // the animation completes.
+  CalculateIdealBounds();
+
+  // Remove drag_view_ from view_model_, it will be deleted after the animation.
+  int drag_view_index = view_model_.GetIndexOfView(drag_item_view);
+  view_model_.Remove(drag_view_index);
+
+  gfx::Rect target_icon_rect =
+      GetTargetIconRectInFolder(drag_item_view, activated_item_view_);
+
+  gfx::Rect drag_view_icon_to_grid =
+      drag_item_view->ConvertRectToParent(drag_item_view->GetIconBounds());
+  drag_view_icon_to_grid.ClampToCenteredSize(
+        gfx::Size(kPreferredIconDimension, kPreferredIconDimension));
+  TopIconAnimationView* icon_view = new TopIconAnimationView(
+      drag_item_view->item()->icon(),
+      target_icon_rect,
+      false);    /* animate like closing folder */
+  AddChildView(icon_view);
+  icon_view->SetBoundsRect(drag_view_icon_to_grid);
+  icon_view->TransformView();
+}
+
 void AppsGridView::CancelContextMenusOnCurrentPage() {
   int start = pagination_model_->selected_page() * tiles_per_page();
   int end = std::min(view_model_.view_size(), start + tiles_per_page());
   for (int i = start; i < end; ++i) {
     AppListItemView* view =
         static_cast<AppListItemView*>(view_model_.view_at(i));
     view->CancelContextMenu();
   }
 }
 
@@ skipping 194 matching lines @@
       return nearest_tile;
     }
   }
 
   // If |drag_view| is not entering the re-order or fold dropping region of
   // any items, cancel any previous re-order or folder dropping timer, and
   // return itself.
   drop_attempt_ = DROP_FOR_NONE;
   reorder_timer_.Stop();
   folder_dropping_timer_.Stop();
+
+  // When dragging for reparent a folder item, it should go back to its parent
+  // folder item if there is no drop target.
+  if (IsDraggingForReparentInRootLevelGridView()) {
+    DCHECK(activated_item_view_);
+    return GetIndexOfView(activated_item_view_);
+  }
+
   return GetIndexOfView(drag_view_);
 }
 
 void AppsGridView::CalculateNearestTileForVertex(const gfx::Point& vertex,
                                                 Index* nearest_tile,
                                                 int* d_min) {
   Index target_index;
   gfx::Rect target_bounds = GetTileBoundsForPoint(vertex, &target_index);
 
   if (target_bounds.IsEmpty() || target_index == *nearest_tile)
@@ skipping 63 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