arc: Support pinned apps across Arc-enabled and Arc-disabled platforms.

chrome/browser/ui/app_list/app_list_syncable_service.cc

 // Copyright 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/ui/app_list/app_list_syncable_service.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 48 matching lines @@
 const char kDriveAppSyncIdPrefix[] = "drive-app-";
 
 void UpdateSyncItemFromSync(const sync_pb::AppListSpecifics& specifics,
                             AppListSyncableService::SyncItem* item) {
   DCHECK_EQ(item->item_id, specifics.item_id());
   item->item_type = specifics.item_type();
   item->item_name = specifics.item_name();
   item->parent_id = specifics.parent_id();
   if (!specifics.item_ordinal().empty())
     item->item_ordinal = syncer::StringOrdinal(specifics.item_ordinal());
+  item->item_pin_ordinal = syncer::StringOrdinal(specifics.item_pin_ordinal());

[stevenjb, 2016/06/14 22:44:08]

An unfortunate side effect of this is that if an older version of chrome updates
a sync item (e.g. because it was moved) it would inadvertantly unpin the item.

Looking back through the sync code, I think this is what we want for both
item_ordinal and item_pin_ordinal:

if (specifics.has_item_pin_ordinal())
  item->item_pin_ordinal = syncer::StringOrdinal(specifics.item_pin_ordinal());

That way if the value is unset (vs. empty), any existing state will not be
overwritten.

(For item_ordinal those are synonymous since item_ordinal.empty() has no special
meaning, whereas with item_pin_ordinal, empty() means unpinned)

[khmel, 2016/06/15 17:01:19]

That is great point. I missed this possibility, thanks! Also extended unit_tests

 }
 
 bool UpdateSyncItemFromAppItem(const AppListItem* app_item,
                                AppListSyncableService::SyncItem* sync_item) {
   DCHECK_EQ(sync_item->item_id, app_item->id());
   bool changed = false;
   if (app_list::switches::IsFolderUIEnabled() &&
       sync_item->parent_id != app_item->folder_id()) {
     sync_item->parent_id = app_item->folder_id();
     changed = true;
@@ skipping 10 matching lines @@
   return changed;
 }
 
 void GetSyncSpecificsFromSyncItem(const AppListSyncableService::SyncItem* item,
                                   sync_pb::AppListSpecifics* specifics) {
   DCHECK(specifics);
   specifics->set_item_id(item->item_id);
   specifics->set_item_type(item->item_type);
   specifics->set_item_name(item->item_name);
   specifics->set_parent_id(item->parent_id);
-  if (item->item_ordinal.IsValid())
-    specifics->set_item_ordinal(item->item_ordinal.ToInternalValue());
+  specifics->set_item_ordinal(item->item_ordinal.IsValid() ?
+      item->item_ordinal.ToInternalValue() : std::string());
+  specifics->set_item_pin_ordinal(item->item_pin_ordinal.IsValid() ?
+      item->item_pin_ordinal.ToInternalValue() : std::string());
 }
 
 syncer::SyncData GetSyncDataFromSyncItem(
     const AppListSyncableService::SyncItem* item) {
   sync_pb::EntitySpecifics specifics;
   GetSyncSpecificsFromSyncItem(item, specifics.mutable_app_list());
   return syncer::SyncData::CreateLocalData(item->item_id,
                                            item->item_id,
                                            specifics);
 }
@@ skipping 180 matching lines @@
 #endif
   }
 
   model_pref_updater_.reset(
       new ModelPrefUpdater(AppListPrefs::Get(profile_), model_.get()));
 
   if (app_list::switches::IsDriveAppsInAppListEnabled())
     drive_app_provider_.reset(new DriveAppProvider(profile_, this));
 }
 
+void AppListSyncableService::AddObserverAndStart(Observer* observer) {
+  observer_list_.AddObserver(observer);
+  SyncStarted();
+}
+
+void AppListSyncableService::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+void AppListSyncableService::NotifyObserversSyncUpdated() {
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnSyncModelUpdated());
+}
+
 size_t AppListSyncableService::GetNumSyncItemsForTest() {
   // If the model isn't built yet, there will be no sync items.
   GetModel();
 
   return sync_items_.size();
 }
 
 void AppListSyncableService::ResetDriveAppProviderForTest() {
   drive_app_provider_.reset();
 }
@@ skipping 104 matching lines @@
   sync_pb::AppListSpecifics::AppListItemType type;
   if (!GetAppListItemType(app_item, &type))
     return NULL;
   VLOG(2) << this << " CreateSyncItemFromAppItem:" << app_item->ToDebugString();
   SyncItem* sync_item = CreateSyncItem(app_item->id(), type);
   UpdateSyncItemFromAppItem(app_item, sync_item);
   SendSyncChange(sync_item, SyncChange::ACTION_ADD);
   return sync_item;
 }
 
+syncer::StringOrdinal AppListSyncableService::GetPinPosition(
+    const std::string& app_id) {
+  SyncItem* sync_item = FindSyncItem(app_id);
+  if (!sync_item)
+    return syncer::StringOrdinal();
+  return sync_item->item_pin_ordinal;
+}
+
+void AppListSyncableService::SetPinPosition(
+    const std::string& app_id,
+    const syncer::StringOrdinal& item_pin_ordinal) {
+  SyncItem* sync_item = FindSyncItem(app_id);
+  SyncChange::SyncChangeType sync_change_type;
+  if (sync_item) {
+    sync_change_type = SyncChange::ACTION_UPDATE;
+  } else {
+    sync_item = CreateSyncItem(app_id, sync_pb::AppListSpecifics::TYPE_APP);
+    sync_change_type = SyncChange::ACTION_ADD;
+  }
+
+  sync_item->item_pin_ordinal = item_pin_ordinal;
+  SendSyncChange(sync_item, sync_change_type);
+}
+
 void AppListSyncableService::AddOrUpdateFromSyncItem(AppListItem* app_item) {
   // Do not create a sync item for the OEM folder here, do that in
   // ResolveFolderPositions once the position has been resolved.
   if (app_item->id() == kOemFolderId)
     return;
 
   SyncItem* sync_item = FindSyncItem(app_item->id());
   if (sync_item) {
     UpdateAppItemFromSyncItem(sync_item, app_item);
     return;
@@ skipping 226 matching lines @@
   }
   sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
 
   // Adding items may have created folders without setting their positions
   // since we haven't started observing the item list yet. Resolve those.
   ResolveFolderPositions();
 
   // Start observing app list model changes.
   model_observer_.reset(new ModelObserver(this));
 
+  NotifyObserversSyncUpdated();
+
   return result;
 }
 
 void AppListSyncableService::StopSyncing(syncer::ModelType type) {
   DCHECK_EQ(type, syncer::APP_LIST);
 
   sync_processor_.reset();
   sync_error_handler_.reset();
   model_->SetFoldersEnabled(false);
 }
@@ skipping 38 matching lines @@
     } else if (change.change_type() == SyncChange::ACTION_DELETE) {
       DeleteSyncItemSpecifics(change.sync_data().GetSpecifics().app_list());
     } else {
       LOG(ERROR) << "Invalid sync change";
     }
   }
 
   // Continue observing app list model changes.
   model_observer_.reset(new ModelObserver(this));
 
+  NotifyObserversSyncUpdated();
+
   return syncer::SyncError();
 }
 
 // AppListSyncableService private
 
 bool AppListSyncableService::ProcessSyncItemSpecifics(
     const sync_pb::AppListSpecifics& specifics) {
   const std::string& item_id = specifics.item_id();
   if (item_id.empty()) {
     LOG(ERROR) << "AppList item with empty ID";
@@ skipping 88 matching lines @@
     VLOG(2) << " Moving Item To Folder: " << sync_item->parent_id;
     model_->MoveItemToFolder(app_item, sync_item->parent_id);
   }
   UpdateAppItemFromSyncItem(sync_item, app_item);
 }
 
 void AppListSyncableService::UpdateAppItemFromSyncItem(
     const AppListSyncableService::SyncItem* sync_item,
     AppListItem* app_item) {
   VLOG(2) << this << " UpdateAppItemFromSyncItem: " << sync_item->ToString();
-  if (!app_item->position().Equals(sync_item->item_ordinal))
+  if (sync_item->item_ordinal.IsValid() &&
+      !app_item->position().Equals(sync_item->item_ordinal)) {
     model_->SetItemPosition(app_item, sync_item->item_ordinal);
+  }
   // Only update the item name if it is a Folder or the name is empty.
   if (sync_item->item_name != app_item->name() &&
       sync_item->item_id != kOemFolderId &&
       (app_item->GetItemType() == AppListFolderItem::kItemType ||
        app_item->name().empty())) {
     model_->SetItemName(app_item, sync_item->item_name);
   }
 }
 
 bool AppListSyncableService::SyncStarted() {
@@ skipping 157 matching lines @@
 
 std::string AppListSyncableService::SyncItem::ToString() const {
   std::string res = item_id.substr(0, 8);
   if (item_type == sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
     res += " { RemoveDefault }";
   } else {
     res += " { " + item_name + " }";
     res += " [" + item_ordinal.ToDebugString() + "]";
     if (!parent_id.empty())
       res += " <" + parent_id.substr(0, 8) + ">";
+    res += " [" + item_pin_ordinal.ToDebugString() + "]";
   }
   return res;
 }
 
 }  // namespace app_list