Convert app_launch_index and page_index from int to StringOrdinal.

chrome/browser/extensions/extension_prefs.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_
 #pragma once
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/extensions/extension_content_settings_store.h"
 #include "chrome/browser/extensions/extension_prefs_scope.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/string_ordinal.h"
 #include "googleurl/src/gurl.h"
 
 class ExtensionPrefValueMap;
 class URLPatternSet;
 
 // Class for managing global and per-extension preferences.
 //
 // This class distinguishes the following kinds of preferences:
 // - global preferences:
 //       internal state for the extension system in general, not associated
@@ skipping 63 matching lines @@
   // ExtensionService::IsExtensionEnabled instead.
   bool IsExtensionDisabled(const std::string& id) const;
 
   // Get the order that the browser actions appear in the toolbar.
   std::vector<std::string> GetToolbarOrder();
 
   // Set the order that the browser actions appear in the toolbar.
   void SetToolbarOrder(const std::vector<std::string>& extension_ids);
 
   // Called when an extension is installed, so that prefs get created.
-  // If |page_index| is -1, and the then a page will be found for the App.
+  // If |page_ordinal| is an invalid ordinal, then a page will be found
+  // for the App.
   void OnExtensionInstalled(const Extension* extension,
                             Extension::State initial_state,
                             bool from_webstore,
-                            int page_index);
+                            const StringOrdinal& page_ordinal);
 
   // Called when an extension is uninstalled, so that prefs get cleaned up.
   void OnExtensionUninstalled(const std::string& extension_id,
                               const Extension::Location& location,
                               bool external_uninstall);
 
+  // Updates the app launcher value for the moved extension so that it is now
+  // located after the given predecessor and before the successor.
+  // Empty strings are used to indicate no successor or predecessor.
+  void OnExtensionMoved(
+      const std::string& moved_extension_id,
+      const std::string& predecessor_extension_id,
+      const std::string& successor_extension_id);
+
   // Called to change the extension's state when it is enabled/disabled.
   void SetExtensionState(const std::string& extension_id, Extension::State);
 
   // Returns all installed extensions
   void GetExtensions(ExtensionIdSet* out);
 
   // Getter and setter for browser action visibility.
   bool GetBrowserActionVisibility(const Extension* extension);
   void SetBrowserActionVisibility(const Extension* extension, bool visible);
 
@@ skipping 174 matching lines @@
   std::set<std::string> GetIdleInstallInfoIds();
 
   // We allow the web store to set a string containing login information when a
   // purchase is made, so that when a user logs into sync with a different
   // account we can recognize the situation. The Get function returns true if
   // there was previously stored data (placing it in |result|), or false
   // otherwise. The Set will overwrite any previous login.
   bool GetWebStoreLogin(std::string* result);
   void SetWebStoreLogin(const std::string& login);
 
-  // Get the application launch index for an extension with |extension_id|. This
-  // determines the order of which the applications appear on the New Tab Page.
-  // A value of 0 generally indicates top left. If the extension has no launch
-  // index a -1 value is returned.
-  int GetAppLaunchIndex(const std::string& extension_id);
+  // Get the application launch ordinal for an extension with |extension_id|.
+  // This determines the order of which the applications appear on the page it

[akalin, 2011/12/02 19:48:23]

First sentence should change extension -> app

Rewrite second sentence as:

This determines the order in which the app appears on the page it's on in the
New Tab Page.  (Note that you can compare app launch ordinals only if the apps
are on the same page.)

[csharp, 2011/12/05 15:30:24]

Done.

+  // is specified to appear on in the New Tab Page. A string value close to
+  // |a*| generally indicates top left. If the extension has no launch ordinal,
+  // an invalid StringOrdinal is returned.
+  StringOrdinal GetAppLaunchOrdinal(const std::string& extension_id) const;
 
-  // Sets a specific launch index for an extension with |extension_id|.
-  void SetAppLaunchIndex(const std::string& extension_id, int index);
+  // Sets a specific launch ordinal for an extension with |extension_id|.

[akalin, 2011/12/02 19:48:23]

extension -> app

[csharp, 2011/12/05 15:30:24]

Done.

+  void SetAppLaunchOrdinal(const std::string& extension_id,
+                           const StringOrdinal& ordinal);
 
-  // Gets the next available application launch index. This is 1 higher than the
-  // highest current application launch index found for the page |on_page|.
-  int GetNextAppLaunchIndex(int on_page);
+  // Create a StringOrdinal which will be the first element for the given page.

[akalin, 2011/12/02 19:48:23]

// Returns a StringOrdinal that is lower than any app launch ordinal for the
given page.

[csharp, 2011/12/05 15:30:24]

Done.

+  StringOrdinal CreateFirstAppLaunchOrdinal(const StringOrdinal& page_ordinal)
+      const;
 
-  // Gets the page a new app should install to. Starts on page 0, and if there
-  // are N or more apps on it, tries to install on the next page.
-  int GetNaturalAppPageIndex();
+  // Creates a ordinal value that is higher than the highest current

[akalin, 2011/12/02 19:48:23]

// Returns a StringOrdinal that is higher than any app launch ordinal for the
given page.

[csharp, 2011/12/05 15:30:24]

Done.

+  // application launch ordinal found for the page |page_ordinal|.
+  StringOrdinal CreateNextAppLaunchOrdinal(const StringOrdinal& page_ordinal)
+      const;
 
-  // Sets the order the apps should be displayed in the app launcher.
-  void SetAppLauncherOrder(const std::vector<std::string>& extension_ids);
+  // Create a StringOrdinal that will be the first page.

[akalin, 2011/12/02 19:48:23]

// Returns a StringOrdinal that is lower than any existing page ordinal.

[csharp, 2011/12/05 15:30:24]

Done.

+  StringOrdinal CreateFirstAppPage() const;

[akalin, 2011/12/02 19:48:23]

maybe rename to CreateFirstAppPageOrdinal() to be more consistent

[csharp, 2011/12/05 15:30:24]

Done.

 
-  // Get the application page index for an extension with |extension_id|.  This
-  // determines which page an app will appear on in page-based NTPs.  If
-  // the app has no page specified, -1 is returned.
-  int GetPageIndex(const std::string& extension_id);
+  // Gets the page a new app should install to. Starts on the first page, and if
+  // there are N or more apps on it, tries to install on the next page.

[akalin, 2011/12/02 19:48:23]

// Gets the page a new app should install to, which is the earliest non-full
page.  The returned ordinal may correspond to a page that doesn't yet exist if
all pages are full.

[csharp, 2011/12/05 15:30:24]

Done.

+  StringOrdinal GetNaturalAppPageOrdinal() const;
 
-  // Sets a specific page index for an extension with |extension_id|.
-  void SetPageIndex(const std::string& extension_id, int index);
+  // Get the application page ordinal for an extension with |extension_id|.

[akalin, 2011/12/02 19:48:23]

application page -> page, extension -> app

[csharp, 2011/12/05 15:30:24]

Done.

+  // This determines which page an app will appear on in page-based NTPs.  If
+  // the app has no page specified, an invalid StringOrdinal is returned.
+  StringOrdinal GetPageOrdinal(const std::string& extension_id) const;
 
-  // Removes the page index for an extension.
-  void ClearPageIndex(const std::string& extension_id);
+  // Sets a specific page ordinal for an extension with |extension_id|.

[akalin, 2011/12/02 19:48:23]

extension -> app

[csharp, 2011/12/05 15:30:24]

Done.

+  void SetPageOrdinal(const std::string& extension_id,
+                      const StringOrdinal& ordinal);
+
+  // Removes the page ordinal for an extension.

[akalin, 2011/12/02 19:48:23]

extension -> app

[csharp, 2011/12/05 15:30:24]

Done.

+  void ClearPageOrdinal(const std::string& extension_id);
+
+  // Convert the page StringOrdinal value to its integer equivalent. This takes
+  // O(# of apps) worst-case.
+  int PageStringOrdinalAsInteger(const StringOrdinal& page_ordinal) const;
+
+  // Converts the page index integer to its StringOrdinal equivalent. This takes
+  // O(# of apps) worst-case.
+  StringOrdinal PageIntegerAsStringOrdinal(size_t page_index) const;
 
   // Returns true if the user repositioned the app on the app launcher via drag
   // and drop.
   bool WasAppDraggedByUser(const std::string& extension_id);
 
   // Sets a flag indicating that the user repositioned the app on the app
   // launcher by drag and dropping it.
   void SetAppDraggedByUser(const std::string& extension_id);
 
   // The extension's update URL data.  If not empty, the ExtensionUpdater
@@ skipping 55 matching lines @@
 
   // The underlying PrefService.
   PrefService* pref_service() const { return prefs_; }
 
  protected:
   // For unit testing. Enables injecting an artificial clock that is used
   // to query the current time, when an extension is installed.
   virtual base::Time GetCurrentTime() const;
 
  private:
+  friend class ExtensionPrefsGetMinAndMaxLaunchOrdinalsOnPage;  // Unit test.
+  friend class ExtensionPrefsMigrateAppIndex;  // Unit test.
   friend class ExtensionPrefsUninstallExtension;  // Unit test.
 
   // ExtensionContentSettingsStore::Observer methods:
   virtual void OnContentSettingChanged(
       const std::string& extension_id,
       bool incognito) OVERRIDE;
 
   // Converts absolute paths in the pref to paths relative to the
   // install_directory_.
   void MakePathsRelative();
@@ skipping 28 matching lines @@
   // Reads an integer pref |pref_key| from extension with id |extension_id|.
   bool ReadExtensionPrefInteger(const std::string& extension_id,
                                 const std::string& pref_key,
                                 int* out_value);
 
   // Reads a list pref |pref_key| from extension with id |extension_id|.
   bool ReadExtensionPrefList(const std::string& extension_id,
                              const std::string& pref_key,
                              const base::ListValue** out_value);
 
+  // Reads a string pref |pref_key| from extension with id |extension_id|.
+  bool ReadExtensionPrefString(const std::string& extension_id,
+                               const std::string& pref_key,
+                               std::string* out_value) const;
+
   // Interprets the list pref, |pref_key| in |extension_id|'s preferences, as a
   // URLPatternSet. The |valid_schemes| specify how to parse the URLPatterns.
   bool ReadExtensionPrefURLPatternSet(const std::string& extension_id,
                                       const std::string& pref_key,
                                       URLPatternSet* result,
                                       int valid_schemes);
 
   // Converts |new_value| to a list of strings and sets the |pref_key| pref
   // belonging to |extension_id|.
   void SetExtensionPrefURLPatternSet(const std::string& extension_id,
@@ skipping 37 matching lines @@
   // in a later Chrome version.
   void FixMissingPrefs(const ExtensionIdSet& extension_ids);
 
   // Installs the persistent extension preferences into |prefs_|'s extension
   // pref store. Does nothing if |extensions_disabled| is true.
   void InitPrefStore(bool extensions_disabled);
 
   // Migrates the permissions data in the pref store.
   void MigratePermissions(const ExtensionIdSet& extension_ids);
 
+  // Migrates the app launcher and page index values.
+  void MigrateAppIndex(const ExtensionIdSet& extension_ids);
+
   // Checks whether there is a state pref for the extension and if so, whether
   // it matches |check_state|.
   bool DoesExtensionHaveState(const std::string& id,
                               Extension::State check_state) const;
 
+  // This function sets |min_app_launch_value| to contain the lowest
+  // ordinal on |page_ordinal| and |max_app_launch_value| to contain the
+  // largest ordinal on |page_ordinal|. If there are no apps on the page then
+  // |min_app_launch_value| and |max_app_launch_value| are unchanged. It is an
+  // error to call this function with an invalid |page_ordinal| or
+  // NULL values for |min_app_launch_value| or |max_app_launch_value|.
+  void GetMinAndMaxAppLaunchOrdinalsOnPage(
+      const StringOrdinal& page_ordinal,
+      StringOrdinal* min_app_launch_value,
+      StringOrdinal* max_app_launch_value) const;
+
+  // Initialize the |page_ordinal_map_| with the page ordinals used by the
+  // given extensions.
+  void InitializePageOrdinalMap(const ExtensionIdSet& extension_ids);
+
+  // Called when an application changes the value of its page ordinal so that
+  // |page_ordinal_map_| is aware that |old_value| page ordinal has been
+  // replace by the |new_value| page ordinal and adjusts its mapping
+  // accordingly. This works with valid and invalid StringOrdinals.
+  void UpdatePageOrdinalMap(const StringOrdinal& old_value,
+                            const StringOrdinal& new_value);
+
   // The pref service specific to this set of extension prefs. Owned by profile.
   PrefService* prefs_;
 
   // Base extensions install directory.
   FilePath install_directory_;
 
+  // A map of all the StringOrdinal page indices mapping to how often they are
+  // used, this is used for mapping the StringOrdinals to their integer
+  // equivalent as well as quick lookup of the sorted StringOrdinals.
+  std::map<StringOrdinal, int, StringOrdinalLessThan> page_ordinal_map_;

[akalin, 2011/12/02 19:48:23]

actually, i think it's better to have a two-layer map, from page ordinals to
some structure that allows lookups of page ordinals by id and vice versa.  But
that seems like a big change, so maybe just add a TODO for that

[csharp, 2011/12/05 15:30:24]

Done.

+
   // Weak pointer, owned by Profile.
   ExtensionPrefValueMap* extension_pref_value_map_;
 
   scoped_refptr<ExtensionContentSettingsStore> content_settings_store_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_