Add a fallback to creation date for Recent bookmarks on NTP

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 18 matching lines @@
   if (!base::StringToInt64(date_string, &date))
     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);
+                                     const BookmarkNode* b,
+                                     bool use_creation_date) {
+  return GetLastVisitDateForBookmark(a, use_creation_date) >
+         GetLastVisitDateForBookmark(b, use_creation_date);
 }
 
 }  // 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) {
+base::Time GetLastVisitDateForBookmark(const BookmarkNode* node,
+                                       bool use_creation_date) {
   if (!node)
     return base::Time::UnixEpoch();
 
+  if (use_creation_date)
+    return node->date_added();
+
   std::string last_visit_date_string;
   node->GetMetaInfo(kBookmarkLastVisitDateKey, &last_visit_date_string);
   return ParseLastVisitDate(last_visit_date_string);
 }
 
-base::Time GetLastVisitDateForBookmarkIfNotDismissed(const BookmarkNode* node) {
+base::Time GetLastVisitDateForBookmarkIfNotDismissed(const BookmarkNode* node,
+                                                     bool use_creation_date) {
   if (IsDismissedFromNTPForBookmark(node))
     return base::Time::UnixEpoch();
 
-  return GetLastVisitDateForBookmark(node);
+  return GetLastVisitDateForBookmark(node, use_creation_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) {
@@ skipping 14 matching lines @@
 
   // Remove dismissed flag from all bookmarks
   for (const BookmarkModel::URLAndTitle& bookmark : bookmarks) {
     std::vector<const BookmarkNode*> nodes;
     bookmark_model->GetNodesByURL(bookmark.url, &nodes);
     for (const BookmarkNode* node : nodes)
       bookmark_model->DeleteNodeMetaInfo(node, kBookmarkDismissedFromNTP);
   }
 }
 
+bool IsLastVisitDataAvailable(BookmarkModel* bookmark_model) {
+  // Get all the bookmark URLs.
+  std::vector<BookmarkModel::URLAndTitle> bookmarks;
+  bookmark_model->GetBookmarks(&bookmarks);
+
+  std::string unused;
+  for (const BookmarkModel::URLAndTitle& bookmark : bookmarks) {
+    // Get all bookmarks for the given URL.
+    std::vector<const BookmarkNode*> bookmarks_for_url;
+    bookmark_model->GetNodesByURL(bookmark.url, &bookmarks_for_url);
+    for (const BookmarkNode* node : bookmarks_for_url) {
+      if (node->GetMetaInfo(kBookmarkLastVisitDateKey, &unused))
+        return true;
+    }
+  }
+
+  return false;
+}
+
 std::vector<const BookmarkNode*> GetRecentlyVisitedBookmarks(
     BookmarkModel* bookmark_model,
+    bool use_creation_date,
     int max_count,
     const base::Time& min_visit_time) {
   // Get all the bookmark URLs.
   std::vector<BookmarkModel::URLAndTitle> bookmarks;
   bookmark_model->GetBookmarks(&bookmarks);
 
   // Remove the URLs for that no bookmark has a recent visit (more recent than
   // |min_visit_time|). Recent visits to dismissed bookmarks are not considered.
   bookmarks.erase(
       std::remove_if(bookmarks.begin(), bookmarks.end(),
-                     [&bookmark_model, &min_visit_time](
+                     [&bookmark_model, &min_visit_time, use_creation_date](
                          const BookmarkModel::URLAndTitle& bookmark) {
                        // Get all bookmarks for the given URL.
                        std::vector<const BookmarkNode*> bookmarks_for_url;
                        bookmark_model->GetNodesByURL(bookmark.url,
                                                      &bookmarks_for_url);
 
                        // Keep if at least one (non-dismissed) bookmark has been
                        // recently visited.
                        for (const BookmarkNode* node : bookmarks_for_url) {
-                         if (GetLastVisitDateForBookmarkIfNotDismissed(node) >
-                             min_visit_time)
+                         if (GetLastVisitDateForBookmarkIfNotDismissed(
+                                 node, use_creation_date) > min_visit_time)
                            return false;
                        }
                        // Otherwise erase this URL.
                        return true;
                      }),
       bookmarks.end());
 
   // Sort the remaining bookmarks by date.
   std::sort(bookmarks.begin(), bookmarks.end(),
-            [&bookmark_model](const BookmarkModel::URLAndTitle& a,
-                              const BookmarkModel::URLAndTitle& b) {
+            [&bookmark_model, use_creation_date](
+                const BookmarkModel::URLAndTitle& a,
+                const BookmarkModel::URLAndTitle& b) {
               return CompareBookmarksByLastVisitDate(
                   bookmark_model->GetMostRecentlyAddedUserNodeForURL(a.url),
-                  bookmark_model->GetMostRecentlyAddedUserNodeForURL(b.url));
+                  bookmark_model->GetMostRecentlyAddedUserNodeForURL(b.url),
+                  use_creation_date);
             });
 
   // Insert the first |max_count| items from |bookmarks| into |result|.
   std::vector<const BookmarkNode*> result;
   for (const BookmarkModel::URLAndTitle& bookmark : bookmarks) {
     result.push_back(
         bookmark_model->GetMostRecentlyAddedUserNodeForURL(bookmark.url));
     if (result.size() >= static_cast<size_t>(max_count))
       break;
   }
@@ skipping 25 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