[NTP4] Auto-deletion of empty apps panes.

chrome/browser/ui/webui/ntp/app_launcher_handler.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 53 matching lines @@
   CHECK(bucket < extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
   return bucket;
 }
 
 }  // namespace
 
 AppLauncherHandler::AppLauncherHandler(ExtensionService* extension_service)
     : extension_service_(extension_service),
       ignore_changes_(false),
       attempted_bookmark_app_install_(false),
-      has_loaded_apps_(false) {
+      has_loaded_apps_(false),
+      uninstall_from_page_(false) {
 }
 
 AppLauncherHandler::~AppLauncherHandler() {}
 
 // Serializes |notification| into a new DictionaryValue which the caller then
 // owns.
 static DictionaryValue* SerializeNotification(
     const AppNotification& notification) {
   DictionaryValue* dictionary = new DictionaryValue();
   dictionary->SetString("title", notification.title());
@@ skipping 78 matching lines @@
     // Make sure every app has a launch index (some predate the launch index).
     // The webstore's app launch index is set to -2 to make sure it's first.
     // The next time the user drags (any) app this will be set to something
     // sane (i.e. >= 0).
     app_launch_index = extension->id() == extension_misc::kWebStoreAppId ?
         -2 : prefs->GetNextAppLaunchIndex(0);
     prefs->SetAppLaunchIndex(extension->id(), app_launch_index);
   }
   value->SetInteger("app_launch_index", app_launch_index);
 
-  int page_index = prefs->GetPageIndex(extension->id());
-  if (page_index < 0) {
-    // Make sure every app has a page index (some predate the page index).
-    // The webstore app should be on the first page.
-    page_index = extension->id() == extension_misc::kWebStoreAppId ?
-        0 : prefs->GetNaturalAppPageIndex();
-    prefs->SetPageIndex(extension->id(), page_index);
-  }
-  value->SetInteger("page_index", page_index);
+  EnsureAppHasPageIndex(service, extension->id());
+  value->SetInteger("page_index", prefs->GetPageIndex(extension->id()));
 }
 
 WebUIMessageHandler* AppLauncherHandler::Attach(WebUI* web_ui) {
   registrar_.Add(this, chrome::NOTIFICATION_APP_INSTALLED_TO_NTP,
       content::Source<TabContents>(web_ui->tab_contents()));
   return WebUIMessageHandler::Attach(web_ui);
 }
 
 void AppLauncherHandler::RegisterMessages() {
+  web_ui_->RegisterMessageCallback("deleteAppsPage",
+      base::Bind(&AppLauncherHandler::HandleDeleteAppsPage,
+                 base::Unretained(this)));
   web_ui_->RegisterMessageCallback("getApps",
       base::Bind(&AppLauncherHandler::HandleGetApps,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("launchApp",
       base::Bind(&AppLauncherHandler::HandleLaunchApp,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("setLaunchType",
       base::Bind(&AppLauncherHandler::HandleSetLaunchType,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("uninstallApp",
       base::Bind(&AppLauncherHandler::HandleUninstallApp,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("hideAppsPromo",
       base::Bind(&AppLauncherHandler::HandleHideAppsPromo,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("createAppShortcut",
       base::Bind(&AppLauncherHandler::HandleCreateAppShortcut,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("reorderApps",
       base::Bind(&AppLauncherHandler::HandleReorderApps,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("setPageIndex",
       base::Bind(&AppLauncherHandler::HandleSetPageIndex,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("promoSeen",
       base::Bind(&AppLauncherHandler::HandlePromoSeen,
                  base::Unretained(this)));
-  web_ui_->RegisterMessageCallback("saveAppPageName",
-      base::Bind(&AppLauncherHandler::HandleSaveAppPageName,
+  web_ui_->RegisterMessageCallback("saveAppsPageName",
+      base::Bind(&AppLauncherHandler::HandleSaveAppsPageName,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("generateAppForLink",
       base::Bind(&AppLauncherHandler::HandleGenerateAppForLink,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("recordAppLaunchByURL",
       base::Bind(&AppLauncherHandler::HandleRecordAppLaunchByURL,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("closeNotification",
       base::Bind(&AppLauncherHandler::HandleNotificationClose,
                  base::Unretained(this)));
@@ skipping 56 matching lines @@
           content::Details<UnloadedExtensionInfo>(details)->extension;
       if (!extension->is_app())
         return;
 
       scoped_ptr<DictionaryValue> app_info(GetAppInfo(extension));
       scoped_ptr<base::FundamentalValue> uninstall_value(
           Value::CreateBooleanValue(
               content::Details<UnloadedExtensionInfo>(details)->reason ==
               extension_misc::UNLOAD_REASON_UNINSTALL));
       if (app_info.get()) {
+        scoped_ptr<base::FundamentalValue> from_page(
+            Value::CreateBooleanValue(uninstall_from_page_));
         web_ui_->CallJavascriptFunction(
-            "ntp4.appRemoved", *app_info, *uninstall_value);
+            "ntp4.appRemoved", *app_info, *uninstall_value, *from_page);
       }
       break;
     }
-    case chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED:
-    // The promo may not load until a couple seconds after the first NTP view,
-    // so we listen for the load notification and notify the NTP when ready.
-    case chrome::NOTIFICATION_WEB_STORE_PROMO_LOADED:
-      // TODO(estade): try to get rid of this inefficient operation.
+    case chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED: {
+      DictionaryValue pages;
+      const ExtensionSet* extensions = extension_service_->extensions();
+      ExtensionPrefs* prefs = extension_service_->extension_prefs();
+      for (ExtensionSet::const_iterator it = extensions->begin();
+          it != extensions->end(); ++it) {
+        if (!IsAppExcludedFromList(*it)) {
+          std::string page_index =
+              base::IntToString(prefs->GetPageIndex((*it)->id()));
+          if (!pages.HasKey(page_index))
+            pages.Set(page_index, new DictionaryValue());
+          DictionaryValue* page;
+          CHECK(pages.GetDictionary(page_index, &page));
+          page->SetString(
+              base::IntToString(prefs->GetAppLaunchIndex((*it)->id())),
+              (*it)->id());
+        }
+      }
+      web_ui_->CallJavascriptFunction("ntp4.appsReordered", pages);
+      break;
+    }
+    case chrome::NOTIFICATION_WEB_STORE_PROMO_LOADED: {
+      // The promo may not load until a couple seconds after the first NTP view,
+      // so we listen for the load notification and notify the NTP when ready.
       HandleGetApps(NULL);
       break;
+    }
     case chrome::NOTIFICATION_PREF_CHANGED: {
       DictionaryValue dictionary;
       FillAppDictionary(&dictionary);
       web_ui_->CallJavascriptFunction("appsPrefChangeCallback", dictionary);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR: {
       CrxInstaller* crx_installer = content::Source<CrxInstaller>(source).ptr();
       if (!Profile::FromWebUI(web_ui_)->IsSameProfile(crx_installer->profile()))
         return;
       // Fall Through.
     }
     case chrome::NOTIFICATION_EXTENSION_LOAD_ERROR: {
       attempted_bookmark_app_install_ = false;
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
+// static
+void AppLauncherHandler::EnsureAppHasPageIndex(ExtensionService* service,
+                                               const std::string& id) {
+  if (service->extension_prefs()->GetPageIndex(id) < 0) {
+    // Make sure every app has a page index (some predate the page index).
+    // The webstore app should be on the first page.
+    int page_index = id == extension_misc::kWebStoreAppId ?
+        0 : service->extension_prefs()->GetNaturalAppPageIndex();
+    service->extension_prefs()->SetPageIndex(id, page_index);
+  }
+}
+
 void AppLauncherHandler::FillAppDictionary(DictionaryValue* dictionary) {
   // CreateAppInfo and ClearPageIndex can change the extension prefs.
   AutoReset<bool> auto_reset(&ignore_changes_, true);
 
   ListValue* list = new ListValue();
   const ExtensionSet* extensions = extension_service_->extensions();
   ExtensionSet::const_iterator it;
   for (it = extensions->begin(); it != extensions->end(); ++it) {
     const Extension* extension = *it;
     if (!IsAppExcludedFromList(extension)) {
@@ skipping 55 matching lines @@
       extension_service_->apps_promo()->ShouldShowAppLauncher(
           extension_service_->GetAppIds()));
 
   PrefService* prefs = Profile::FromWebUI(web_ui_)->GetPrefs();
   const ListValue* app_page_names = prefs->GetList(prefs::kNTPAppPageNames);
   if (!app_page_names || !app_page_names->GetSize()) {
     ListPrefUpdate update(prefs, prefs::kNTPAppPageNames);
     ListValue* list = update.Get();
     list->Set(0, Value::CreateStringValue(
         l10n_util::GetStringUTF16(IDS_APP_DEFAULT_PAGE_NAME)));
-    dictionary->Set("appPageNames",
+    dictionary->Set("appsPageNames",
                     static_cast<ListValue*>(list->DeepCopy()));
   } else {
-    dictionary->Set("appPageNames",
+    dictionary->Set("appsPageNames",
                     static_cast<ListValue*>(app_page_names->DeepCopy()));
   }
 }
 
 DictionaryValue* AppLauncherHandler::GetAppInfo(const Extension* extension) {
   AppNotificationManager* notification_manager =
       extension_service_->app_notification_manager();
   DictionaryValue* app_info = new DictionaryValue();
   // CreateAppInfo can change the extension prefs.
   AutoReset<bool> auto_reset(&ignore_changes_, true);
   CreateAppInfo(extension,
                 notification_manager->GetLast(extension->id()),
                 extension_service_,
                 app_info);
   return app_info;
 }
 
 void AppLauncherHandler::FillPromoDictionary(DictionaryValue* dictionary) {
   AppsPromo::PromoData data = AppsPromo::GetPromo();
   dictionary->SetString("promoHeader", data.header);
   dictionary->SetString("promoButton", data.button);
   dictionary->SetString("promoLink", data.link.spec());
   dictionary->SetString("promoLogo", data.logo.spec());
   dictionary->SetString("promoExpire", data.expire);
 }
 
+void AppLauncherHandler::HandleDeleteAppsPage(const ListValue* args) {
+  double page_index_double;
+  CHECK(args->GetDouble(0, &page_index_double) && page_index_double >= 0);
+  size_t page_index = static_cast<size_t>(page_index_double);
+
+  AutoReset<bool> auto_reset(&ignore_changes_, true);
+
+  DeleteAppsPageRange(page_index, 1);
+}
+
+void AppLauncherHandler::CleanupAfterUninstall() {
+  uninstall_from_page_ = false;
+  extension_id_prompting_ = "";
+}
+
+void AppLauncherHandler::CondenseAppsPages() {
+  std::vector<bool> has_apps;
+  const ExtensionSet* extensions = extension_service_->extensions();
+  for (ExtensionSet::const_iterator it = extensions->begin();
+       it != extensions->end(); ++it) {
+    if (!IsAppExcludedFromList(*it)) {
+      EnsureAppHasPageIndex(extension_service_, (*it)->id());
+      size_t page_index =
+          extension_service_->extension_prefs()->GetPageIndex((*it)->id());
+      if (has_apps.size() < page_index + 1)
+        has_apps.resize(page_index + 1);
+      has_apps[page_index] = true;
+    }
+  }
+
+  // Delete empty ranges of apps pages.
+  int first_empty = -1;
+  for (size_t i = 0; i < has_apps.size(); ++i) {
+    if (!has_apps[i]) {
+      if (first_empty == -1)
+        first_empty = i;
+    } else if (first_empty != -1) {
+      DeleteAppsPageRange(first_empty, i - first_empty);
+      has_apps.erase(has_apps.begin() + first_empty, has_apps.begin() + i);
+      i -= (i - first_empty);
+      first_empty = -1;
+    }
+  }
+  // Make sure there are no pending empty apps pages at the end of our list.
+  CHECK_EQ(first_empty, -1);
+}
+
+void AppLauncherHandler::DeleteAppsPageRange(size_t index, size_t how_many) {
+  // Delete the apps page name from our prefs.
+  PrefService* prefs = Profile::FromWebUI(web_ui_)->GetPrefs();
+  ListPrefUpdate update(prefs, prefs::kNTPAppPageNames);
+  ListValue* list = update.Get();
+
+  // Index checking is done within list->Remove() and will return false if an
+  // index to remove is negative or larger than the size of the list. This is
+  // intentionally left un-CHECK()-ed in the case that there's a skew between
+  // the list pref size and the last page index of all the apps.
+  for (size_t i = 0; i < how_many; ++i)
+    list->Remove(index, NULL);
+
+  // Move apps that were on a page past the one we're deleting to their newly
+  // adjusted page index.
+  ExtensionPrefs* ext_prefs = extension_service_->extension_prefs();
+  const ExtensionSet* extensions = extension_service_->extensions();
+  for (ExtensionSet::const_iterator it = extensions->begin();
+       it != extensions->end(); ++it) {
+    // Ignore extensions and the cloud print app (but handle CWS app).
+    if (!IsAppExcludedFromList(*it)) {
+      size_t apps_page_index =
+          static_cast<size_t>(ext_prefs->GetPageIndex((*it)->id()));
+      // Don't delete pages with apps still on them.
+      CHECK(apps_page_index < index || apps_page_index >= (index + how_many));
+      if (apps_page_index >= (index + how_many))
+        ext_prefs->SetPageIndex((*it)->id(), apps_page_index - how_many);
+    }
+  }
+}
+
 void AppLauncherHandler::HandleGetApps(const ListValue* args) {
   DictionaryValue dictionary;
 
   // Tell the client whether to show the promo for this view. We don't do this
   // in the case of PREF_CHANGED because:
   //
   // a) At that point in time, depending on the pref that changed, it can look
   //    like the set of apps installed has changed, and we will mark the promo
   //    expired.
   // b) Conceptually, it doesn't really make sense to count a
@@ skipping 10 matching lines @@
   }
 
   // If the default apps have just expired (user viewed them too many times with
   // no interaction), then we uninstall them and focus the recent sites section.
   if (apps_promo_just_expired) {
     ignore_changes_ = true;
     UninstallDefaultApps();
     ignore_changes_ = false;
   }
 
+  CondenseAppsPages();
   SetAppToBeHighlighted();
   FillAppDictionary(&dictionary);
   web_ui_->CallJavascriptFunction("getAppsCallback", dictionary);
 
   // First time we get here we set up the observer so that we can tell update
   // the apps as they change.
   if (!has_loaded_apps_) {
     pref_change_registrar_.Init(
         extension_service_->extension_prefs()->pref_service());
     pref_change_registrar_.Add(ExtensionPrefs::kExtensionsPref, this);
@@ skipping 123 matching lines @@
   if (!extension_id_prompting_.empty())
     return;  // Only one prompt at a time.
 
   extension_id_prompting_ = extension_id;
 
   bool dont_confirm = false;
   if (args->GetBoolean(1, &dont_confirm) && dont_confirm) {
     AutoReset<bool> auto_reset(&ignore_changes_, true);
     ExtensionUninstallAccepted();
   } else {
+    // We don't use an AutoReset<bool> here as the uninstall dialog runs in a
+    // different thread so it's not sync.
+    uninstall_from_page_ = true;
     GetExtensionUninstallDialog()->ConfirmUninstall(extension);
   }
 }
 
 void AppLauncherHandler::HandleHideAppsPromo(const ListValue* args) {
   // If the user has intentionally hidden the promotion, we'll uninstall all the
   // default apps (we know the user hasn't installed any apps on their own at
   // this point, or the promotion wouldn't have been shown).
   // TODO(estade): this isn't used right now as we sort out the future of the
   // apps promo on ntp4.
@@ skipping 50 matching lines @@
   extension_service_->extension_prefs()->SetPageIndex(extension_id,
       static_cast<int>(page_index));
 }
 
 void AppLauncherHandler::HandlePromoSeen(const ListValue* args) {
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
                             extension_misc::PROMO_SEEN,
                             extension_misc::PROMO_BUCKET_BOUNDARY);
 }
 
-void AppLauncherHandler::HandleSaveAppPageName(const ListValue* args) {
+void AppLauncherHandler::HandleSaveAppsPageName(const ListValue* args) {
   string16 name;
   CHECK(args->GetString(0, &name));
 
-  double page_index;
-  CHECK(args->GetDouble(1, &page_index));
+  double page_index_double;
+  CHECK(args->GetDouble(1, &page_index_double));
 
   AutoReset<bool> auto_reset(&ignore_changes_, true);
   PrefService* prefs = Profile::FromWebUI(web_ui_)->GetPrefs();
   ListPrefUpdate update(prefs, prefs::kNTPAppPageNames);
   ListValue* list = update.Get();
-  list->Set(static_cast<size_t>(page_index), Value::CreateStringValue(name));
+  size_t page_index = static_cast<size_t>(page_index_double);
+  // Though it's valid to set items of a list at a non-existent positive index
+  // (that's greater than the current length), this is not desired in this case
+  // as it creates null values in the middle of the list. Instead, only allow a
+  // save to act as an append when the page being saved is exactly equal to the
+  // length of the list.
+  CHECK(page_index <= list->GetSize());
+  list->Set(page_index, Value::CreateStringValue(name));
 }
 
 void AppLauncherHandler::HandleGenerateAppForLink(const ListValue* args) {
   std::string url;
   CHECK(args->GetString(0, &url));
   GURL launch_url(url);
 
   string16 title;
   CHECK(args->GetString(1, &title));
 
   double page_index;
   CHECK(args->GetDouble(2, &page_index));
 
+  // TODO(dbeam): Handle third argument (app_launch_index) and pass through
+  // the installation process.
+
   Profile* profile = Profile::FromWebUI(web_ui_);
   FaviconService* favicon_service =
       profile->GetFaviconService(Profile::EXPLICIT_ACCESS);
   if (!favicon_service) {
     LOG(ERROR) << "No favicon service";
     return;
   }
 
   scoped_ptr<AppInstallInfo> install_info(new AppInstallInfo());
   install_info->is_bookmark_app = true;
@@ skipping 172 matching lines @@
 
   // The extension can be uninstalled in another window while the UI was
   // showing. Do nothing in that case.
   const Extension* extension =
       extension_service_->GetExtensionById(extension_id_prompting_, true);
   if (!extension)
     return;
 
   extension_service_->UninstallExtension(extension_id_prompting_,
                                          false /* external_uninstall */, NULL);
-
-  extension_id_prompting_ = "";
+  CleanupAfterUninstall();
 }
 
 void AppLauncherHandler::ExtensionUninstallCanceled() {
-  extension_id_prompting_ = "";
+  CleanupAfterUninstall();
 }
 
 void AppLauncherHandler::InstallUIProceed() {
   // Do the re-enable work here.
   DCHECK(!extension_id_prompting_.empty());
 
   // The extension can be uninstalled in another window while the UI was
   // showing. Do nothing in that case.
   const Extension* extension =
       extension_service_->GetExtensionById(extension_id_prompting_, true);
@@ skipping 44 matching lines @@
 
 void AppLauncherHandler::UninstallDefaultApps() {
   AppsPromo* apps_promo = extension_service_->apps_promo();
   const ExtensionIdSet& app_ids = apps_promo->old_default_apps();
   for (ExtensionIdSet::const_iterator iter = app_ids.begin();
        iter != app_ids.end(); ++iter) {
     if (extension_service_->GetExtensionById(*iter, true))
       extension_service_->UninstallExtension(*iter, false, NULL);
   }
 }