Use bookmark creation date fallback for 6 weeks after installing M54

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 <string>
 #include <utility>
 
@@ skipping 24 matching lines @@
     return base::Time::UnixEpoch();
   return base::Time::FromInternalValue(date);
 }
 
 std::string FormatLastVisitDate(const base::Time& date) {
   return base::Int64ToString(date.ToInternalValue());
 }
 
 bool CompareBookmarksByLastVisitDate(const BookmarkNode* a,
                                      const BookmarkNode* b) {
-  return GetLastVisitDateForBookmark(a) > GetLastVisitDateForBookmark(b);
+  return GetLastVisitDateForBookmark(a, /*creation_date_fallback=*/true) >
+         GetLastVisitDateForBookmark(b, /*creation_date_fallback=*/true);
 }
 
 }  // namespace
 
 void UpdateBookmarkOnURLVisitedInMainFrame(BookmarkModel* bookmark_model,
                                            const GURL& url) {
   std::vector<const BookmarkNode*> bookmarks_for_url;
   bookmark_model->GetNodesByURL(url, &bookmarks_for_url);
   if (bookmarks_for_url.empty())
     return;
 
   // If there are bookmarks for |url|, set their last visit date to now.
   std::string now = FormatLastVisitDate(base::Time::Now());
   for (const BookmarkNode* node : bookmarks_for_url) {
     bookmark_model->SetNodeMetaInfo(node, kBookmarkLastVisitDateKey, now);
     // If the bookmark has been dismissed from NTP before, a new visit overrides
     // such a dismission.
     bookmark_model->DeleteNodeMetaInfo(node, kBookmarkDismissedFromNTP);
   }
 }
 
 base::Time GetLastVisitDateForBookmark(const BookmarkNode* node,
                                        bool creation_date_fallback) {
   if (!node)
     return base::Time::UnixEpoch();
 
   std::string last_visit_date_string;
   if (!node->GetMetaInfo(kBookmarkLastVisitDateKey, &last_visit_date_string) &&
-      creation_date_fallback)
+      creation_date_fallback) {
     return node->date_added();
-
+  }
   return ParseLastVisitDate(last_visit_date_string);
 }
 
 base::Time GetLastVisitDateForBookmarkIfNotDismissed(
     const BookmarkNode* node,
     bool creation_date_fallback) {
   if (IsDismissedFromNTPForBookmark(node))
     return base::Time::UnixEpoch();
 
   return GetLastVisitDateForBookmark(node, creation_date_fallback);
@@ skipping 47 matching lines @@
   for (const BookmarkModel::URLAndTitle& url_and_title : bookmark_urls) {
     // Get all bookmarks for the given URL.
     std::vector<const BookmarkNode*> bookmarks_for_url;
     bookmark_model->GetNodesByURL(url_and_title.url, &bookmarks_for_url);
 
     // Find the most recent node (minimal w.r.t.
     // CompareBookmarksByLastVisitDate).
     std::vector<const BookmarkNode*>::iterator most_recent =
         std::min_element(bookmarks_for_url.begin(), bookmarks_for_url.end(),
                          &CompareBookmarksByLastVisitDate);
-    if (most_recent == bookmarks_for_url.end())
-      continue;
     const BookmarkNode* node = *most_recent;
 
     // Find out if it has been _visited_ recently enough.
     if (GetLastVisitDateForBookmarkIfNotDismissed(
             node, /*creation_date_fallback=*/false) > min_visit_time) {
       recently_visited_count++;
       bookmarks.push_back({node, true});
     } else {
       bookmarks.push_back({node, false});
     }
   }
 
   if (recently_visited_count < min_count) {
     // Fill the list up to |min_count| but do not display more.
     max_count = min_count;
   } else {
-    // Remove the bookmarks that are not recently visited; we do no need them.
+    // Remove the bookmarks that are not recently visited; we do not need them.
     bookmarks.erase(
         std::remove_if(bookmarks.begin(), bookmarks.end(),
                        [](const RecentBookmark& bookmark) {
                          return !bookmark.visited_recently;
                        }),
         bookmarks.end());
   }
 
   // Sort the remaining entries by date.
   std::sort(bookmarks.begin(), bookmarks.end(),
@@ skipping 36 matching lines @@
   // Insert into |result|.
   std::vector<const BookmarkNode*> result;
   for (const BookmarkModel::URLAndTitle& bookmark : bookmarks) {
     result.push_back(
         bookmark_model->GetMostRecentlyAddedUserNodeForURL(bookmark.url));
   }
   return result;
 }
 
 }  // namespace ntp_snippets