cros: Implement default app ordering.

chrome/browser/extensions/extension_sorting.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 "chrome/browser/extensions/extension_sorting.h"
 
+#include <algorithm>
+#include <vector>
+
 #include "chrome/browser/extensions/extension_scoped_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 
 using extensions::ExtensionPrefs;
 
 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 size_t kNaturalAppPageSize = 18;
 
 // A preference determining the order of which the apps appear on the NTP.
 const char kPrefAppLaunchIndexDeprecated[] = "app_launcher_index";
 const char kPrefAppLaunchOrdinal[] = "app_launcher_ordinal";
 
 // A preference determining the page on which an app appears in the NTP.
 const char kPrefPageIndexDeprecated[] = "page_index";
 const char kPrefPageOrdinal[] = "page_ordinal";
 
 }  // namespace
 
 ExtensionSorting::ExtensionSorting(ExtensionScopedPrefs* extension_scoped_prefs,
                                    PrefService* pref_service)
     : extension_scoped_prefs_(extension_scoped_prefs),
       pref_service_(pref_service),
       extension_service_(NULL) {
+  CreateDefaultOrdinals();
 }
 
 ExtensionSorting::~ExtensionSorting() {
 }
 
 void ExtensionSorting::SetExtensionService(
     ExtensionServiceInterface* extension_service) {
   extension_service_ = extension_service;
 }
 
@@ skipping 149 matching lines @@
       }
     }
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED,
       content::Source<ExtensionSorting>(this),
       content::NotificationService::NoDetails());
 }
 
-void ExtensionSorting::EnsureValidOrdinals(const std::string& extension_id) {
+void ExtensionSorting::EnsureValidOrdinals(
+    const std::string& extension_id,
+    const syncer::StringOrdinal& suggested_page) {
   syncer::StringOrdinal page_ordinal = GetPageOrdinal(extension_id);
   if (!page_ordinal.IsValid()) {
-    // The webstore app should always start be on the first page.
-    page_ordinal = extension_id == extension_misc::kWebStoreAppId ?
-        CreateFirstAppPageOrdinal() :
-        GetNaturalAppPageOrdinal();
+    if (suggested_page.IsValid()) {
+      page_ordinal = suggested_page;
+    } else if (!GetDefaultOrdinals(extension_id, &page_ordinal, NULL) ||
+        !page_ordinal.IsValid()) {
+      page_ordinal = GetNaturalAppPageOrdinal();
+    }
+
     SetPageOrdinal(extension_id, page_ordinal);
   }
 
   syncer::StringOrdinal app_launch_ordinal = GetAppLaunchOrdinal(extension_id);
   if (!app_launch_ordinal.IsValid()) {
-    // The webstore app should always start in the position.
-    app_launch_ordinal = extension_id == extension_misc::kWebStoreAppId ?
-        CreateFirstAppLaunchOrdinal(page_ordinal) :
-        CreateNextAppLaunchOrdinal(page_ordinal);
-    SetAppLaunchOrdinal(extension_id,
-                        app_launch_ordinal);
+    // If using default app launcher ordinal, make sure there is no collision.
+    if (GetDefaultOrdinals(extension_id, NULL, &app_launch_ordinal) &&
+        app_launch_ordinal.IsValid())
+      app_launch_ordinal = ResolveCollision(page_ordinal, app_launch_ordinal);
+    else
+      app_launch_ordinal = CreateNextAppLaunchOrdinal(page_ordinal);
+
+    SetAppLaunchOrdinal(extension_id, app_launch_ordinal);
   }
 }
 
 void ExtensionSorting::OnExtensionMoved(
     const std::string& moved_extension_id,
     const std::string& predecessor_extension_id,
     const std::string& successor_extension_id) {
   // We only need to change the StringOrdinal if there are neighbours.
   if (!predecessor_extension_id.empty() || !successor_extension_id.empty()) {
     if (predecessor_extension_id.empty()) {
@@ skipping 275 matching lines @@
     if (ext) {
       // It is possible for old extension to have ordinal values, but they
       // shouldn't so we clear them.
       if (!ext->is_app())
         ClearOrdinals(extension_id);
 
       extension_service_->SyncExtensionChangeIfNeeded(*ext);
     }
   }
 }
+
+void ExtensionSorting::CreateDefaultOrdinals() {
+  // The following defines the default order of apps.
+#if defined(OS_CHROMEOS)
+  const char* kDefaultAppOrder[] = {
+    extension_misc::kChromeAppId,
+    extension_misc::kWebStoreAppId,
+    "coobgpohoikkiipiblmjeljniedjpjpf",  // Search
+    "blpcfgokakmgnkcojhhkbfbldkacnbeo",  // Youtube
+    "pjkljhegncpnkpknbcohdijeoejaedia",  // Gmail
+    "ejjicmeblgpmajnghnpcppodonldlgfn",  // Calendar
+    "kjebfhglflhjjjiceimfkgicifkhjlnm",  // Scratchpad
+    "lneaknkopdijkpnocmklfnjbeapigfbh",  // Google Maps
+    "apdfllckaahabafndbhieahigkjlhalf",  // Drive
+    "aohghmighlieiainnegkcijnfilokake",  // Docs
+    "felcaaldnbdncclmgdcncolpebgiejap",  // Sheets
+    "aapocclcgogkmnckokdopfmhonfmgoek",  // Slides
+    "dlppkpafhbajpcmmoheippocdidnckmm",  // Google+
+    "kbpgddbgniojgndnhlkjbkpknjhppkbk",  // Google+ Hangouts
+    "hhaomjibdihmijegdhdafkllkbggdgoj",  // Files
+    "hkhhlkdconhgemhegnplaldnmnmkaemd",  // Tips & Tricks
+    "icppfcnhkcmnfdhfhphakoifcfokfdhg",  // Play Music
+    "mmimngoggfoobjdlefbcabngfnmieonb",  // Play Books
+    "fppdphmgcddhjeddoeghpjefkdlccljb",  // Play Movies
+    "fobcpibfeplaikcclojfdhfdmbbeofai",  // Games
+    "joodangkbfjnajiiifokapkpmhfnpleo",  // Calculator
+    "cmbmjjimlbmpkonhnfabflhampihgnea",  // Camera
+    "gbchcmhmhahfdphkhkmpfmihenigjmpp",  // Chrome Remote Desktop
+  };
+#else
+  const char* kDefaultAppOrder[] = {
+    extension_misc::kWebStoreAppId,
+  };
+#endif
+
+  syncer::StringOrdinal page_ordinal = CreateFirstAppPageOrdinal();
+  syncer::StringOrdinal app_launch_ordinal =
+      CreateFirstAppLaunchOrdinal(page_ordinal);
+  for (size_t i = 0; i < arraysize(kDefaultAppOrder); ++i) {
+    const std::string extension_id = kDefaultAppOrder[i];
+    default_ordinals_[extension_id].page_ordinal = page_ordinal;
+    default_ordinals_[extension_id].app_launch_ordinal = app_launch_ordinal;
+    app_launch_ordinal = app_launch_ordinal.CreateAfter();
+  }
+}
+
+bool ExtensionSorting::GetDefaultOrdinals(
+    const std::string& extension_id,
+    syncer::StringOrdinal* page_ordinal,
+    syncer::StringOrdinal* app_launch_ordinal) const {
+  AppOrdinalsMap::const_iterator it = default_ordinals_.find(extension_id);
+  if (it == default_ordinals_.end())
+    return false;
+
+  if (page_ordinal)
+    *page_ordinal = it->second.page_ordinal;
+  if (app_launch_ordinal)
+    *app_launch_ordinal = it->second.app_launch_ordinal;
+  return true;
+}
+
+syncer::StringOrdinal ExtensionSorting::ResolveCollision(
+    const syncer::StringOrdinal& page_ordinal,
+    const syncer::StringOrdinal& app_launch_ordinal) const {
+  DCHECK(page_ordinal.IsValid() && app_launch_ordinal.IsValid());
+
+  PageOrdinalMap::const_iterator page_it = ntp_ordinal_map_.find(page_ordinal);
+  if (page_it == ntp_ordinal_map_.end())
+    return app_launch_ordinal;
+
+  const AppLaunchOrdinalMap& page = page_it->second;
+  if (page.find(app_launch_ordinal) == page.end())
+    return app_launch_ordinal;
+
+  syncer::StringOrdinal next_ordinal = app_launch_ordinal.CreateAfter();

[csharp, 2012/09/24 14:09:45]

I think this section should be replaced by:
return app_launch_ordinal.CreateBetween(page.find(app_launch_ordinal) + 1)

This way the app launch ordinal appears right after the one it conflicted with
(which I assume is the intended behavior)  

[xiyuan, 2012/09/24 16:37:12]

Done. Good call. This is much better than using a loop.

+  while (page.find(next_ordinal) != page.end())
+    next_ordinal = app_launch_ordinal.CreateBetween(next_ordinal);
+
+  return next_ordinal;
+}
+