[Bookmark suggestions] Clean-up in the api: switch const* to const&

components/ntp_snippets/bookmarks/bookmark_last_visit_utils.cc

 // Copyright 2016 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/ntp_snippets/bookmarks/bookmark_last_visit_utils.h"
 
 #include <algorithm>
 #include <numeric>
 #include <set>
 #include <string>
@@ skipping 57 matching lines @@
 }
 
 std::vector<const BookmarkNode*>::const_iterator FindMostRecentBookmark(
     const std::vector<const BookmarkNode*>& bookmarks,
     bool consider_visits_from_desktop) {
   auto most_recent = bookmarks.end();
   base::Time most_recent_last_visited = base::Time::UnixEpoch();
 
   for (auto iter = bookmarks.begin(); iter != bookmarks.end(); ++iter) {
     base::Time last_visited;
-    if (GetLastVisitDateForNTPBookmark(*iter, consider_visits_from_desktop,
+    if (GetLastVisitDateForNTPBookmark(**iter, consider_visits_from_desktop,
                                        &last_visited) &&
         most_recent_last_visited <= last_visited) {
       most_recent = iter;
       most_recent_last_visited = last_visited;
     }
   }
 
   return most_recent;
 }
 
@@ skipping 20 matching lines @@
     bookmark_model->SetNodeMetaInfo(
         node, is_mobile_platform ? kBookmarkLastVisitDateOnMobileKey
                                  : kBookmarkLastVisitDateOnDesktopKey,
         now);
     // If the bookmark has been dismissed from NTP before, a new visit overrides
     // such a dismissal.
     bookmark_model->DeleteNodeMetaInfo(node, kBookmarkDismissedFromNTP);
   }
 }
 
-bool GetLastVisitDateForNTPBookmark(const BookmarkNode* node,
+bool GetLastVisitDateForNTPBookmark(const BookmarkNode& node,
                                     bool consider_visits_from_desktop,
                                     base::Time* out) {
-  if (!node || IsDismissedFromNTPForBookmark(node)) {
+  if (IsDismissedFromNTPForBookmark(node)) {
     return false;
   }
 
   bool got_mobile_date =
-      ExtractLastVisitDate(*node, kBookmarkLastVisitDateOnMobileKey, out);
+      ExtractLastVisitDate(node, kBookmarkLastVisitDateOnMobileKey, out);
 
   if (consider_visits_from_desktop) {
     // Consider the later visit from these two platform groups.
     base::Time last_visit_desktop;
-    if (ExtractLastVisitDate(*node, kBookmarkLastVisitDateOnDesktopKey,
+    if (ExtractLastVisitDate(node, kBookmarkLastVisitDateOnDesktopKey,
                              &last_visit_desktop)) {
       if (!got_mobile_date) {
         *out = last_visit_desktop;
       } else {
         *out = std::max(*out, last_visit_desktop);
       }
       return true;
     }
   }
 
   return got_mobile_date;
 }
 
 void MarkBookmarksDismissed(BookmarkModel* bookmark_model, const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   bookmark_model->GetNodesByURL(url, &nodes);
   for (const BookmarkNode* node : nodes) {
     bookmark_model->SetNodeMetaInfo(node, kBookmarkDismissedFromNTP, "1");
   }
 }
 
-bool IsDismissedFromNTPForBookmark(const BookmarkNode* node) {
-  if (!node) {
-    return false;
-  }
-
+bool IsDismissedFromNTPForBookmark(const BookmarkNode& node) {
   std::string dismissed_from_ntp;
   bool result =
-      node->GetMetaInfo(kBookmarkDismissedFromNTP, &dismissed_from_ntp);
+      node.GetMetaInfo(kBookmarkDismissedFromNTP, &dismissed_from_ntp);
   DCHECK(!result || dismissed_from_ntp == "1");
   return result;
 }
 
 void MarkAllBookmarksUndismissed(BookmarkModel* bookmark_model) {
   // Get all the bookmark URLs.
   std::vector<BookmarkModel::URLAndTitle> bookmarks;
   bookmark_model->GetBookmarks(&bookmarks);
 
   // Remove dismissed flag from all bookmarks
@@ skipping 32 matching lines @@
     // Find the most recently visited node for the given URL.
     auto most_recent =
         FindMostRecentBookmark(bookmarks_for_url, consider_visits_from_desktop);
     if (most_recent == bookmarks_for_url.end()) {
       continue;
     }
 
     // Extract the last visit of the node to use later for sorting.
     base::Time last_visit_time;
     if (!GetLastVisitDateForNTPBookmark(
-            *most_recent, consider_visits_from_desktop, &last_visit_time) ||
+            **most_recent, consider_visits_from_desktop, &last_visit_time) ||
         last_visit_time <= min_visit_time) {
       continue;
     }
 
     bookmarks.push_back({*most_recent, last_visit_time});
   }
 
   // Sort the entries by date, getting the |max_count| most recent bookmarks
   // to the front.
   size_t count_to_sort =
@@ skipping 24 matching lines @@
   // Remove the bookmark URLs which have at least one non-dismissed bookmark.
   bookmarks.erase(
       std::remove_if(
           bookmarks.begin(), bookmarks.end(),
           [&bookmark_model](const BookmarkModel::URLAndTitle& bookmark) {
             std::vector<const BookmarkNode*> bookmarks_for_url;
             bookmark_model->GetNodesByURL(bookmark.url, &bookmarks_for_url);
             DCHECK(!bookmarks_for_url.empty());
 
             for (const BookmarkNode* node : bookmarks_for_url) {
-              if (!IsDismissedFromNTPForBookmark(node)) {
+              if (!IsDismissedFromNTPForBookmark(*node)) {
                 return true;
               }
             }
             return false;
           }),
       bookmarks.end());
 
   // Insert into |result|.
   std::vector<const BookmarkNode*> result;
   for (const BookmarkModel::URLAndTitle& bookmark : bookmarks) {
@@ skipping 16 matching lines @@
     for (const BookmarkNode* bookmark : bookmarks_for_url) {
       bookmark_model->DeleteNodeMetaInfo(bookmark,
                                          kBookmarkLastVisitDateOnMobileKey);
       bookmark_model->DeleteNodeMetaInfo(bookmark,
                                          kBookmarkLastVisitDateOnDesktopKey);
     }
   }
 }
 
 }  // namespace ntp_snippets