Remove stl_util's STLDeleteContainerPairSecondPointers.

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/memory/ptr_util.h"
+#include "base/stl_util.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/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"
@@ skipping 247 matching lines @@
   }
 
   oem_folder_name_ =
       l10n_util::GetStringUTF8(IDS_APP_LIST_OEM_DEFAULT_FOLDER_NAME);
 }
 
 AppListSyncableService::~AppListSyncableService() {
   // Remove observers.
   model_observer_.reset();
   model_pref_updater_.reset();
-
-  base::STLDeleteContainerPairSecondPointers(sync_items_.begin(),
-                                             sync_items_.end());
 }
 
 void AppListSyncableService::BuildModel() {
   // TODO(calamity): make this a DCHECK after a dev channel release.
   CHECK(extension_system_->extension_service() &&
         extension_system_->extension_service()->is_ready());
   AppListControllerDelegate* controller = NULL;
   AppListService* service = AppListService::Get();
   if (service)
     controller = service->GetControllerDelegate();
@@ skipping 74 matching lines @@
 
 void AppListSyncableService::UntrackUninstalledDriveApp(
     const std::string& drive_app_id) {
   const std::string sync_id = GetDriveAppSyncId(drive_app_id);
   SyncItem* sync_item = FindSyncItem(sync_id);
   if (!sync_item)
     return;
 
   DCHECK_EQ(sync_item->item_type,
             sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP);
-  DeleteSyncItem(sync_item);
+  DeleteSyncItem(drive_app_id);
 }
 
 const AppListSyncableService::SyncItem*
 AppListSyncableService::GetSyncItem(const std::string& id) const {
-  SyncItemMap::const_iterator iter = sync_items_.find(id);
+  auto iter = sync_items_.find(id);
   if (iter != sync_items_.end())
-    return iter->second;
+    return iter->second.get();
   return NULL;
 }
 
 void AppListSyncableService::SetOemFolderName(const std::string& name) {
   oem_folder_name_ = name;
   AppListFolderItem* oem_folder = model_->FindFolderItem(kOemFolderId);
   if (oem_folder)
     model_->SetItemName(oem_folder, oem_folder_name_);
 }
 
@@ skipping 111 matching lines @@
       AppIsDefault(extension_system_->extension_service(), item->id())) {
     VLOG(2) << this << ": HandleDefaultApp: Uninstall: "
             << sync_item->ToString();
     UninstallExtension(extension_system_->extension_service(), item->id());
     return true;
   }
 
   // Otherwise, we are adding the app as a non-default app (i.e. an app that
   // was installed by Default and removed is getting installed explicitly by
   // the user), so delete the REMOVE_DEFAULT_APP.
-  DeleteSyncItem(sync_item);
+  DeleteSyncItem(sync_item->item_id);
   return false;
 }
 
-void AppListSyncableService::DeleteSyncItem(SyncItem* sync_item) {
+void AppListSyncableService::DeleteSyncItem(const std::string& item_id) {
+  SyncItem* sync_item = FindSyncItem(item_id);
+  if (!sync_item) {
+    LOG(ERROR) << "DeleteSyncItem: no sync item: " << item_id;
+    return;
+  }
   if (SyncStarted()) {
     VLOG(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));
   }
-  std::string item_id = sync_item->item_id;
-  delete sync_item;
   sync_items_.erase(item_id);
 }
 
 void AppListSyncableService::UpdateSyncItem(AppListItem* app_item) {
   SyncItem* sync_item = FindSyncItem(app_item->id());
   if (!sync_item) {
     LOG(ERROR) << "UpdateItem: no sync item: " << app_item->id();
     return;
   }
   bool changed = UpdateSyncItemFromAppItem(app_item, sync_item);
@@ skipping 22 matching lines @@
     return;
   bool is_oem = AppIsOem(app_item->id());
   if (!is_oem && app_item->folder_id() == kOemFolderId)
     model_->MoveItemToFolder(app_item, "");
   else if (is_oem && app_item->folder_id() != kOemFolderId)
     model_->MoveItemToFolder(app_item, kOemFolderId);
 }
 
 void AppListSyncableService::RemoveSyncItem(const std::string& id) {
   VLOG(2) << this << ": RemoveSyncItem: " << id.substr(0, 8);
-  SyncItemMap::iterator iter = sync_items_.find(id);
+  auto iter = sync_items_.find(id);
   if (iter == sync_items_.end()) {
     DVLOG(2) << this << " : RemoveSyncItem: No Item.";
     return;
   }
 
   // Check for existing RemoveDefault sync item.
-  SyncItem* sync_item = iter->second;
+  SyncItem* sync_item = iter->second.get();
   sync_pb::AppListSpecifics::AppListItemType type = sync_item->item_type;
   if (type == sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
     // RemoveDefault item exists, just return.
     DVLOG(2) << this << " : RemoveDefault Item exists.";
     return;
   }
 
   if (type == sync_pb::AppListSpecifics::TYPE_APP &&
       AppIsDefault(extension_system_->extension_service(), id)) {
     // This is a Default app; update the entry to a REMOVE_DEFAULT entry. This
     // will overwrite any existing entry for the item.
     VLOG(2) << this << " -> SYNC UPDATE: REMOVE_DEFAULT: "
             << sync_item->item_id;
     sync_item->item_type = sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP;
     SendSyncChange(sync_item, SyncChange::ACTION_UPDATE);
     return;
   }
 
-  DeleteSyncItem(sync_item);
+  DeleteSyncItem(iter->first);
 }
 
 void AppListSyncableService::ResolveFolderPositions() {
   if (!app_list::switches::IsFolderUIEnabled())
     return;
 
   VLOG(1) << "ResolveFolderPositions.";
-  for (SyncItemMap::iterator iter = sync_items_.begin();
-       iter != sync_items_.end(); ++iter) {
-    SyncItem* sync_item = iter->second;
+  for (const auto& sync_pair : sync_items_) {
+    SyncItem* sync_item = sync_pair.second.get();
     if (sync_item->item_type != sync_pb::AppListSpecifics::TYPE_FOLDER)
       continue;
     AppListItem* app_item = model_->FindItem(sync_item->item_id);
     if (!app_item)
       continue;
     UpdateAppItemFromSyncItem(sync_item, app_item);
   }
 
   // Move the OEM folder if one exists and we have not synced its position.
   AppListFolderItem* oem_folder = model_->FindFolderItem(kOemFolderId);
   if (oem_folder && !FindSyncItem(kOemFolderId)) {
     model_->SetItemPosition(oem_folder, GetOemFolderPos());
     VLOG(1) << "Creating new OEM folder sync item: "
             << oem_folder->position().ToDebugString();
     CreateSyncItemFromAppItem(oem_folder);
   }
 }
 
 void AppListSyncableService::PruneEmptySyncFolders() {
   if (!app_list::switches::IsFolderUIEnabled())
     return;
 
   std::set<std::string> parent_ids;
-  for (SyncItemMap::iterator iter = sync_items_.begin();
-       iter != sync_items_.end(); ++iter) {
-    parent_ids.insert(iter->second->parent_id);
-  }
-  for (SyncItemMap::iterator iter = sync_items_.begin();
-       iter != sync_items_.end(); ) {
-    SyncItem* sync_item = (iter++)->second;
+  for (const auto& sync_pair : sync_items_)
+    parent_ids.insert(sync_pair.second->parent_id);
+
+  for (auto iter = sync_items_.begin(); iter != sync_items_.end();) {
+    SyncItem* sync_item = (iter++)->second.get();
     if (sync_item->item_type != sync_pb::AppListSpecifics::TYPE_FOLDER)
       continue;
     if (!base::ContainsKey(parent_ids, sync_item->item_id))
-      DeleteSyncItem(sync_item);
+      DeleteSyncItem(sync_item->item_id);
   }
 }
 
 // AppListSyncableService syncer::SyncableService
 
 syncer::SyncMergeResult AppListSyncableService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
     std::unique_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(error_handler.get());
 
   // Ensure the model is built.
   GetModel();
 
   sync_processor_ = std::move(sync_processor);
   sync_error_handler_ = std::move(error_handler);
   if (switches::IsFolderUIEnabled())
     model_->SetFoldersEnabled(true);
 
   syncer::SyncMergeResult result = syncer::SyncMergeResult(type);
   result.set_num_items_before_association(sync_items_.size());
   VLOG(1) << this << ": MergeDataAndStartSyncing: "
           << initial_sync_data.size();
 
   // Copy all sync items to |unsynced_items|.
   std::set<std::string> unsynced_items;
-  for (SyncItemMap::const_iterator iter = sync_items_.begin();
-       iter != sync_items_.end(); ++iter) {
-    unsynced_items.insert(iter->first);
+  for (const auto& sync_pair : sync_items_) {
+    unsynced_items.insert(sync_pair.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;
     const std::string& item_id = data.GetSpecifics().app_list().item_id();
     const sync_pb::AppListSpecifics& specifics = data.GetSpecifics().app_list();
     DVLOG(2) << this << "  Initial Sync Item: " << item_id
@@ skipping 54 matching lines @@
   sync_error_handler_.reset();
   model_->SetFoldersEnabled(false);
 }
 
 syncer::SyncDataList AppListSyncableService::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(syncer::APP_LIST, type);
 
   VLOG(1) << this << ": GetAllSyncData: " << sync_items_.size();
   syncer::SyncDataList list;
-  for (SyncItemMap::const_iterator iter = sync_items_.begin();
-       iter != sync_items_.end(); ++iter) {
+  for (auto iter = sync_items_.begin(); iter != sync_items_.end(); ++iter) {
     VLOG(2) << this << " -> SYNC: " << iter->second->ToString();
-    list.push_back(GetSyncDataFromSyncItem(iter->second));
+    list.push_back(GetSyncDataFromSyncItem(iter->second.get()));
   }
   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,
@@ skipping 52 matching lines @@
         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_->DeleteItem(item_id);
     }
     VLOG(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);
   VLOG(2) << this << " <- SYNC ADD: " << sync_item->ToString();
   return true;
 }
 
@@ skipping 108 matching lines @@
   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);
+  auto iter = sync_items_.find(item_id);
   if (iter == sync_items_.end())
     return NULL;
-  return iter->second;
+  return iter->second.get();
 }
 
 AppListSyncableService::SyncItem*
 AppListSyncableService::CreateSyncItem(
     const std::string& item_id,
     sync_pb::AppListSpecifics::AppListItemType item_type) {
   DCHECK(!base::ContainsKey(sync_items_, item_id));
-  SyncItem* sync_item = new SyncItem(item_id, item_type);
-  sync_items_[item_id] = sync_item;
-  return sync_item;
+  sync_items_[item_id] = base::MakeUnique<SyncItem>(item_id, item_type);
+  return sync_items_[item_id].get();
 }
 
 void AppListSyncableService::DeleteSyncItemSpecifics(
     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;
   }
   VLOG(2) << this << ": DeleteSyncItemSpecifics: " << item_id.substr(0, 8);
-  SyncItemMap::iterator iter = sync_items_.find(item_id);
+  auto iter = sync_items_.find(item_id);
   if (iter == sync_items_.end())
     return;
   sync_pb::AppListSpecifics::AppListItemType item_type =
       iter->second->item_type;
   VLOG(2) << this << " <- SYNC DELETE: " << iter->second->ToString();
-  delete iter->second;
   sync_items_.erase(iter);
   // Only delete apps from the model. Folders will be deleted when all
   // children have been deleted.
   if (item_type == sync_pb::AppListSpecifics::TYPE_APP) {
     model_->DeleteItem(item_id);
   } else if (item_type == sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
     if (IsDriveAppSyncId(item_id) && drive_app_provider_) {
       drive_app_provider_->RemoveUninstalledDriveAppFromSync(
           GetDriveAppIdFromSyncId(item_id));
     }
@@ skipping 20 matching lines @@
   }
   model_->SetItemName(oem_folder, oem_folder_name_);
   return oem_folder->id();
 }
 
 syncer::StringOrdinal AppListSyncableService::GetOemFolderPos() {
   VLOG(1) << "GetOemFolderPos: " << first_app_list_sync_;
   if (!first_app_list_sync_) {
     VLOG(1) << "Sync items exist, placing OEM folder at end.";
     syncer::StringOrdinal last;
-    for (SyncItemMap::iterator iter = sync_items_.begin();
-         iter != sync_items_.end(); ++iter) {
-      SyncItem* sync_item = iter->second;
+    for (const auto& sync_pair : sync_items_) {
+      SyncItem* sync_item = sync_pair.second.get();
       if (sync_item->item_ordinal.IsValid() &&
           (!last.IsValid() || sync_item->item_ordinal.GreaterThan(last))) {
         last = sync_item->item_ordinal;
       }
     }
     if (last.IsValid())
       return last.CreateAfter();
   }
 
   // Place the OEM folder just after the web store, which should always be
@@ skipping 45 matching lines @@
     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