components/bookmarks: convert usage of FOR_EACH_OBSERVER macro

components/bookmarks/browser/bookmark_model.cc

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 111 matching lines @@
       loaded_signal_(base::WaitableEvent::ResetPolicy::MANUAL,
                      base::WaitableEvent::InitialState::NOT_SIGNALED),
       extensive_changes_(0),
       undo_delegate_(nullptr),
       empty_undo_delegate_(new EmptyUndoDelegate) {
   DCHECK(client_);
   client_->Init(this);
 }
 
 BookmarkModel::~BookmarkModel() {
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkModelBeingDeleted(this));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkModelBeingDeleted(this);
 
   if (store_.get()) {
     // The store maintains a reference back to us. We need to tell it we're gone
     // so that it doesn't try and invoke a method back on us again.
     store_->BookmarkModelDeleted();
   }
 }
 
 void BookmarkModel::Shutdown() {
   if (loaded_)
@@ skipping 27 matching lines @@
 void BookmarkModel::AddObserver(BookmarkModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void BookmarkModel::RemoveObserver(BookmarkModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void BookmarkModel::BeginExtensiveChanges() {
   if (++extensive_changes_ == 1) {
-    FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                      ExtensiveBookmarkChangesBeginning(this));
+    for (BookmarkModelObserver& observer : observers_)
+      observer.ExtensiveBookmarkChangesBeginning(this);
   }
 }
 
 void BookmarkModel::EndExtensiveChanges() {
   --extensive_changes_;
   DCHECK_GE(extensive_changes_, 0);
   if (extensive_changes_ == 0) {
-    FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                      ExtensiveBookmarkChangesEnded(this));
+    for (BookmarkModelObserver& observer : observers_)
+      observer.ExtensiveBookmarkChangesEnded(this);
   }
 }
 
 void BookmarkModel::BeginGroupedChanges() {
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    GroupedBookmarkChangesBeginning(this));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.GroupedBookmarkChangesBeginning(this);
 }
 
 void BookmarkModel::EndGroupedChanges() {
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    GroupedBookmarkChangesEnded(this));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.GroupedBookmarkChangesEnded(this);
 }
 
 void BookmarkModel::Remove(const BookmarkNode* node) {
   DCHECK(loaded_);
   DCHECK(node);
   DCHECK(!is_root_node(node));
   RemoveAndDeleteNode(AsMutable(node));
 }
 
 void BookmarkModel::RemoveAllUserBookmarks() {
   std::set<GURL> removed_urls;
   struct RemoveNodeData {
     const BookmarkNode* parent;
     int index;
     std::unique_ptr<BookmarkNode> node;
   };
   std::vector<RemoveNodeData> removed_node_data_list;
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillRemoveAllUserBookmarks(this));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillRemoveAllUserBookmarks(this);
 
   BeginExtensiveChanges();
   // Skip deleting permanent nodes. Permanent bookmark nodes are the root and
   // its immediate children. For removing all non permanent nodes just remove
   // all children of non-root permanent nodes.
   {
     base::AutoLock url_lock(url_lock_);
     for (int i = 0; i < root_.child_count(); ++i) {
       const BookmarkNode* permanent_node = root_.GetChild(i);
 
       if (!client_->CanBeEditedByUser(permanent_node))
         continue;
 
       for (int j = permanent_node->child_count() - 1; j >= 0; --j) {
         std::unique_ptr<BookmarkNode> node = RemoveNodeAndGetRemovedUrls(
             AsMutable(permanent_node->GetChild(j)), &removed_urls);
         removed_node_data_list.push_back({permanent_node, j, std::move(node)});
       }
     }
   }
   EndExtensiveChanges();
   if (store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkAllUserNodesRemoved(this, removed_urls));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkAllUserNodesRemoved(this, removed_urls);
 
   BeginGroupedChanges();
   for (auto& removed_node_data : removed_node_data_list) {
     undo_delegate()->OnBookmarkNodeRemoved(this, removed_node_data.parent,
                                            removed_node_data.index,
                                            std::move(removed_node_data.node));
   }
   EndGroupedChanges();
 }
 
@@ skipping 28 matching lines @@
 
   BookmarkNode* mutable_old_parent = AsMutable(old_parent);
   std::unique_ptr<BookmarkNode> owned_node =
       mutable_old_parent->Remove(AsMutable(node));
   BookmarkNode* mutable_new_parent = AsMutable(new_parent);
   mutable_new_parent->Add(std::move(owned_node), index);
 
   if (store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkNodeMoved(this, old_parent, old_index,
-                                      new_parent, index));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeMoved(this, old_parent, old_index, new_parent, index);
 }
 
 void BookmarkModel::Copy(const BookmarkNode* node,
                          const BookmarkNode* new_parent,
                          int index) {
   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
       is_root_node(new_parent) || is_permanent_node(node)) {
     NOTREACHED();
     return;
   }
@@ skipping 35 matching lines @@
   DCHECK(node);
 
   if (node->GetTitle() == title)
     return;
 
   if (is_permanent_node(node) && !client_->CanSetPermanentNodeTitle(node)) {
     NOTREACHED();
     return;
   }
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillChangeBookmarkNode(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillChangeBookmarkNode(this, node);
 
   // The title index doesn't support changing the title, instead we remove then
   // add it back.
   index_->Remove(node);
   AsMutable(node)->SetTitle(title);
   index_->Add(node);
 
   if (store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkNodeChanged(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeChanged(this, node);
 }
 
 void BookmarkModel::SetURL(const BookmarkNode* node, const GURL& url) {
   DCHECK(node && !node->is_folder());
 
   if (node->url() == url)
     return;
 
   BookmarkNode* mutable_node = AsMutable(node);
   mutable_node->InvalidateFavicon();
   CancelPendingFaviconLoadRequests(mutable_node);
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillChangeBookmarkNode(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillChangeBookmarkNode(this, node);
 
   {
     base::AutoLock url_lock(url_lock_);
     RemoveNodeFromInternalMaps(mutable_node);
     mutable_node->set_url(url);
     AddNodeToInternalMaps(mutable_node);
   }
 
   if (store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkNodeChanged(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeChanged(this, node);
 }
 
 void BookmarkModel::SetNodeMetaInfo(const BookmarkNode* node,
                                     const std::string& key,
                                     const std::string& value) {
   std::string old_value;
   if (node->GetMetaInfo(key, &old_value) && old_value == value)
     return;
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillChangeBookmarkMetaInfo(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillChangeBookmarkMetaInfo(this, node);
 
   if (AsMutable(node)->SetMetaInfo(key, value) && store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkMetaInfoChanged(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkMetaInfoChanged(this, node);
 }
 
 void BookmarkModel::SetNodeMetaInfoMap(
     const BookmarkNode* node,
     const BookmarkNode::MetaInfoMap& meta_info_map) {
   const BookmarkNode::MetaInfoMap* old_meta_info_map = node->GetMetaInfoMap();
   if ((!old_meta_info_map && meta_info_map.empty()) ||
       (old_meta_info_map && meta_info_map == *old_meta_info_map))
     return;
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillChangeBookmarkMetaInfo(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillChangeBookmarkMetaInfo(this, node);
 
   AsMutable(node)->SetMetaInfoMap(meta_info_map);
   if (store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkMetaInfoChanged(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkMetaInfoChanged(this, node);
 }
 
 void BookmarkModel::DeleteNodeMetaInfo(const BookmarkNode* node,
                                        const std::string& key) {
   const BookmarkNode::MetaInfoMap* meta_info_map = node->GetMetaInfoMap();
   if (!meta_info_map || meta_info_map->find(key) == meta_info_map->end())
     return;
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillChangeBookmarkMetaInfo(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillChangeBookmarkMetaInfo(this, node);
 
   if (AsMutable(node)->DeleteMetaInfo(key) && store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkMetaInfoChanged(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkMetaInfoChanged(this, node);
 }
 
 void BookmarkModel::AddNonClonedKey(const std::string& key) {
   non_cloned_keys_.insert(key);
 }
 
 void BookmarkModel::SetNodeSyncTransactionVersion(
     const BookmarkNode* node,
     int64_t sync_transaction_version) {
   DCHECK(client_->CanSyncNode(node));
@@ skipping 27 matching lines @@
       if (icon_url == node->icon_url())
         to_update.insert(node);
     }
   }
 
   for (const BookmarkNode* node : to_update) {
     // Rerequest the favicon.
     BookmarkNode* mutable_node = AsMutable(node);
     mutable_node->InvalidateFavicon();
     CancelPendingFaviconLoadRequests(mutable_node);
-    FOR_EACH_OBSERVER(BookmarkModelObserver,
-                      observers_,
-                      BookmarkNodeFaviconChanged(this, node));
+    for (BookmarkModelObserver& observer : observers_)
+      observer.BookmarkNodeFaviconChanged(this, node);
   }
 }
 
 void BookmarkModel::SetDateAdded(const BookmarkNode* node, Time date_added) {
   DCHECK(node && !is_permanent_node(node));
 
   if (node->date_added() == date_added)
     return;
 
   AsMutable(node)->set_date_added(date_added);
@@ skipping 135 matching lines @@
 }
 
 void BookmarkModel::SortChildren(const BookmarkNode* parent) {
   DCHECK(client_->CanBeEditedByUser(parent));
 
   if (!parent || !parent->is_folder() || is_root_node(parent) ||
       parent->child_count() <= 1) {
     return;
   }
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillReorderBookmarkNode(this, parent));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillReorderBookmarkNode(this, parent);
 
   UErrorCode error = U_ZERO_ERROR;
   std::unique_ptr<icu::Collator> collator(icu::Collator::createInstance(error));
   if (U_FAILURE(error))
     collator.reset(NULL);
   BookmarkNode* mutable_parent = AsMutable(parent);
   std::sort(mutable_parent->children().begin(),
             mutable_parent->children().end(),
             SortComparator(collator.get()));
 
   if (store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkNodeChildrenReordered(this, parent));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeChildrenReordered(this, parent);
 }
 
 void BookmarkModel::ReorderChildren(
     const BookmarkNode* parent,
     const std::vector<const BookmarkNode*>& ordered_nodes) {
   DCHECK(client_->CanBeEditedByUser(parent));
 
   // Ensure that all children in |parent| are in |ordered_nodes|.
   DCHECK_EQ(static_cast<size_t>(parent->child_count()), ordered_nodes.size());
   for (const BookmarkNode* node : ordered_nodes)
     DCHECK_EQ(parent, node->parent());
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillReorderBookmarkNode(this, parent));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillReorderBookmarkNode(this, parent);
 
   if (ordered_nodes.size() > 1) {
     std::map<const BookmarkNode*, int> order;
     for (size_t i = 0; i < ordered_nodes.size(); ++i)
       order[ordered_nodes[i]] = i;
 
     std::vector<std::unique_ptr<BookmarkNode>> new_children(
         ordered_nodes.size());
     BookmarkNode* mutable_parent = AsMutable(parent);
     for (auto& child : mutable_parent->children()) {
       size_t new_location = order[child.get()];
       new_children[new_location] = std::move(child);
     }
     mutable_parent->children().swap(new_children);
 
     if (store_.get())
       store_->ScheduleSave();
   }
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkNodeChildrenReordered(this, parent));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeChildrenReordered(this, parent);
 }
 
 void BookmarkModel::SetDateFolderModified(const BookmarkNode* parent,
                                           const Time time) {
   DCHECK(parent);
   AsMutable(parent)->set_date_folder_modified(time);
 
   if (store_.get())
     store_->ScheduleSave();
 }
@@ skipping 52 matching lines @@
   BookmarkNode* node_ptr = node.get();
   AddNode(AsMutable(parent), index, std::move(node));
 
   // We might be restoring a folder node that have already contained a set of
   // child nodes. We need to notify all of them.
   NotifyNodeAddedForAllDescendents(node_ptr);
 }
 
 void BookmarkModel::NotifyNodeAddedForAllDescendents(const BookmarkNode* node) {
   for (int i = 0; i < node->child_count(); ++i) {
-    FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                      BookmarkNodeAdded(this, node, i));
+    for (BookmarkModelObserver& observer : observers_)
+      observer.BookmarkNodeAdded(this, node, i);
     NotifyNodeAddedForAllDescendents(node->GetChild(i));
   }
 }
 
 bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
   BookmarkNode tmp_node(url);
   return (nodes_ordered_by_url_set_.find(&tmp_node) !=
           nodes_ordered_by_url_set_.end());
 }
 
@@ skipping 104 matching lines @@
   loaded_ = true;
 
   loaded_signal_.Signal();
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/467179
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile6(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("467179 BookmarkModel::DoneLoading6"));
 
   // Notify our direct observers.
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkModelLoaded(this, details->ids_reassigned()));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkModelLoaded(this, details->ids_reassigned());
 }
 
 void BookmarkModel::RemoveAndDeleteNode(BookmarkNode* node_ptr) {
   std::unique_ptr<BookmarkNode> node;
 
   const BookmarkNode* parent = node_ptr->parent();
   DCHECK(parent);
   int index = parent->GetIndexOf(node_ptr);
   DCHECK_NE(-1, index);
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    OnWillRemoveBookmarks(this, parent, index, node_ptr));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.OnWillRemoveBookmarks(this, parent, index, node_ptr);
 
   std::set<GURL> removed_urls;
   {
     base::AutoLock url_lock(url_lock_);
     node = RemoveNodeAndGetRemovedUrls(node_ptr, &removed_urls);
   }
 
   if (store_.get())
     store_->ScheduleSave();
 
-  FOR_EACH_OBSERVER(
-      BookmarkModelObserver,
-      observers_,
-      BookmarkNodeRemoved(this, parent, index, node.get(), removed_urls));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeRemoved(this, parent, index, node.get(), removed_urls);
 
   undo_delegate()->OnBookmarkNodeRemoved(this, parent, index, std::move(node));
 }
 
 void BookmarkModel::RemoveNodeFromInternalMaps(BookmarkNode* node) {
   index_->Remove(node);
   // NOTE: this is called in such a way that url_lock_ is already held. As
   // such, this doesn't explicitly grab the lock.
   url_lock_.AssertAcquired();
   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(node);
@@ skipping 41 matching lines @@
   parent->Add(std::move(node), index);
 
   if (store_.get())
     store_->ScheduleSave();
 
   {
     base::AutoLock url_lock(url_lock_);
     AddNodeToInternalMaps(node_ptr);
   }
 
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkNodeAdded(this, parent, index));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeAdded(this, parent, index);
 
   return node_ptr;
 }
 
 void BookmarkModel::AddNodeToInternalMaps(BookmarkNode* node) {
   url_lock_.AssertAcquired();
   if (node->is_url()) {
     index_->Add(node);
     nodes_ordered_by_url_set_.insert(node);
   }
@@ skipping 73 matching lines @@
               &BookmarkModel::OnFaviconDataAvailable,
               base::Unretained(this),
               node,
               icon_type),
           &cancelable_task_tracker_);
   if (taskId != base::CancelableTaskTracker::kBadTaskId)
     node->set_favicon_load_task_id(taskId);
 }
 
 void BookmarkModel::FaviconLoaded(const BookmarkNode* node) {
-  FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
-                    BookmarkNodeFaviconChanged(this, node));
+  for (BookmarkModelObserver& observer : observers_)
+    observer.BookmarkNodeFaviconChanged(this, node);
 }
 
 void BookmarkModel::CancelPendingFaviconLoadRequests(BookmarkNode* node) {
   if (node->favicon_load_task_id() != base::CancelableTaskTracker::kBadTaskId) {
     cancelable_task_tracker_.TryCancel(node->favicon_load_task_id());
     node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
   }
 }
 
 void BookmarkModel::PopulateNodesByURL(BookmarkNode* node) {
@@ skipping 25 matching lines @@
   undo_delegate_ = undo_delegate;
   if (undo_delegate_)
     undo_delegate_->SetUndoProvider(this);
 }
 
 BookmarkUndoDelegate* BookmarkModel::undo_delegate() const {
   return undo_delegate_ ? undo_delegate_ : empty_undo_delegate_.get();
 }
 
 }  // namespace bookmarks