Separate the NTP app ordering from the app list app ordering

chrome/browser/extensions/app_list_extension_ordering.cc

+// Copyright (c) 2013 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/app_list_extension_ordering.h"
+#include "chrome/browser/extensions/extension_prefs.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/notification_service.h"
+
+namespace {
+  const char kPrefAppListOrdinal[] = "app_list_ordinal";
+}
+
+AppListExtensionOrdering::AppListExtensionOrdering(
+    ExtensionScopedPrefs* extension_scoped_prefs)
+    : ExtensionOrdering(extension_scoped_prefs) {}
+AppListExtensionOrdering::~AppListExtensionOrdering() {}
+
+// ExtensionOrdering implementation.
+void AppListExtensionOrdering::Initialize(
+    const extensions::ExtensionIdList& extension_ids) {
+  for (extensions::ExtensionIdList::const_iterator ext_it =
+       extension_ids.begin(); ext_it != extension_ids.end(); ++ext_it) {
+    syncer::StringOrdinal ordinal = GetAppListOrdinal(*ext_it);
+    if (ordinal.IsValid()) {
+      SetAppListOrdinal(*ext_it, ordinal);
+    }
+
+    // Ensure that the web store app still isn't found in this list, since
+    // it is added after this loop.
+    DCHECK(*ext_it != extension_misc::kWebStoreAppId);
+    DCHECK(*ext_it != extension_misc::kChromeAppId);
+  }
+
+  // Include the Web Store App since it is displayed on the app list.
+  syncer::StringOrdinal web_store_app_ordinal =
+      GetAppListOrdinal(extension_misc::kWebStoreAppId);
+  if (web_store_app_ordinal.IsValid()) {
+    SetAppListOrdinal(extension_misc::kWebStoreAppId, web_store_app_ordinal);
+  }
+  // Include the Chrome App since it is displayed on the app list.
+  syncer::StringOrdinal chrome_app_ordinal =
+      GetAppListOrdinal(extension_misc::kChromeAppId);
+  if (web_store_app_ordinal.IsValid()) {
+    SetAppListOrdinal(extension_misc::kChromeAppId, chrome_app_ordinal);
+  }
+}
+
+void AppListExtensionOrdering::FixSyncCollisions() {
+  for (AppListOrdinalMap::iterator ordinal_map_it = app_list_ordinal_map_
+                                                    .begin();
+      ordinal_map_it != app_list_ordinal_map_.end(); ++ordinal_map_it) {
+    syncer::StringOrdinal repeated_ordinal = ordinal_map_it->first;
+    ExtensionIdSet& extension_set = ordinal_map_it->second;
+    if (extension_set.size() == 1)
+      continue;
+    AppListOrdinalMap::iterator next_it = ordinal_map_it;
+    ++next_it;
+
+    syncer::StringOrdinal upper_bound_ordinal =
+        next_it == app_list_ordinal_map_.end() ? syncer::StringOrdinal()
+                                               : next_it->first;
+    syncer::StringOrdinal lower_bound_ordinal = repeated_ordinal;
+    std::vector<std::string> conflicting_ids(extension_set.begin(),
+                                             extension_set.end());
+    // Start at position 1 because the first extension can keep the conflicted
+    // value.
+    for (size_t i = 1; i < conflicting_ids.size(); ++i) {
+      syncer::StringOrdinal unique_ordinal;
+      if (upper_bound_ordinal.IsValid()) {
+        unique_ordinal =
+            lower_bound_ordinal.CreateBetween(upper_bound_ordinal);
+      } else {
+        unique_ordinal = lower_bound_ordinal.CreateAfter();
+      }
+      Erase(conflicting_ids[i]);
+      SetAppListOrdinal(conflicting_ids[i], unique_ordinal);
+      lower_bound_ordinal = unique_ordinal;
+    }
+  }
+
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_APP_LIST_REORDERED,
+      content::Source<AppListExtensionOrdering>(this),
+      content::NotificationService::NoDetails());
+}
+
+void AppListExtensionOrdering::InsertAtFront(const std::string& extension_id) {
+  syncer::StringOrdinal ordinal = syncer::StringOrdinal::CreateInitialOrdinal();
+  if (!app_list_ordinal_map_.empty()) {
+    ordinal = app_list_ordinal_map_.begin()->first.CreateBefore();
+  }
+  SetAppListOrdinal(extension_id, ordinal);
+}
+
+void AppListExtensionOrdering::InsertAtBack(const std::string& extension_id) {
+  syncer::StringOrdinal ordinal = syncer::StringOrdinal::CreateInitialOrdinal();
+  if (!app_list_ordinal_map_.empty()) {
+    ordinal = app_list_ordinal_map_.rbegin()->first.CreateAfter();
+  }
+  SetAppListOrdinal(extension_id, ordinal);
+}
+
+void AppListExtensionOrdering::InsertAtNextAvailable(
+    const std::string& extension_id) {
+  InsertAtBack(extension_id);
+}
+
+void AppListExtensionOrdering::OnExtensionMoved(
+    const std::string& moved_extension_id,
+    const std::string& predecessor_extension_id,
+    const std::string& successor_extension_id) {
+  const syncer::StringOrdinal& predecessor_ordinal =
+      predecessor_extension_id.empty() ?
+          syncer::StringOrdinal() :
+          GetAppListOrdinal(predecessor_extension_id);
+  const syncer::StringOrdinal& successor_ordinal =
+      successor_extension_id.empty() ?
+          syncer::StringOrdinal() :
+          GetAppListOrdinal(successor_extension_id);
+  // We only need to change the StringOrdinal if there are neighbours.
+  if (predecessor_ordinal.IsValid() || successor_ordinal.IsValid()) {
+    if (!predecessor_ordinal.IsValid()) {
+      // Only a successor.
+      SetAppListOrdinal(moved_extension_id, successor_ordinal.CreateBefore());
+    } else if (!successor_ordinal.IsValid()) {
+      // Only a predecessor.
+      SetAppListOrdinal(moved_extension_id, predecessor_ordinal.CreateAfter());
+    } else {
+      // Both a successor and predecessor
+      SetAppListOrdinal(moved_extension_id,
+                        predecessor_ordinal.CreateBetween(successor_ordinal));
+    }
+  }
+
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_APP_LIST_REORDERED,
+      content::Source<AppListExtensionOrdering>(this),
+      content::Details<const std::string>(&moved_extension_id));
+}
+
+void AppListExtensionOrdering::Erase(const std::string& extension_id) {
+  AppListOrdinalMap::iterator ordinal_map_it =
+      app_list_ordinal_map_.find(GetAppListOrdinal(extension_id));
+  if (ordinal_map_it != app_list_ordinal_map_.end()) {
+    ordinal_map_it->second.erase(extension_id);
+    if (ordinal_map_it->second.empty())
+      app_list_ordinal_map_.erase(ordinal_map_it);
+  }
+  UpdatePrefs(extension_id, syncer::StringOrdinal());
+}
+
+bool AppListExtensionOrdering::ExtensionPrecedes(
+    const std::string& extension1,
+    const std::string& extension2) {
+  if (!GetAppListOrdinal(extension1).IsValid())
+    return false;
+  if (!GetAppListOrdinal(extension2).IsValid())
+    return true;
+  return GetAppListOrdinal(extension1).LessThan(GetAppListOrdinal(extension2));
+}
+
+syncer::StringOrdinal AppListExtensionOrdering::GetAppListOrdinal(
+    const std::string& extension_id) {
+  std::string raw_data;
+  // If the preference read fails then raw_data will still be unset and we will
+  // return an invalid StringOrdinal to signal that no page ordinal was found.
+  extension_scoped_prefs_->ReadPrefAsString(
+      extension_id, kPrefAppListOrdinal, &raw_data);
+  return syncer::StringOrdinal(raw_data);
+}
+
+void AppListExtensionOrdering::SetAppListOrdinal(
+    const std::string& extension_id,
+    const syncer::StringOrdinal& ordinal) {
+  app_list_ordinal_map_[ordinal].insert(extension_id);
+  UpdatePrefs(extension_id, ordinal);
+}
+
+void AppListExtensionOrdering::UpdatePrefs(
+    const std::string& extension_id,
+    const syncer::StringOrdinal& ordinal) {
+  if (ordinal.EqualsOrBothInvalid(GetAppListOrdinal(extension_id)))
+    return;
+  Value* new_value = ordinal.IsValid() ?
+      Value::CreateStringValue(ordinal.ToInternalValue()) :
+      NULL;
+  extension_scoped_prefs_->UpdateExtensionPref(
+      extension_id,
+      kPrefAppListOrdinal,
+      new_value);
+  SyncIfNeeded(extension_id);
+}