ntp4: default to 18 apps per page for new installs

chrome/browser/extensions/extension_prefs.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/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "content/common/notification_service.h"
 
 using base::Time;
 
 namespace {
 
+// The number of apps per page. This isn't a hard limit, but new apps installed
+// from the webstore will overflow onto a new page if this limit is reached.
+const int kNaturalAppPageSize = 18;
+
 // Additional preferences keys
 
 // Where an extension was installed from. (see Extension::Location)
 const char kPrefLocation[] = "location";
 
 // Enabled, disabled, killed, etc. (see Extension::State)
 const char kPrefState[] = "state";
 
 // The path to the current version's manifest file.
 const char kPrefPath[] = "path";
@@ skipping 939 matching lines @@
 
   FilePath::StringType path = MakePathRelative(install_directory_,
       extension->path());
   extension_dict->Set(kPrefPath, Value::CreateStringValue(path));
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (extension->location() != Extension::LOAD) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest_value()->DeepCopy());
   }
-  extension_dict->Set(kPrefPageIndex,
-                      Value::CreateIntegerValue(page_index));
-  extension_dict->Set(kPrefAppLaunchIndex,
-      Value::CreateIntegerValue(GetNextAppLaunchIndex(page_index)));
+
+  if (extension->is_app()) {
+    if (page_index == -1)
+      page_index = GetNaturalAppPageIndex();
+    extension_dict->Set(kPrefPageIndex,
+                        Value::CreateIntegerValue(page_index));
+    extension_dict->Set(kPrefAppLaunchIndex,
+        Value::CreateIntegerValue(GetNextAppLaunchIndex(page_index)));
+  }
   extension_pref_value_map_->RegisterExtension(
       id, install_time, initial_state == Extension::ENABLED);
   content_settings_store_->RegisterExtension(
       id, install_time, initial_state == Extension::ENABLED);
 }
 
 void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id,
                                             const Extension::Location& location,
                                             bool external_uninstall) {
   // For external extensions, we save a preference reminding ourself not to try
@@ skipping 318 matching lines @@
 int ExtensionPrefs::GetAppLaunchIndex(const std::string& extension_id) {
   int value;
   if (ReadExtensionPrefInteger(extension_id, kPrefAppLaunchIndex, &value))
     return value;
 
   return -1;
 }
 
 void ExtensionPrefs::SetAppLaunchIndex(const std::string& extension_id,
                                        int index) {
-  DCHECK_GE(index, 0);
   UpdateExtensionPref(extension_id, kPrefAppLaunchIndex,
                       Value::CreateIntegerValue(index));
 }
 
 int ExtensionPrefs::GetNextAppLaunchIndex(int on_page) {
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
   if (!extensions)
     return 0;
 
   int max_value = -1;
   for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
        extension_id != extensions->end_keys(); ++extension_id) {
     int value = GetAppLaunchIndex(*extension_id);
     int page = GetPageIndex(*extension_id);
     if (page == on_page && value > max_value)
       max_value = value;
   }
   return max_value + 1;
 }
 
+int ExtensionPrefs::GetNaturalAppPageIndex() {
+  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
+  if (!extensions)
+    return 0;
+
+  std::map<int, int> page_counts;
+  for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
+       extension_id != extensions->end_keys(); ++extension_id) {
+    int page_index = GetPageIndex(*extension_id);
+    if (page_index >= 0)
+      page_counts[page_index] = page_counts[page_index] + 1;
+  }
+  for (int i = 0; ; i++) {
+    std::map<int, int>::const_iterator it = page_counts.find(i);
+    if (it == page_counts.end() || it->second < kNaturalAppPageSize)
+      return i;
+  }
+}
+
 void ExtensionPrefs::SetAppLauncherOrder(
     const std::vector<std::string>& extension_ids) {
   for (size_t i = 0; i < extension_ids.size(); ++i)
     SetAppLaunchIndex(extension_ids.at(i), i);
 
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED,
       Source<ExtensionPrefs>(this),
       NotificationService::NoDetails());
 }
 
 int ExtensionPrefs::GetPageIndex(const std::string& extension_id) {
   int value = -1;
   ReadExtensionPrefInteger(extension_id, kPrefPageIndex, &value);
   return value;
 }
 
 void ExtensionPrefs::SetPageIndex(const std::string& extension_id, int index) {
-  CHECK_GE(index, 0);
   UpdateExtensionPref(extension_id, kPrefPageIndex,
                       Value::CreateIntegerValue(index));
 }
 
 bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefUserDraggedApp);
 }
 
 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
@@ skipping 298 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }