Sync removal of Default apps.

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 "base/command_line.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_service.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/host_desktop.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/notification_source.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/sync.pb.h"
+#include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item_model.h"
 #include "ui/app_list/app_list_model.h"
 
 using syncer::SyncChange;
 
 namespace app_list {
 
 namespace {
 
 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.page_ordinal().empty())
     item->page_ordinal = syncer::StringOrdinal(specifics.page_ordinal());
   if (!specifics.item_ordinal().empty())
     item->item_ordinal = syncer::StringOrdinal(specifics.item_ordinal());
 }
 
 bool UpdateSyncItemFromAppItem(const AppListItemModel* app_item,
                                AppListSyncableService::SyncItem* sync_item) {
   DCHECK_EQ(sync_item->item_id, app_item->id());
   bool changed = false;
+  if (sync_item->item_name != app_item->title()) {
+    sync_item->item_name = app_item->title();
+    changed = true;
+  }
   if (!sync_item->item_ordinal.IsValid() ||
       !app_item->position().Equals(sync_item->item_ordinal)) {
     sync_item->item_ordinal = app_item->position();
     changed = true;
   }
   // TODO(stevenjb): Set parent_id and page_ordinal.
   return changed;
 }
 
 void GetSyncSpecificsFromSyncItem(const AppListSyncableService::SyncItem* item,
@@ skipping 11 matching lines @@
 
 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);
 }
 
+bool AppIsDefault(ExtensionService* service, const std::string& id) {
+  return service && service->extension_prefs()->WasInstalledByDefault(id);
+}
+
+bool AppIsPlatformApp(ExtensionService* service, const std::string& id) {
+  if (!service)
+    return false;
+  const extensions::Extension* app = service->GetInstalledExtension(id);
+  DVLOG_IF(1, !app) << "No App for ID: " << id;
+  return app ? app->is_platform_app() : false;
+}
+
+void UninstallExtension(ExtensionService* service, const std::string& id) {
+  if (service && service->GetInstalledExtension(id))
+    service->UninstallExtension(id, false, NULL);
+}
+
 }  // namespace
 
 // AppListSyncableService::SyncItem
 
 AppListSyncableService::SyncItem::SyncItem(
     const std::string& id,
     sync_pb::AppListSpecifics::AppListItemType type)
     : item_id(id),
       item_type(type) {
 }
 
 AppListSyncableService::SyncItem::~SyncItem() {
 }
 
 // AppListSyncableService
 
 AppListSyncableService::AppListSyncableService(
     Profile* profile,
     ExtensionService* extension_service)
     : profile_(profile),
+      extension_service_(extension_service),
       model_(new AppListModel) {
-  if (extension_service && extension_service->is_ready()) {
+  if (!extension_service) {
+    LOG(WARNING) << "AppListSyncableService created with no ExtensionService";
+    return;
+  }
+
+  if (extension_service->is_ready()) {
     BuildModel();
     return;
   }
 
   // The extensions for this profile have not yet all been loaded.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<Profile>(profile));
 }
 
 AppListSyncableService::~AppListSyncableService() {
@@ skipping 35 matching lines @@
 }
 
 const AppListSyncableService::SyncItem*
 AppListSyncableService::GetSyncItem(const std::string& id) const {
   SyncItemMap::const_iterator iter = sync_items_.find(id);
   if (iter != sync_items_.end())
     return iter->second;
   return NULL;
 }
 
-void AppListSyncableService::AddExtensionAppItem(ExtensionAppItem* item) {
-  SyncItem* sync_item = AddItem(
-      sync_pb::AppListSpecifics_AppListItemType_TYPE_APP, item);
-  if (!sync_item)
-    return;  // Item already exists.
-  sync_item->item_name = item->extension_name();
+void AppListSyncableService::AddItem(AppListItemModel* item) {
+  const std::string& item_id = item->id();
+  if (item_id.empty()) {
+    LOG(ERROR) << "AppListItemModel item with empty ID";
+    return;
+  }
+  sync_pb::AppListSpecifics::AppListItemType type;
+  const char* item_type = item->GetAppType();
+  if (item_type == ExtensionAppItem::kAppType) {
+    type = sync_pb::AppListSpecifics_AppListItemType_TYPE_APP;
+  } else if (item_type == AppListFolderItem::kAppType) {
+    type = sync_pb::AppListSpecifics_AppListItemType_TYPE_FOLDER;
+  } else {
+    LOG(ERROR) << "Unrecognized model type: " << item_type;
+    return;
+  }
+  SyncItem* sync_item = FindSyncItem(item_id);
+  if (sync_item) {
+    // If there is an existing, non-REMOVE_DEFAULT entry, update it.
+    if (sync_item->item_type !=
+        sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
+      DCHECK_EQ(sync_item->item_type, type);
+      DVLOG(2) << this << ": AddItem already exists: " << sync_item->ToString();
+      UpdateItem(item);
+      return;
+    }
+    // If there is an existing REMOVE_DEFAULT entry, uninstall the app instead.
+    if (type == sync_pb::AppListSpecifics_AppListItemType_TYPE_APP &&
+        AppIsDefault(extension_service_, item_id)) {
+      DVLOG(1) << this << ": AddItem: Uninstall: " << sync_item->ToString();
+      UninstallExtension(extension_service_, item_id);
+      return;
+    }
+    // Otherwise, delete the REMOVE_DEFAULT entry.

[Nicolas Zea, 2013/12/20 20:44:30]

I'm not sure I understand the purpose of this. If you have a remove_default
entry, don't you need to keep it around for other clients? Why would you delete
it?

[stevenjb, 2013/12/20 21:05:56]

I updated this comment and the comment above to clarify; this case is for when a
removed Default app is getting added as a non-Default app, i.e. installed from
the store.

+    if (SyncStarted()) {
+      DVLOG(2) << this << " -> SYNC DELETE: " << sync_item->ToString();
+      SyncChange sync_change(FROM_HERE, SyncChange::ACTION_DELETE,
+                             GetSyncDataFromSyncItem(sync_item));
+      sync_processor_->ProcessSyncChanges(
+          FROM_HERE, syncer::SyncChangeList(1, sync_change));
+    }
+    delete sync_item;
+    sync_items_.erase(item_id);

[Nicolas Zea, 2013/12/20 20:44:30]

should you return after this?

[stevenjb, 2013/12/20 21:05:56]

No, now we add the app as usual. Comment added.

+  }
+
+  sync_item = CreateSyncItem(item_id, type);
+  UpdateSyncItemFromAppItem(item, sync_item);
+  model_->item_list()->AddItem(item);
+  DVLOG(1) << this << ": AddItem: " << sync_item->ToString()
+           << " Default: " << AppIsDefault(extension_service_, item->id());
   SendSyncChange(sync_item, SyncChange::ACTION_ADD);
 }
 
-void AppListSyncableService::UpdateExtensionAppItem(ExtensionAppItem* item) {
+void AppListSyncableService::UpdateItem(AppListItemModel* item) {
   SyncItem* sync_item = FindSyncItem(item->id());
   if (!sync_item) {
-    LOG(ERROR) << "UpdateExtensionAppItem: no sync item: " << item->id();
+    LOG(ERROR) << "UpdateItem: no sync item: " << item->id();
     return;
   }
   bool changed = UpdateSyncItemFromAppItem(item, sync_item);
-  if (sync_item->item_name != item->extension_name()) {
-    sync_item->item_name = item->extension_name();
-    changed = true;
-  }
   if (!changed) {
     DVLOG(2) << this << " - Update: SYNC NO CHANGE: " << sync_item->ToString();
     return;
   }
   SendSyncChange(sync_item, SyncChange::ACTION_UPDATE);
 }
 
 void AppListSyncableService::RemoveItem(const std::string& id) {
   DVLOG(2) << this << ": RemoveItem: " << id.substr(0, 8);
   SyncItemMap::iterator iter = sync_items_.find(id);
-  if (iter == sync_items_.end())
+  if (iter == sync_items_.end()) {
+    DVLOG(2) << this << " : No Sync Item.";
     return;
+  }
+  // Always delete the item from the model.
+  model_->item_list()->DeleteItem(id);
+
+  // Check for existing RemoveDefault sync item.
   SyncItem* sync_item = iter->second;
+  if (sync_item->item_type ==
+      sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
+    // RemoveDefault item exists, just return.
+    DVLOG(2) << this << " : RemoveDefault Item exists.";
+    return;
+  }
+
+  // Existing entry is a normal entry, send a Delete sync change and remove
+  // the entry.
   if (SyncStarted()) {
     DVLOG(2) << this << " -> SYNC DELETE: " << sync_item->ToString();
     SyncChange sync_change(FROM_HERE, SyncChange::ACTION_DELETE,
                            GetSyncDataFromSyncItem(sync_item));
     sync_processor_->ProcessSyncChanges(
         FROM_HERE, syncer::SyncChangeList(1, sync_change));

[Nicolas Zea, 2013/12/20 20:44:30]

Are you creating two incompatible changes for the same item here (a DELETE, then
an ADD)? 

[stevenjb, 2013/12/20 21:05:56]

If the app is a Default app, we will DELETE any APP entry, then *possibly* add a
REMOVE_DEFAULT entry. I believe the sync system may combine these to a single
UPDATE change, which we will handle correctly. Is that right, will that work?

[Nicolas Zea, 2013/12/30 19:49:00]

It should theoretically work, but it's a bit confusing to understand. I think
you can rewrite it differently though, by checking whether the app is default
first, and creating/updating as a remove default item, otherwise performing the
deletion.

[stevenjb, 2014/01/02 21:15:48]

Fair enough. Done.

   }
   delete sync_item;
   sync_items_.erase(iter);
-  model_->item_list()->DeleteItem(id);
+
+  if (!AppIsDefault(extension_service_, id))
+    return;
+  // This is a Default app; create and send a REMOVE_DEFAULT sync change.
+  // Note: we add the REMOVE_DEFAULT entry after we delete the existing entry.
+  sync_item = CreateSyncItem(
+      id, sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP);
+  DVLOG(1) << this << ": RemoveDefaultItem: " << sync_item->ToString();
+  SendSyncChange(sync_item, SyncChange::ACTION_ADD);
 }
 
 // AppListSyncableService syncer::SyncableService
 
 syncer::SyncMergeResult AppListSyncableService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK(!sync_processor_.get());
@@ skipping 13 matching lines @@
   for (SyncItemMap::const_iterator iter = sync_items_.begin();
        iter != sync_items_.end(); ++iter) {
     unsynced_items.insert(iter->first);
   }
 
   // Create SyncItem entries for initial_sync_data.
   size_t new_items = 0, updated_items = 0;
   for (syncer::SyncDataList::const_iterator iter = initial_sync_data.begin();
        iter != initial_sync_data.end(); ++iter) {
     const syncer::SyncData& data = *iter;
+    DVLOG(2) << this << "  Initial Sync Item: "
+             << data.GetSpecifics().app_list().item_id()
+             << " Type: " << data.GetSpecifics().app_list().item_type();
     DCHECK_EQ(syncer::APP_LIST, data.GetDataType());
-    if (CreateOrUpdateSyncItem(data.GetSpecifics().app_list()))
+    if (ProcessSyncItem(data.GetSpecifics().app_list()))
       ++new_items;
     else
       ++updated_items;
     unsynced_items.erase(data.GetSpecifics().app_list().item_id());
   }
 
   result.set_num_items_after_association(sync_items_.size());
   result.set_num_items_added(new_items);
   result.set_num_items_deleted(0);
   result.set_num_items_modified(updated_items);
@@ skipping 16 matching lines @@
   DCHECK_EQ(type, syncer::APP_LIST);
 
   sync_processor_.reset();
   sync_error_handler_.reset();
 }
 
 syncer::SyncDataList AppListSyncableService::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(syncer::APP_LIST, type);
 
-  DVLOG(1) << this << "GetAllSyncData: " << sync_items_.size();
+  DVLOG(1) << this << ": GetAllSyncData: " << sync_items_.size();
   syncer::SyncDataList list;
   for (SyncItemMap::const_iterator iter = sync_items_.begin();
        iter != sync_items_.end(); ++iter) {
     DVLOG(2) << this << " -> SYNC: " << iter->second->ToString();
     list.push_back(GetSyncDataFromSyncItem(iter->second));
   }
   return list;
 }
 
 syncer::SyncError AppListSyncableService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   if (!sync_processor_.get()) {
     return syncer::SyncError(FROM_HERE,
                              syncer::SyncError::DATATYPE_ERROR,
                              "App List syncable service is not started.",
                              syncer::APP_LIST);
   }
 
-  // Process incoming changes first.
   DVLOG(1) << this << ": ProcessSyncChanges: " << change_list.size();
   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
        iter != change_list.end(); ++iter) {
     const SyncChange& change = *iter;
+    DVLOG(2) << this << "  Change: "
+             << change.sync_data().GetSpecifics().app_list().item_id()
+             << " (" << change.change_type() << ")";
     if (change.change_type() == SyncChange::ACTION_ADD ||
         change.change_type() == SyncChange::ACTION_UPDATE) {
-      CreateOrUpdateSyncItem(change.sync_data().GetSpecifics().app_list());
+      ProcessSyncItem(change.sync_data().GetSpecifics().app_list());
     } else if (change.change_type() == SyncChange::ACTION_DELETE) {
       DeleteSyncItem(change.sync_data().GetSpecifics().app_list());
     } else {
       LOG(ERROR) << "Invalid sync change";
     }
   }
   return syncer::SyncError();
 }
 
 // AppListSyncableService private
 
-void AppListSyncableService::CreateAppItemFromSyncItem(SyncItem* sync_item) {
-  if (sync_item->item_type == sync_pb::AppListSpecifics::TYPE_APP) {
-    std::string extension_id = sync_item->item_id;
-    const ExtensionService* extension_service =
-        extensions::ExtensionSystem::Get(profile_)->extension_service();
-    const extensions::Extension* app =
-        extension_service->GetInstalledExtension(extension_id);
-    DVLOG_IF(1, !app) << this << "No App for ID: " << extension_id;
-    bool is_platform_app = app ? app->is_platform_app() : false;
-    ExtensionAppItem* app_item = new ExtensionAppItem(
-        profile_,
-        sync_item,
-        extension_id,
-        sync_item->item_name,
-        gfx::ImageSkia(),
-        is_platform_app);
-    model_->item_list()->AddItem(app_item);
-    return;
+bool AppListSyncableService::ProcessSyncItem(
+    const sync_pb::AppListSpecifics& specifics) {
+  const std::string& item_id = specifics.item_id();
+  if (item_id.empty()) {
+    LOG(ERROR) << "AppList item with empty ID";
+    return false;
   }
-  if (sync_item->item_type ==
+  SyncItem* sync_item = FindSyncItem(item_id);
+  if (sync_item) {
+    // If an item of the same type exists, update it.
+    if (sync_item->item_type == specifics.item_type()) {
+      UpdateSyncItemFromSync(specifics, sync_item);
+      ProcessExistingSyncItem(sync_item);
+      DVLOG(2) << this << " <- SYNC UPDATE: " << sync_item->ToString();
+      return false;
+    }
+    // Otherwise, one of the entries should be TYPE_REMOVE_DEFAULT_APP.
+    if (sync_item->item_type !=
+        sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP &&
+        specifics.item_type() !=
+        sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
+      LOG(ERROR) << "Synced item type: " << specifics.item_type()
+                 << " != existing sync item type: " << sync_item->item_type
+                 << " Deleting item from model!";
+      model_->item_list()->DeleteItem(item_id);
+    }
+    DVLOG(2) << this << " - ProcessSyncItem: Delete existing entry: "
+             << sync_item->ToString();
+    delete sync_item;
+    sync_items_.erase(item_id);
+  }
+
+  sync_item = CreateSyncItem(item_id, specifics.item_type());
+  UpdateSyncItemFromSync(specifics, sync_item);
+  ProcessNewSyncItem(sync_item);
+  DVLOG(2) << this << " <- SYNC ADD: " << sync_item->ToString();
+  return true;
+}
+
+void AppListSyncableService::ProcessNewSyncItem(SyncItem* sync_item) {
+  switch (sync_item->item_type) {
+    case sync_pb::AppListSpecifics::TYPE_APP: {
+      std::string extension_id = sync_item->item_id;
+      bool is_platform_app = AppIsPlatformApp(extension_service_, extension_id);
+      ExtensionAppItem* app_item = new ExtensionAppItem(
+          profile_,
+          sync_item,
+          extension_id,
+          sync_item->item_name,
+          gfx::ImageSkia(),
+          is_platform_app);
+      model_->item_list()->AddItem(app_item);
+      return;
+    }
+    case sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP: {
+      DVLOG(1) << this << ": Uninstall: " << sync_item->ToString();
+      UninstallExtension(extension_service_, sync_item->item_id);
+      return;
+    }
+    case sync_pb::AppListSpecifics::TYPE_FOLDER: {
+      // TODO(stevenjb): Implement
+      LOG(WARNING) << "TYPE_FOLDER not supported";
+      return;
+    }
+    case sync_pb::AppListSpecifics::TYPE_URL: {
+      // TODO(stevenjb): Implement
+      LOG(WARNING) << "TYPE_URL not supported";
+      return;
+    }
+  }
+  NOTREACHED() << "Unrecoginized sync item type: " << sync_item->ToString();
+}
+
+void AppListSyncableService::ProcessExistingSyncItem(SyncItem* sync_item) {
+  if (sync_item->item_type !=
       sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
-    // TODO(stevenjb): Implement
+    AppListItemModel* item =
+        model_->item_list()->FindItem(sync_item->item_id);
+    if (item && !item->position().Equals(sync_item->item_ordinal))
+      model_->item_list()->SetItemPosition(item, sync_item->item_ordinal);
   }
-  if (sync_item->item_type == sync_pb::AppListSpecifics::TYPE_FOLDER) {
-    // TODO(stevenjb): Implement
-  }
-  if (sync_item->item_type == sync_pb::AppListSpecifics::TYPE_URL) {
-    // TODO(stevenjb): Implement
-  }
-  LOG(ERROR) << "Unsupported type: " << sync_item->item_type;
 }
 
 bool AppListSyncableService::SyncStarted() {
   if (sync_processor_.get())
     return true;
   if (flare_.is_null()) {
     DVLOG(2) << this << ": SyncStarted: Flare.";
     flare_ = sync_start_util::GetFlareForSyncableService(profile_->GetPath());
     flare_.Run(syncer::APP_LIST);
   }
   return false;
 }
 
-AppListSyncableService::SyncItem* AppListSyncableService::AddItem(
-    sync_pb::AppListSpecifics::AppListItemType type,
-    AppListItemModel* app_item) {
-  const std::string& item_id = app_item->id();
-  if (item_id.empty()) {
-    LOG(ERROR) << "AppListItemModel item with empty ID";
-    return NULL;
-  }
-  bool new_item = false;
-  SyncItem* sync_item = FindOrCreateSyncItem(item_id, type, &new_item);
-  if (!new_item) {
-    DVLOG(2) << this << ": AddItem already exists: " << sync_item->ToString();
-    return NULL;  // Item already exists.
-  }
-  UpdateSyncItemFromAppItem(app_item, sync_item);
-  DVLOG(1) << this << ": AddItem: " << sync_item->ToString();
-  model_->item_list()->AddItem(app_item);
-  return sync_item;
-}
-
 void AppListSyncableService::SendSyncChange(
     SyncItem* sync_item,
     SyncChange::SyncChangeType sync_change_type) {
   if (!SyncStarted()) {
     DVLOG(2) << this << " - SendSyncChange: SYNC NOT STARTED: "
              << sync_item->ToString();
     return;
   }
   if (sync_change_type == SyncChange::ACTION_ADD)
     DVLOG(2) << this << " -> SYNC ADD: " << sync_item->ToString();
   else
     DVLOG(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())
     return NULL;
   return iter->second;
 }
 
-AppListSyncableService::SyncItem* AppListSyncableService::FindOrCreateSyncItem(
+AppListSyncableService::SyncItem*
+AppListSyncableService::CreateSyncItem(
     const std::string& item_id,
-    sync_pb::AppListSpecifics::AppListItemType type,
-    bool* new_item) {
-  SyncItem* item = FindSyncItem(item_id);
-  if (item) {
-    DCHECK(type == item->item_type);
-    *new_item = false;
-    return item;
-  }
-
-  item = new SyncItem(item_id, type);
-  sync_items_[item_id] = item;
-  *new_item = true;
-  return item;
-}
-
-bool AppListSyncableService::CreateOrUpdateSyncItem(
-    const sync_pb::AppListSpecifics& specifics) {
-  const std::string& item_id = specifics.item_id();
-  if (item_id.empty()) {
-    LOG(ERROR) << "CreateOrUpdate AppList item with empty ID";
-    return false;
-  }
-  bool new_item = false;
-  SyncItem* sync_item =
-      FindOrCreateSyncItem(item_id, specifics.item_type(), &new_item);
-  DVLOG(2) << this << "CreateOrUpdateSyncItem: " << sync_item->ToString()
-           << " New: " << new_item << " Pos: " << specifics.item_ordinal();
-  UpdateSyncItemFromSync(specifics, sync_item);
-  // Update existing item in model
-  AppListItemModel* item = model_->item_list()->FindItem(sync_item->item_id);
-  if (item && !item->position().Equals(sync_item->item_ordinal))
-    model_->item_list()->SetItemPosition(item, sync_item->item_ordinal);
-  if (new_item) {
-    CreateAppItemFromSyncItem(sync_item);
-    DVLOG(2) << this << " <- SYNC ADD: " << sync_item->ToString();
-  } else {
-    DVLOG(2) << this << " <- SYNC UPDATE: " << sync_item->ToString();
-  }
-  return new_item;
+    sync_pb::AppListSpecifics::AppListItemType item_type) {
+  DCHECK(!ContainsKey(sync_items_, item_id));
+  SyncItem* sync_item = new SyncItem(item_id, item_type);
+  sync_items_[item_id] = sync_item;
+  return sync_item;
 }
 
 void AppListSyncableService::DeleteSyncItem(
     const sync_pb::AppListSpecifics& specifics) {
   const std::string& item_id = specifics.item_id();
   if (item_id.empty()) {
     LOG(ERROR) << "Delete AppList item with empty ID";
     return;
   }
-  DVLOG(2) << this << "DeleteSyncItem: " << item_id.substr(0, 8);
+  DVLOG(2) << this << ": DeleteSyncItem: " << item_id.substr(0, 8);
   SyncItemMap::iterator iter = sync_items_.find(item_id);
   if (iter == sync_items_.end())
     return;
+  sync_pb::AppListSpecifics::AppListItemType item_type =
+      iter->second->item_type;
   DVLOG(2) << this << " <- SYNC DELETE: " << iter->second->ToString();
   delete iter->second;
   sync_items_.erase(iter);
-  model_->item_list()->DeleteItem(item_id);
+  if (item_type != sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP)
+    model_->item_list()->DeleteItem(item_id);
 }
 
 std::string AppListSyncableService::SyncItem::ToString() const {
-  return item_id.substr(0, 8) + " [" + item_ordinal.ToDebugString() + "]";
+  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() + "]";
+  }
+  return res;
 }
 
 }  // namespace app_list