Disable folder UI when app sync is disabled

ui/app_list/app_list_model.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/app_list_model.h"
 
 #include <string>
 
 #include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_model_observer.h"
 #include "ui/app_list/search_box_model.h"
 #include "ui/app_list/search_result.h"
 
 namespace app_list {
 
 AppListModel::AppListModel()
     : top_level_item_list_(new AppListItemList),
       search_box_(new SearchBoxModel),
       results_(new SearchResults),
-      status_(STATUS_NORMAL) {
+      status_(STATUS_NORMAL),
+      folders_enabled_(false) {
   top_level_item_list_->AddObserver(this);
 }
 
 AppListModel::~AppListModel() { top_level_item_list_->RemoveObserver(this); }
 
 void AppListModel::AddObserver(AppListModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void AppListModel::RemoveObserver(AppListModelObserver* observer) {
@@ skipping 38 matching lines @@
 }
 
 AppListItem* AppListModel::AddItemToFolder(scoped_ptr<AppListItem> item,
                                            const std::string& folder_id) {
   if (folder_id.empty())
     return AddItem(item.Pass());
   DVLOG(2) << "AddItemToFolder: " << item->id() << ": " << folder_id;
   DCHECK(!item->IsInFolder() || item->folder_id() == folder_id);
   DCHECK(item->GetItemType() != AppListFolderItem::kItemType);
   AppListFolderItem* dest_folder = FindOrCreateFolderItem(folder_id);
+  if (!dest_folder)
+    return NULL;
   DCHECK(!dest_folder->item_list()->FindItem(item->id()))
       << "Already in folder: " << dest_folder->id();
   return AddItemToFolderItemAndNotify(dest_folder, item.Pass());
 }
 
 const std::string AppListModel::MergeItems(const std::string& target_item_id,
                                            const std::string& source_item_id) {
+  if (!folders_enabled()) {
+    LOG(ERROR) << "MergeItems called with folders disabled.";
+    return "";
+  }
   DVLOG(2) << "MergeItems: " << source_item_id << " -> " << target_item_id;
   // Find the target item.
   AppListItem* target_item = FindItem(target_item_id);
   if (!target_item) {
     LOG(ERROR) << "MergeItems: Target no longer exists.";
     return "";
   }
   CHECK(target_item->folder_id().empty());
 
   AppListItem* source_item = FindItem(source_item_id);
@@ skipping 149 matching lines @@
                     OnAppListItemWillBeDeleted(item));
   child_item.reset();  // Deletes item.
   FOR_EACH_OBSERVER(AppListModelObserver, observers_, OnAppListItemDeleted());
 }
 
 void AppListModel::NotifyExtensionPreferenceChanged() {
   for (size_t i = 0; i < top_level_item_list_->item_count(); ++i)
     top_level_item_list_->item_at(i)->OnExtensionPreferenceChanged();
 }
 
+void AppListModel::SetFoldersEnabled(bool folders_enabled) {
+  folders_enabled_ = folders_enabled;
+  if (folders_enabled)
+    return;
+  // Remove child items from folders.

[xiyuan, 2014/06/02 19:57:49]

I am not sure what is the best to do here. Can we leave the user data untouched?
This is a bit too destructive. 

[stevenjb, 2014/06/02 20:25:11]

We are only changing the in-memory model to match what the result will be after
a restart. If sync is re-enabled, the model will be re-populated with the
restored folder info.

[xiyuan, 2014/06/02 21:23:26]

What if user disables sync then re-enables it in the same session? If the sync
was enabled at the beginning, the syncable service is monitoring model change.
Would that cause the changes here become permanent?

+  std::vector<std::string> folder_ids;
+  for (size_t i = 0; i < top_level_item_list_->item_count(); ++i) {
+    AppListItem* item = top_level_item_list_->item_at(i);
+    if (item->GetItemType() != AppListFolderItem::kItemType)
+      continue;
+    AppListFolderItem* folder = static_cast<AppListFolderItem*>(item);
+    if (folder->folder_type() == AppListFolderItem::FOLDER_TYPE_OEM)
+      continue;  // Do not remove OEM folders.
+    while (folder->item_list()->item_count()) {
+      scoped_ptr<AppListItem> child = folder->item_list()->RemoveItemAt(0);
+      child->set_folder_id("");
+      AddItemToItemListAndNotifyUpdate(child.Pass());
+    }
+    folder_ids.push_back(folder->id());
+  }
+  // Delete folders.
+  for (size_t i = 0; i < folder_ids.size(); ++i)
+    DeleteItem(folder_ids[i]);
+}
+
 // Private methods
 
 void AppListModel::OnListItemMoved(size_t from_index,
                                    size_t to_index,
                                    AppListItem* item) {
   FOR_EACH_OBSERVER(AppListModelObserver,
                     observers_,
                     OnAppListItemUpdated(item));
 }
 
 AppListFolderItem* AppListModel::FindOrCreateFolderItem(
     const std::string& folder_id) {
   if (folder_id.empty())
     return NULL;
 
   AppListFolderItem* dest_folder = FindFolderItem(folder_id);
   if (dest_folder)
     return dest_folder;
 
+  if (!folders_enabled()) {
+    LOG(ERROR) << "Attempt to create folder item when disabled: " << folder_id;
+    return NULL;
+  }
+
   DVLOG(2) << "Creating new folder: " << folder_id;
   scoped_ptr<AppListFolderItem> new_folder(
       new AppListFolderItem(folder_id, AppListFolderItem::FOLDER_TYPE_NORMAL));
   new_folder->set_position(
       top_level_item_list_->CreatePositionBefore(syncer::StringOrdinal()));
   AppListItem* new_folder_item =
       AddItemToItemListAndNotify(new_folder.PassAs<AppListItem>());
   return static_cast<AppListFolderItem*>(new_folder_item);
 }
 
@@ skipping 44 matching lines @@
   scoped_ptr<AppListItem> result = folder->item_list()->RemoveItem(item->id());
   result->set_folder_id("");
   if (folder->item_list()->item_count() == 0) {
     DVLOG(2) << "Deleting empty folder: " << folder->ToDebugString();
     DeleteItem(folder_id);
   }
   return result.Pass();
 }
 
 }  // namespace app_list