Convert app_launch_index and page_index from int to StringOrdinal.

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"
@@ skipping 92 matching lines @@
 
 // A preference set by the web store to indicate login information for
 // purchased apps.
 const char kWebStoreLogin[] = "extensions.webstore_login";
 
 // A preference set by the the NTP to persist the desired launch container type
 // used for apps.
 const char kPrefLaunchType[] = "launchType";
 
 // A preference determining the order of which the apps appear on the NTP.
-const char kPrefAppLaunchIndex[] = "app_launcher_index";
+const char kPrefAppLaunchIndexDeprecated[] = "app_launcher_index";
+const char kPrefAppLaunchIndex[] = "app_launcher_index_string_ordinal";
 
 // A preference determining the page on which an app appears in the NTP.
-const char kPrefPageIndex[] = "page_index";
+const char kPrefPageIndexDeprecated[] = "page_index";
+const char kPrefPageIndex[] = "page_index_string_ordinal";
 
 // A preference specifying if the user dragged the app on the NTP.
 const char kPrefUserDraggedApp[] = "user_dragged_app_ntp";
 
 // A preference for storing extra data sent in update checks for an extension.
 const char kUpdateUrlData[] = "update_url_data";
 
 // Whether the browser action is visible in the toolbar.
 const char kBrowserActionVisible[] = "browser_action_visible";
 
@@ skipping 105 matching lines @@
   const std::string extension_id_;
   const std::string incognito_or_regular_path_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedExtensionControlledPrefUpdate);
 };
 
 std::string JoinPrefs(std::string parent, const char* child) {
   return parent + "." + child;
 }
 
+// A simple structure used when sorting applications based on the order they
+// appear on the NTP. This is used by the code that migrates the data
+// from integers to StringOrdinals.
+struct ApplicationNTPOldPosition {
+  const std::string* application_id;
+  const int page_index;
+  const int app_launch_index;
+
+  ApplicationNTPOldPosition(const std::string& app_id, int page, int app_launch)
+      : application_id(&app_id),
+        page_index(page),
+        app_launch_index(app_launch) {}
+};
+
+struct SortByNTPOldPosition {
+  bool operator() (const ApplicationNTPOldPosition& lhs,
+                   const ApplicationNTPOldPosition& rhs) const {
+    if (lhs.page_index != rhs.page_index)
+      return lhs.page_index < rhs.page_index;
+
+    return lhs.app_launch_index < rhs.app_launch_index;
+  }
+};
+
 }  // namespace
 
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       content_settings_store_(new ExtensionContentSettingsStore()) {
@@ skipping 156 matching lines @@
   const DictionaryValue* ext = GetExtensionPref(extension_id);
   ListValue* out = NULL;
   if (!ext || !ext->GetList(pref_key, &out))
     return false;
   if (out_value)
     *out_value = out;
 
   return true;
 }
 
+bool ExtensionPrefs::ReadExtensionPrefString(
+    const std::string& extension_id, const std::string& pref_key,
+    std::string* out_value) const {
+  const DictionaryValue* ext = GetExtensionPref(extension_id);
+
+  if (!ext || !ext->GetString(pref_key, out_value))
+    return false;
+
+  return true;
+}
+
 bool ExtensionPrefs::ReadExtensionPrefURLPatternSet(
     const std::string& extension_id,
     const std::string& pref_key,
     URLPatternSet* result,
     int valid_schemes) {
   const ListValue* value = NULL;
   if (!ReadExtensionPrefList(extension_id, pref_key, &value))
     return false;
 
   result->ClearPatterns();
@@ skipping 423 matching lines @@
     if (ext->GetList(kPrefOldGrantedHosts, &hosts)) {
       UpdateExtensionPref(
           *ext_id, explicit_hosts, hosts->DeepCopy());
 
       // We can get rid of the old one by setting it to an empty list.
       UpdateExtensionPref(*ext_id, kPrefOldGrantedHosts, new ListValue());
     }
   }
 }
 
+void ExtensionPrefs::MigrateAppIndex(const ExtensionIdSet& extension_ids) {
+  if (extension_ids.begin() == extension_ids.end())
+    return;
+
+  // Create a sorted set of all the extensions that need either their page
+  // or launch index converted.
+  std::set<ApplicationNTPOldPosition, SortByNTPOldPosition> apps_to_convert;
+  for (ExtensionIdSet::const_iterator ext_id = extension_ids.begin();
+       ext_id != extension_ids.end(); ++ext_id) {
+    int old_page_index = 0;
+    int old_app_launch_index = 0;
+
+    bool has_old_values = ReadExtensionPrefInteger(*ext_id,
+                                                   kPrefPageIndexDeprecated,
+                                                   &old_page_index);
+    has_old_values |= ReadExtensionPrefInteger(*ext_id,
+                                               kPrefAppLaunchIndexDeprecated,
+                                               &old_app_launch_index);
+
+    if (has_old_values) {
+      // Its ok to use both values, even if they weren't read, because this
+      // only affects the sorting, which can handle apps with the default
+      // integer values.
+      apps_to_convert.insert(ApplicationNTPOldPosition(
+          *ext_id, old_page_index, old_app_launch_index));
+    }
+  }
+
+  if (apps_to_convert.empty())
+    return;
+
+  // Create the new values and remove the old preferences.
+  for (std::set<ApplicationNTPOldPosition, SortByNTPOldPosition>::iterator ext =
+           apps_to_convert.begin(); ext != apps_to_convert.end(); ++ext) {
+    int old_page_index;
+    if (ReadExtensionPrefInteger(*(ext->application_id),
+                                 kPrefPageIndexDeprecated,
+                                 &old_page_index)) {
+      SetPageIndex(*(ext->application_id),
+                   PageIndexAsStringOrdinal(old_page_index));
+      UpdateExtensionPref(
+          *(ext->application_id), kPrefPageIndexDeprecated, NULL);
+    }
+
+    int old_app_launch_index;
+    if (ReadExtensionPrefInteger(*(ext->application_id),
+                                 kPrefAppLaunchIndexDeprecated,
+                                 &old_app_launch_index)) {
+      StringOrdinal page = GetPageIndex(*(ext->application_id));
+      SetAppLaunchIndex(*(ext->application_id),
+                        GetNextAppLaunchIndex(page));
+      UpdateExtensionPref(
+          *(ext->application_id), kPrefAppLaunchIndexDeprecated, NULL);
+    }
+  }
+}
+
 ExtensionPermissionSet* ExtensionPrefs::GetGrantedPermissions(
     const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
   return ReadExtensionPrefPermissionSet(extension_id, kPrefGrantedPermissions);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(
     const std::string& extension_id,
     const ExtensionPermissionSet* permissions) {
   CHECK(Extension::IdIsValid(extension_id));
@@ skipping 194 matching lines @@
        iter != extension_ids.end(); ++iter) {
     toolbar_order->Append(new StringValue(*iter));
   }
   SavePrefs();
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool from_webstore,
-    int page_index) {
+    StringOrdinal page_index) {
   const std::string& id = extension->id();
   CHECK(Extension::IdIsValid(id));
   ScopedExtensionPrefUpdate update(prefs_, id);
   DictionaryValue* extension_dict = update.Get();
   const base::Time install_time = GetCurrentTime();
   extension_dict->Set(kPrefState, Value::CreateIntegerValue(initial_state));
   extension_dict->Set(kPrefLocation,
                       Value::CreateIntegerValue(extension->location()));
   extension_dict->Set(kPrefFromWebStore,
                       Value::CreateBooleanValue(from_webstore));
@@ skipping 11 matching lines @@
       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());
   }
 
   if (extension->is_app()) {
-    if (page_index == -1)
+    if (!page_index.IsValid())
       page_index = GetNaturalAppPageIndex();
     extension_dict->Set(kPrefPageIndex,
-                        Value::CreateIntegerValue(page_index));
+                        Value::CreateStringValue(page_index.ToString()));
+    UpdatePageIndexMap(StringOrdinal(), page_index);
+
     extension_dict->Set(kPrefAppLaunchIndex,
-        Value::CreateIntegerValue(GetNextAppLaunchIndex(page_index)));
+                        Value::CreateStringValue(
+                            GetNextAppLaunchIndex(page_index).ToString()));
   }
   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) {
@@ skipping 312 matching lines @@
     return true;
   }
   return false;
 }
 
 void ExtensionPrefs::SetWebStoreLogin(const std::string& login) {
   prefs_->SetString(kWebStoreLogin, login);
   SavePrefs();
 }
 
-int ExtensionPrefs::GetAppLaunchIndex(const std::string& extension_id) {
-  int value;
-  if (ReadExtensionPrefInteger(extension_id, kPrefAppLaunchIndex, &value))
-    return value;
+void ExtensionPrefs::GetAllAppLaunchIndicesOnPageSorted(
+    const StringOrdinal& target_page_index,
+    std::set<StringOrdinal, StringOrdinalLessThan>* indices_on_page) const {
+  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
+  if (!extensions || !target_page_index.IsValid())
+    return;
 
-  return -1;
+  for (DictionaryValue::key_iterator ext_it = extensions->begin_keys();
+       ext_it != extensions->end_keys(); ++ext_it) {
+    StringOrdinal page_index = GetPageIndex(*ext_it);
+    if (page_index.IsValid() && page_index.Equal(target_page_index)) {
+      StringOrdinal app_launch_index = GetAppLaunchIndex(*ext_it);
+      if (app_launch_index.IsValid())
+        indices_on_page->insert(app_launch_index);
+    }
+  }
+}
+
+StringOrdinal ExtensionPrefs::GetFirstAppPage() const {
+  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
+  if (!extensions)
+    return StringOrdinal();
+
+  if (page_index_map_.size() == 0)
+    return StringOrdinal::CreateInitialOrdinal();
+
+  return page_index_map_.begin()->first;
+}
+
+StringOrdinal ExtensionPrefs::CreateFirstAppLaunchIndex(
+    const StringOrdinal& page_index) const {
+  std::set<StringOrdinal, StringOrdinalLessThan> apps_on_page;
+  GetAllAppLaunchIndicesOnPageSorted(page_index, &apps_on_page);
+
+  if (apps_on_page.empty())
+    return StringOrdinal::CreateInitialOrdinal();
+  else
+    return apps_on_page.begin()->CreateBefore();
+}
+
+StringOrdinal ExtensionPrefs::GetAppLaunchIndex(
+    const std::string& extension_id) const {
+  std::string raw_value;
+  // If the preference read fails then raw_value will still be unset and we
+  // will return an invalid StringOrdinal to signal that no app launch index
+  // was found.
+  ReadExtensionPrefString(extension_id, kPrefAppLaunchIndex, &raw_value);
+  return StringOrdinal(raw_value);
 }
 
 void ExtensionPrefs::SetAppLaunchIndex(const std::string& extension_id,
-                                       int index) {
+                                       const StringOrdinal& index) {
   UpdateExtensionPref(extension_id, kPrefAppLaunchIndex,
-                      Value::CreateIntegerValue(index));
+                      Value::CreateStringValue(index.ToString()));
 }
 
-int ExtensionPrefs::GetNextAppLaunchIndex(int on_page) {
+StringOrdinal ExtensionPrefs::GetNextAppLaunchIndex(
+    const StringOrdinal& on_page) const {
+  std::set<StringOrdinal, StringOrdinalLessThan> apps_on_page;
+  GetAllAppLaunchIndicesOnPageSorted(on_page, &apps_on_page);
+
+  if (apps_on_page.empty())
+    return StringOrdinal::CreateInitialOrdinal();
+  else
+    return apps_on_page.rbegin()->CreateAfter();
+}
+
+StringOrdinal ExtensionPrefs::GetNaturalAppPageIndex() const {
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
   if (!extensions)
-    return 0;
+    return StringOrdinal();
 
-  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;
+  if (page_index_map_.size() == 0)
+    return StringOrdinal::CreateInitialOrdinal();
+
+  std::map<StringOrdinal, int>::const_iterator it = page_index_map_.begin();
+  for (; it != page_index_map_.end(); ++it) {
+    if (it->second < kNaturalAppPageSize)
+      return it->first;
   }
-  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;
-  }
+  // Add a new page as all existing pages are full.
+  StringOrdinal last_element = page_index_map_.rbegin()->first;
+  return last_element.CreateAfter();
 }
 
 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);
+    const std::vector<std::string>& extension_ids,
+    const std::string& moved_extension_id) {
+  std::vector<std::string>::const_iterator it =
+      find(extension_ids.begin(), extension_ids.end(), moved_extension_id);
+  size_t position = std::distance(extension_ids.begin(), it);
+
+  // We need at least 2 apps for the moved apps old value to be invalidated.
+  if (extension_ids.size() >= 2) {
+    if (position == 0U) {
+      // The app is moving to the start of the group, so we need to get the
+      // previous first StringOrdinal and create the new value before it.
+      ++it;
+      SetAppLaunchIndex(moved_extension_id,
+                        GetAppLaunchIndex(*it).CreateBefore());
+    } else if (position == extension_ids.size() - 1U) {
+      // The app is moving to the end of the group, so we need to get the
+      // previous last StringOrdinal and create the new value after it.
+      --it;
+      SetAppLaunchIndex(moved_extension_id,
+                        GetAppLaunchIndex(*it).CreateAfter());
+    } else {
+      // The app is going into a middle position, which means there are valid
+      // StringOrdinals before and after it. We get the new adjacent
+      // StringOrdinals and create our new value between them.
+      ++it;
+      StringOrdinal value_after = GetAppLaunchIndex(*it);
+      advance(it, -2);
+      StringOrdinal value_before = GetAppLaunchIndex(*it);
+      SetAppLaunchIndex(moved_extension_id,
+                        value_before.CreateBetween(value_after));
+    }
+  }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED,
       content::Source<ExtensionPrefs>(this),
       content::NotificationService::NoDetails());
 }
 
-int ExtensionPrefs::GetPageIndex(const std::string& extension_id) {
-  int value = -1;
-  ReadExtensionPrefInteger(extension_id, kPrefPageIndex, &value);
-  return value;
+StringOrdinal ExtensionPrefs::GetPageIndex(const std::string& extension_id)
+    const {
+  std::string raw_data;
+  // If the preference read fails then raw_value will still be unset and we will
+  // return an invalid StringOrdinal to signal that no page index was found.
+  ReadExtensionPrefString(extension_id, kPrefPageIndex, &raw_data);
+  return StringOrdinal(raw_data);
 }
 
-void ExtensionPrefs::SetPageIndex(const std::string& extension_id, int index) {
+void ExtensionPrefs::SetPageIndex(const std::string& extension_id,
+                                  const StringOrdinal& page_index) {
+  UpdatePageIndexMap(GetPageIndex(extension_id), page_index);
   UpdateExtensionPref(extension_id, kPrefPageIndex,
-                      Value::CreateIntegerValue(index));
+                      Value::CreateStringValue(page_index.ToString()));
 }
 
 void ExtensionPrefs::ClearPageIndex(const std::string& extension_id) {
+  UpdatePageIndexMap(GetPageIndex(extension_id), StringOrdinal());
   UpdateExtensionPref(extension_id, kPrefPageIndex, NULL);
 }
 
+void ExtensionPrefs::InitializePageIndexMap(
+    const ExtensionIdSet& extension_ids) {
+  for (ExtensionIdSet::const_iterator ext_it = extension_ids.begin();
+       ext_it != extension_ids.end(); ++ext_it) {
+    UpdatePageIndexMap(StringOrdinal(), GetPageIndex(*ext_it));
+  }
+}
+
+void ExtensionPrefs::UpdatePageIndexMap(const StringOrdinal& old_value,
+                                        const StringOrdinal& new_value) {
+  if (new_value.IsValid())
+    ++page_index_map_[new_value];
+
+  if (old_value.IsValid()) {
+    --page_index_map_[old_value];
+
+    if (page_index_map_[old_value] == 0)
+      page_index_map_.erase(old_value);
+  }
+}
+
+int ExtensionPrefs::PageIndexAsInteger(const StringOrdinal& page_index) const {
+  if (!page_index.IsValid())
+    return -1;
+
+  std::map<StringOrdinal, int>::const_iterator it =
+      page_index_map_.find(page_index);
+  if (it != page_index_map_.end()) {
+    return std::distance(page_index_map_.begin(), it);
+  } else {
+    return -1;
+  }
+}
+
+StringOrdinal ExtensionPrefs::PageIndexAsStringOrdinal(size_t page_index) {
+  const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
+  if (!extensions)
+    return StringOrdinal();
+
+  if (page_index_map_.size() == 0)
+    return StringOrdinal::CreateInitialOrdinal();
+
+  if (page_index < page_index_map_.size()) {
+    std::map<StringOrdinal, int, StringOrdinalLessThan>::const_iterator it =
+        page_index_map_.begin();
+    advance(it, page_index);
+
+    return it->first;
+  } else {
+    // Create new pages until we reach the desired index.
+    while (page_index >= page_index_map_.size()) {
+      StringOrdinal new_page = page_index_map_.rbegin()->first.CreateAfter();
+      page_index_map_[new_page] = 0;
+    }
+    return page_index_map_.rbegin()->first;
+  }
+}
+
 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,
                       Value::CreateBooleanValue(true));
 }
 
 void ExtensionPrefs::SetUpdateUrlData(const std::string& extension_id,
@@ skipping 124 matching lines @@
   // Create empty preferences dictionary for each extension (these dictionaries
   // are pruned when persisting the preferences to disk).
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     ScopedExtensionPrefUpdate update(prefs_, *ext_id);
     // This creates an empty dictionary if none is stored.
     update.Get();
   }
 
   FixMissingPrefs(extension_ids);
+  InitializePageIndexMap(extension_ids);
   MigratePermissions(extension_ids);
+  MigrateAppIndex(extension_ids);
 
   // Store extension controlled preference values in the
   // |extension_pref_value_map_|, which then informs the subscribers
   // (ExtensionPrefStores) about the winning values.
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     extension_pref_value_map_->RegisterExtension(
         *ext_id,
         GetInstallTime(*ext_id),
         !IsExtensionDisabled(*ext_id));
@@ skipping 155 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);
 }