[New CL] Add bookmark provider for content suggestions

components/ntp_snippets/bookmarks/bookmark_suggestions_provider.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_suggestions_provider.h"
+
+#include <utility>
+#include <vector>
+
+#include "base/strings/utf_string_conversions.h"
+#include "components/bookmarks/browser/bookmark_model.h"
+#include "components/ntp_snippets/bookmarks/bookmark_last_visit_utils.h"
+#include "components/ntp_snippets/category_factory.h"
+#include "components/ntp_snippets/content_suggestion.h"
+
+using bookmarks::BookmarkModel;
+using bookmarks::BookmarkNode;
+
+namespace {
+const int kMaxBookmarks = 10;
+const int kMaxBookmarkAgeInDays = 42;
+
+base::Time GetThresholdTime() {
+  return base::Time::Now() - base::TimeDelta::FromDays(kMaxBookmarkAgeInDays);
+}
+
+}  // namespace
+
+namespace ntp_snippets {
+
+BookmarkSuggestionsProvider::BookmarkSuggestionsProvider(
+    ContentSuggestionsProvider::Observer* observer,
+    CategoryFactory* category_factory,
+    bookmarks::BookmarkModel* bookmark_model)
+    : ContentSuggestionsProvider(observer, category_factory),
+      category_status_(CategoryStatus::AVAILABLE_LOADING),
+      provided_category_(
+          category_factory->FromKnownCategory(KnownCategories::BOOKMARKS)),
+      bookmark_model_(bookmark_model),
+      fetch_requested_(false),
+      end_of_list_last_visit_date_(GetThresholdTime()) {
+  bookmark_model_->AddObserver(this);
+  FetchBookmarks();
+}
+
+BookmarkSuggestionsProvider::~BookmarkSuggestionsProvider() {
+  bookmark_model_->RemoveObserver(this);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Private methods
+
+std::vector<Category> BookmarkSuggestionsProvider::GetProvidedCategories() {
+  return std::vector<Category>({provided_category_});
+}
+
+CategoryStatus BookmarkSuggestionsProvider::GetCategoryStatus(
+    Category category) {
+  return category_status_;
+}
+
+void BookmarkSuggestionsProvider::DismissSuggestion(
+    const std::string& suggestion_id) {
+  // TODO(jkrcal): Implement blacklisting bookmarks until they are next visited.
+  // Then also implement ClearDismissedSuggestionsForDebugging.
+}
+
+void BookmarkSuggestionsProvider::FetchSuggestionImage(
+    const std::string& suggestion_id,
+    const ImageFetchedCallback& callback) {
+  callback.Run(suggestion_id, gfx::Image());

[Marc Treib, 2016/08/04 13:57:14]

Running the callback synchronously might be surprising to the caller - maybe we
should do base::ThreadTaskRunnerHandle::Get()->PostTask(...) ?

[Philipp Keck, 2016/08/04 14:43:42]

So far, it has always worked fine. The ContentSuggestionsService also does that
when the provider doesn't exist. Put it on my list to think about it.

btw, NTPSnippetsStatusService also calls the OnDisabledReasonChanged when you
initialize it (I think).

[Marc Treib, 2016/08/04 14:46:26]

Acknowledged.

[Bernhard Bauer, 2016/08/04 18:10:55]

+1 for asynchronously running the callback. Reentrancy issues are very nasty.

[Philipp Keck, 2016/08/05 08:00:21]

Ok. CL coming up.

+}
+
+void BookmarkSuggestionsProvider::ClearCachedSuggestionsForDebugging() {
+  // Ignored.
+}
+
+void BookmarkSuggestionsProvider::ClearDismissedSuggestionsForDebugging() {
+  // TODO(jkrcal): Implement when discarded suggestions are supported.
+}
+
+void BookmarkSuggestionsProvider::BookmarkModelLoaded(
+    bookmarks::BookmarkModel* model,
+    bool ids_reassigned) {
+  DCHECK_EQ(bookmark_model_, model);
+  if (fetch_requested_) {
+    fetch_requested_ = false;
+    FetchBookmarksInternal();
+  }
+}
+
+void BookmarkSuggestionsProvider::OnWillChangeBookmarkMetaInfo(
+    BookmarkModel* model,
+    const BookmarkNode* node) {
+  // Store the last visit date of the node that is about to change.
+  node_to_change_last_visit_date_ = GetLastVisitDateForBookmark(node);
+}
+
+void BookmarkSuggestionsProvider::BookmarkMetaInfoChanged(
+    BookmarkModel* model,
+    const BookmarkNode* node) {
+  base::Time time = GetLastVisitDateForBookmark(node);
+  if (time == node_to_change_last_visit_date_ ||
+      time < end_of_list_last_visit_date_)
+    return;
+
+  // Last visit date of a node has changed (and is relevant for the list), we
+  // should update the suggestions.
+  FetchBookmarks();

[Marc Treib, 2016/08/04 13:57:14]

We probably can't get here before the bookmark model is loaded? Then you could
call FetchBookmarksInternal directly.

[Philipp Keck, 2016/08/04 14:43:42]

I don't know if the BookmarkModel guarantees that. The respective methods
https://codesearch.chromium.org/chromium/src/components/bookmarks/browser/boo...
don't really guard against |loaded_| being false.

[Marc Treib, 2016/08/04 14:46:26]

Alright. Carry on then I guess...

[Philipp Keck, 2016/08/05 08:00:21]

Acknowledged.

+}
+
+void BookmarkSuggestionsProvider::FetchBookmarksInternal() {
+  DCHECK(bookmark_model_->loaded());
+
+  NotifyStatusChanged(CategoryStatus::AVAILABLE);
+
+  std::vector<const BookmarkNode*> bookmarks = GetRecentlyVisitedBookmarks(
+      bookmark_model_, kMaxBookmarks, GetThresholdTime());
+
+  std::vector<ContentSuggestion> suggestions;
+  for (const BookmarkNode* bookmark : bookmarks) {
+    ContentSuggestion suggestion(
+        MakeUniqueID(provided_category_, bookmark->url().spec()),
+        bookmark->url());
+
+    suggestion.set_title(bookmark->GetTitle());
+    suggestion.set_snippet_text(base::string16());
+    suggestion.set_publish_date(GetLastVisitDateForBookmark(bookmark));
+    suggestion.set_publisher_name(base::UTF8ToUTF16(bookmark->url().host()));
+    suggestions.emplace_back(std::move(suggestion));
+  }
+
+  if (suggestions.empty())
+    end_of_list_last_visit_date_ = GetThresholdTime();
+  else
+    end_of_list_last_visit_date_ = suggestions.back().publish_date();
+
+  observer()->OnNewSuggestions(this, provided_category_,
+                               std::move(suggestions));
+}
+
+void BookmarkSuggestionsProvider::FetchBookmarks() {
+  if (bookmark_model_->loaded())
+    FetchBookmarksInternal();
+  else
+    fetch_requested_ = true;
+}
+
+void BookmarkSuggestionsProvider::NotifyStatusChanged(
+    CategoryStatus new_status) {
+  if (category_status_ == new_status)
+    return;
+  category_status_ = new_status;
+  observer()->OnCategoryStatusChanged(this, provided_category_, new_status);
+}
+
+}  // namespace ntp_snippets