Remove usage of FOR_EACH_OBSERVER macro in ui/app_list

ui/app_list/app_list_model.cc

 // Copyright (c) 2012 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 "ui/app_list/app_list_model.h"
 
 #include <string>
 #include <utility>
 
 #include "ui/app_list/app_list_folder_item.h"
@@ skipping 23 matching lines @@
 
 void AppListModel::RemoveObserver(AppListModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void AppListModel::SetStatus(Status status) {
   if (status_ == status)
     return;
 
   status_ = status;
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListModelStatusChanged());
+  for (auto& observer : observers_)
+    observer.OnAppListModelStatusChanged();
 }
 
 void AppListModel::SetState(State state) {
   if (state_ == state)
     return;
 
   State old_state = state_;
 
   state_ = state;
 
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListModelStateChanged(old_state, state_));
+  for (auto& observer : observers_)
+    observer.OnAppListModelStateChanged(old_state, state_);
 }
 
 AppListItem* AppListModel::FindItem(const std::string& id) {
   AppListItem* item = top_level_item_list_->FindItem(id);
   if (item)
     return item;
   for (size_t i = 0; i < top_level_item_list_->item_count(); ++i) {
     AppListItem* child_item =
         top_level_item_list_->item_at(i)->FindChildItem(id);
     if (child_item)
@@ skipping 155 matching lines @@
   if (!item->IsInFolder()) {
     top_level_item_list_->SetItemPosition(item, new_position);
     // Note: this will trigger OnListItemMoved which will signal observers.
     // (This is done this way because some View code still moves items within
     // the item list directly).
     return;
   }
   AppListFolderItem* folder = FindFolderItem(item->folder_id());
   DCHECK(folder);
   folder->item_list()->SetItemPosition(item, new_position);
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemUpdated(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemUpdated(item);
 }
 
 void AppListModel::SetItemName(AppListItem* item, const std::string& name) {
   item->SetName(name);
   DVLOG(2) << "AppListModel::SetItemName: " << item->ToDebugString();
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemUpdated(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemUpdated(item);
 }
 
 void AppListModel::SetItemNameAndShortName(AppListItem* item,
                                            const std::string& name,
                                            const std::string& short_name) {
   item->SetNameAndShortName(name, short_name);
   DVLOG(2) << "AppListModel::SetItemNameAndShortName: "
            << item->ToDebugString();
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemUpdated(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemUpdated(item);
 }
 
 void AppListModel::DeleteItem(const std::string& id) {
   AppListItem* item = FindItem(id);
   if (!item)
     return;
   if (!item->IsInFolder()) {
     DCHECK_EQ(0u, item->ChildItemCount())
         << "Invalid call to DeleteItem for item with children: " << id;
-    FOR_EACH_OBSERVER(AppListModelObserver,
-                      observers_,
-                      OnAppListItemWillBeDeleted(item));
+    for (auto& observer : observers_)
+      observer.OnAppListItemWillBeDeleted(item);
     top_level_item_list_->DeleteItem(id);
-    FOR_EACH_OBSERVER(AppListModelObserver, observers_, OnAppListItemDeleted());
+    for (auto& observer : observers_)
+      observer.OnAppListItemDeleted();
     return;
   }
   AppListFolderItem* folder = FindFolderItem(item->folder_id());
   DCHECK(folder) << "Folder not found for item: " << item->ToDebugString();
   std::unique_ptr<AppListItem> child_item = RemoveItemFromFolder(folder, item);
   DCHECK_EQ(item, child_item.get());
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemWillBeDeleted(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemWillBeDeleted(item);
   child_item.reset();  // Deletes item.
-  FOR_EACH_OBSERVER(AppListModelObserver, observers_, OnAppListItemDeleted());
+  for (auto& observer : observers_)
+    observer.OnAppListItemDeleted();
 }
 
 void AppListModel::DeleteUninstalledItem(const std::string& id) {
   AppListItem* item = FindItem(id);
   if (!item)
     return;
   const std::string folder_id = item->folder_id();
   DeleteItem(id);
 
   // crbug.com/368111: Upon uninstall of 2nd-to-last folder item, reparent last
@@ skipping 30 matching lines @@
     }
     folder_ids.push_back(folder->id());
   }
   // Delete folders.
   for (size_t i = 0; i < folder_ids.size(); ++i)
     DeleteItem(folder_ids[i]);
 }
 
 void AppListModel::SetCustomLauncherPageEnabled(bool enabled) {
   custom_launcher_page_enabled_ = enabled;
-  FOR_EACH_OBSERVER(AppListModelObserver, observers_,
-                    OnCustomLauncherPageEnabledStateChanged(enabled));
+  for (auto& observer : observers_)
+    observer.OnCustomLauncherPageEnabledStateChanged(enabled);
 }
 
 std::vector<SearchResult*> AppListModel::FilterSearchResultsByDisplayType(
     SearchResults* results,
     SearchResult::DisplayType display_type,
     size_t max_results) {
   std::vector<SearchResult*> matches;
   for (size_t i = 0; i < results->item_count(); ++i) {
     SearchResult* item = results->GetItemAt(i);
     if (item->display_type() == display_type) {
@@ skipping 16 matching lines @@
   --custom_launcher_page_subpage_depth_;
   return true;
 }
 
 void AppListModel::ClearCustomLauncherPageSubpages() {
   custom_launcher_page_subpage_depth_ = 0;
 }
 
 void AppListModel::SetSearchEngineIsGoogle(bool is_google) {
   search_engine_is_google_ = is_google;
-  FOR_EACH_OBSERVER(AppListModelObserver, observers_,
-                    OnSearchEngineIsGoogleChanged(is_google));
+  for (auto& observer : observers_)
+    observer.OnSearchEngineIsGoogleChanged(is_google);
 }
 
 // Private methods
 
 void AppListModel::OnListItemMoved(size_t from_index,
                                    size_t to_index,
                                    AppListItem* item) {
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemUpdated(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemUpdated(item);
 }
 
 AppListFolderItem* AppListModel::FindOrCreateFolderItem(
     const std::string& folder_id) {
   if (folder_id.empty())
     return NULL;
 
   AppListFolderItem* dest_folder = FindFolderItem(folder_id);
   if (dest_folder)
     return dest_folder;
@@ skipping 10 matching lines @@
       top_level_item_list_->CreatePositionBefore(syncer::StringOrdinal()));
   AppListItem* new_folder_item =
       AddItemToItemListAndNotify(std::move(new_folder));
   return static_cast<AppListFolderItem*>(new_folder_item);
 }
 
 AppListItem* AppListModel::AddItemToItemListAndNotify(
     std::unique_ptr<AppListItem> item_ptr) {
   DCHECK(!item_ptr->IsInFolder());
   AppListItem* item = top_level_item_list_->AddItem(std::move(item_ptr));
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemAdded(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemAdded(item);
   return item;
 }
 
 AppListItem* AppListModel::AddItemToItemListAndNotifyUpdate(
     std::unique_ptr<AppListItem> item_ptr) {
   DCHECK(!item_ptr->IsInFolder());
   AppListItem* item = top_level_item_list_->AddItem(std::move(item_ptr));
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemUpdated(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemUpdated(item);
   return item;
 }
 
 AppListItem* AppListModel::AddItemToFolderItemAndNotify(
     AppListFolderItem* folder,
     std::unique_ptr<AppListItem> item_ptr) {
   CHECK_NE(folder->id(), item_ptr->folder_id());
   AppListItem* item = folder->item_list()->AddItem(std::move(item_ptr));
   item->set_folder_id(folder->id());
-  FOR_EACH_OBSERVER(AppListModelObserver,
-                    observers_,
-                    OnAppListItemUpdated(item));
+  for (auto& observer : observers_)
+    observer.OnAppListItemUpdated(item);
   return item;
 }
 
 std::unique_ptr<AppListItem> AppListModel::RemoveItem(AppListItem* item) {
   if (!item->IsInFolder())
     return top_level_item_list_->RemoveItem(item->id());
 
   AppListFolderItem* folder = FindFolderItem(item->folder_id());
   return RemoveItemFromFolder(folder, item);
 }
 
 std::unique_ptr<AppListItem> AppListModel::RemoveItemFromFolder(
     AppListFolderItem* folder,
     AppListItem* item) {
   std::string folder_id = folder->id();
   CHECK_EQ(item->folder_id(), folder_id);
   std::unique_ptr<AppListItem> result =
       folder->item_list()->RemoveItem(item->id());
   result->set_folder_id("");
   if (folder->item_list()->item_count() == 0) {
     DVLOG(2) << "Deleting empty folder: " << folder->ToDebugString();
     DeleteItem(folder_id);
   }
   return result;
 }
 
 }  // namespace app_list