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"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/drive/drive_app_provider.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_prefs.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
+#include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/extension_app_item.h"
 #include "chrome/browser/ui/app_list/extension_app_model_builder.h"
 #include "chrome/browser/ui/app_list/model_pref_updater.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
@@ skipping 31 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());
+  item->item_pin_by_policy = specifics.item_pin_by_policy();
 }
 
 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 12 matching lines @@
 
 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_pin_ordinal(item->item_pin_ordinal.IsValid() ?
+      item->item_pin_ordinal.ToInternalValue() : std::string());
+  specifics->set_item_pin_by_policy(item->item_pin_by_policy);
 }
 
 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 55 matching lines @@
 }
 
 }  // namespace
 
 // AppListSyncableService::SyncItem
 
 AppListSyncableService::SyncItem::SyncItem(
     const std::string& id,
     sync_pb::AppListSpecifics::AppListItemType type)
     : item_id(id),
-      item_type(type) {
+      item_type(type),
+      item_pin_by_policy(false) {
 }
 
 AppListSyncableService::SyncItem::~SyncItem() {
 }
 
 // AppListSyncableService::ModelObserver
 
 class AppListSyncableService::ModelObserver : public AppListModelObserver {
  public:
   explicit ModelObserver(AppListSyncableService* owner)
@@ skipping 41 matching lines @@
   }
 
   AppListSyncableService* owner_;
   AppListItem* adding_item_;  // Unowned pointer to item being added.
 
   DISALLOW_COPY_AND_ASSIGN(ModelObserver);
 };
 
 // AppListSyncableService
 
+// static
+AppListSyncableService* AppListSyncableService::Get(Profile* profile) {
+  return AppListSyncableServiceFactory::GetForProfile(profile);
+}
+
+
 AppListSyncableService::AppListSyncableService(
     Profile* profile,
     extensions::ExtensionSystem* extension_system)
     : profile_(profile),
       extension_system_(extension_system),
       model_(new AppListModel),
       initial_sync_data_processed_(false),
       first_app_list_sync_(true) {
   if (!extension_system) {
     LOG(ERROR) << "AppListSyncableService created with no ExtensionSystem";
@@ skipping 43 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;
 }
 
+bool AppListSyncableService::GetPinByPolicy(const std::string& app_id) {
+  SyncItem* sync_item = FindSyncItem(app_id);
+  if (!sync_item)
+    return false;
+  return sync_item->item_pin_by_policy;
+}
+
+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,
+    bool pinned_by_policy) {
+  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;
+  sync_item->item_pin_by_policy = pinned_by_policy;
+  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);
   }
 }
 
@@ skipping 19 matching lines @@
   if (!initial_sync_data_processed_ &&
       sync_change_type == SyncChange::ACTION_ADD) {
     // This can occur if an initial item is created before its folder item.
     // A sync item should already exist for the folder, so we do not want to
     // send an ADD event, since that would trigger a CHECK in the sync code.
     DCHECK(sync_item->item_type == sync_pb::AppListSpecifics::TYPE_FOLDER);
     DVLOG(2) << this << " - SendSyncChange: ADD before initial data processed: "
              << sync_item->ToString();
     return;
   }
-  if (sync_change_type == SyncChange::ACTION_ADD)
+  if (sync_change_type == SyncChange::ACTION_ADD) {
     VLOG(2) << this << " -> SYNC ADD: " << sync_item->ToString();
-  else
+  } else {
     VLOG(2) << this << " -> SYNC UPDATE: " << sync_item->ToString();
+  }
   SyncChange sync_change(FROM_HERE, sync_change_type,
                          GetSyncDataFromSyncItem(sync_item));
   sync_processor_->ProcessSyncChanges(
       FROM_HERE, syncer::SyncChangeList(1, sync_change));
 }
 
 AppListSyncableService::SyncItem*
 AppListSyncableService::FindSyncItem(const std::string& item_id) {
   SyncItemMap::iterator iter = sync_items_.find(item_id);
   if (iter == sync_items_.end())
@@ skipping 115 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