[Media Feeds] Add get feed items API

Add an API for getting the feed items for a feed
when we want to display them and also feed items
for continue watching.

BUG=1053599

Change-Id: Id40e56035adb5fea25176f4ee9ed983d54c2f1da
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2227885
Commit-Queue: Becca Hughes <beccahughes@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Tommy Steimel <steimel@chromium.org>
Cr-Commit-Position: refs/heads/master@{#776283}

chrome/browser/media/feeds/media_feeds_browsertest.cc

@@ -182,8 +182,9 @@ class MediaFeedsBrowserTest : public InProcessBrowserTest {
     base::RunLoop run_loop;
     std::vector<media_feeds::mojom::MediaFeedItemPtr> out;
 
-    GetMediaHistoryService()->GetItemsForMediaFeedForDebug(
-        feed_id,
+    GetMediaHistoryService()->GetMediaFeedItems(
+        media_history::MediaHistoryKeyedService::GetMediaFeedItemsRequest::
+            CreateItemsForDebug(feed_id),
         base::BindLambdaForTesting(
             [&](std::vector<media_feeds::mojom::MediaFeedItemPtr> items) {
               out = std::move(items);
@@ -366,6 +367,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetch) {
   // Check each feed item and all fields one-by-one.
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 1;
     expected_item->name =
         base::ASCIIToUTF16("Anatomy of a Web Media Experience");
     expected_item->type = mojom::MediaFeedItemType::kVideo;
@@ -406,6 +408,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetch) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 2;
     expected_item->name = base::ASCIIToUTF16(
         "Building Modern Web Media Experiences: Picture-in-Picture and AV1");
     expected_item->type = mojom::MediaFeedItemType::kVideo;
@@ -457,6 +460,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetch) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 3;
     expected_item->name = base::ASCIIToUTF16("Chrome Releases");
     expected_item->type = mojom::MediaFeedItemType::kTVSeries;
     ASSERT_TRUE(
@@ -527,6 +531,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetch) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 4;
     expected_item->name = base::ASCIIToUTF16("Chrome University");
     expected_item->type = mojom::MediaFeedItemType::kTVSeries;
     ASSERT_TRUE(
@@ -592,6 +597,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetch) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 5;
     expected_item->name = base::ASCIIToUTF16("JAM stack");
     expected_item->type = mojom::MediaFeedItemType::kTVSeries;
     ASSERT_TRUE(
@@ -624,6 +630,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetch) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 6;
     expected_item->name = base::ASCIIToUTF16("Ask Chrome");
     expected_item->type = mojom::MediaFeedItemType::kVideo;
     expected_item->author = mojom::Author::New();
@@ -664,6 +671,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetch) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 7;
     expected_item->name = base::ASCIIToUTF16("Big Buck Bunny");
     expected_item->type = mojom::MediaFeedItemType::kMovie;
     ASSERT_TRUE(
@@ -763,6 +771,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetchMinimal) {
   // the correct fields are set. Don't assume or require any specific ordering.
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 1;
     expected_item->name =
         base::ASCIIToUTF16("Anatomy of a Web Media Experience");
     expected_item->type = mojom::MediaFeedItemType::kVideo;
@@ -796,6 +805,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetchMinimal) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 2;
     expected_item->name = base::ASCIIToUTF16("Chrome Releases");
     expected_item->type = mojom::MediaFeedItemType::kTVSeries;
     ASSERT_TRUE(
@@ -837,6 +847,7 @@ IN_PROC_BROWSER_TEST_F(MediaFeedsBrowserTest, DiscoverAndFetchMinimal) {
 
   {
     mojom::MediaFeedItemPtr expected_item = mojom::MediaFeedItem::New();
+    expected_item->id = 3;
     expected_item->name = base::ASCIIToUTF16("Big Buck Bunny");
     expected_item->type = mojom::MediaFeedItemType::kMovie;
     ASSERT_TRUE(

chrome/browser/media/feeds/media_feeds_service_unittest.cc

@@ -231,8 +231,9 @@ class MediaFeedsServiceTest : public ChromeRenderViewHostTestHarness {
     base::RunLoop run_loop;
     std::vector<media_feeds::mojom::MediaFeedItemPtr> out;
 
-    GetMediaHistoryService()->GetItemsForMediaFeedForDebug(
-        feed_id,
+    GetMediaHistoryService()->GetMediaFeedItems(
+        media_history::MediaHistoryKeyedService::GetMediaFeedItemsRequest::
+            CreateItemsForDebug(feed_id),
         base::BindLambdaForTesting(
             [&](std::vector<media_feeds::mojom::MediaFeedItemPtr> rows) {
               out = std::move(rows);
@@ -298,8 +299,10 @@ class MediaFeedsServiceTest : public ChromeRenderViewHostTestHarness {
     return media_history::MediaHistoryKeyedService::Get(profile());
   }
 
-  static media_feeds::mojom::MediaFeedItemPtr GetSingleExpectedItem() {
+  static media_feeds::mojom::MediaFeedItemPtr GetSingleExpectedItem(
+      int id_start = 0) {
     auto item = media_feeds::mojom::MediaFeedItem::New();
+    item->id = ++id_start;
     item->name = base::ASCIIToUTF16("The Movie");
     item->type = media_feeds::mojom::MediaFeedItemType::kMovie;
     item->date_published = base::Time::FromDeltaSinceWindowsEpoch(
@@ -315,12 +318,16 @@ class MediaFeedsServiceTest : public ChromeRenderViewHostTestHarness {
     return item;
   }
 
-  static std::vector<media_feeds::mojom::MediaFeedItemPtr> GetExpectedItems() {
+  static std::vector<media_feeds::mojom::MediaFeedItemPtr> GetExpectedItems(
+      int id_start = 0) {
     std::vector<media_feeds::mojom::MediaFeedItemPtr> items;
-    items.push_back(GetSingleExpectedItem());
+
+    items.push_back(GetSingleExpectedItem(id_start));
+    id_start++;
 
     {
       auto item = media_feeds::mojom::MediaFeedItem::New();
+      item->id = ++id_start;
       item->type = media_feeds::mojom::MediaFeedItemType::kTVSeries;
       item->name = base::ASCIIToUTF16("The TV Series");
       item->action_status =
@@ -334,6 +341,7 @@ class MediaFeedsServiceTest : public ChromeRenderViewHostTestHarness {
 
     {
       auto item = media_feeds::mojom::MediaFeedItem::New();
+      item->id = ++id_start;
       item->type = media_feeds::mojom::MediaFeedItemType::kTVSeries;
       item->name = base::ASCIIToUTF16("The Live TV Series");
       item->action_status =

chrome/browser/media/feeds/media_feeds_store.mojom

@@ -362,6 +362,9 @@ enum IsFamilyFriendly {
 // represents a single recommendation such as a video or TV show.
 // https://wicg.github.io/media-feeds/index.html#media-feed-item
 struct MediaFeedItem {
+  // The ID of the feed item in storage.
+  int64 id;
+
   // The type of this feed item such as a video or TV show.
   MediaFeedItemType type;
 

chrome/browser/media/history/media_history_feed_items_table.cc

@@ -207,6 +207,22 @@ sql::InitStatus MediaHistoryFeedItemsTable::CreateTableIfNonExistent() {
         "mediaFeedItem (safe_search_result, feed_id)");
   }
 
+  if (success) {
+    success = DB()->Execute(
+        "CREATE INDEX IF NOT EXISTS "
+        "mediaFeedItem_continue_watching_index ON "
+        "mediaFeedItem (action_status, play_next_candidate, "
+        "safe_search_result)");
+  }
+
+  if (success) {
+    success = DB()->Execute(
+        "CREATE INDEX IF NOT EXISTS "
+        "mediaFeedItem_for_feed_index ON "
+        "mediaFeedItem (feed_id, action_status, play_next_candidate, "
+        "safe_search_result)");
+  }
+
   if (!success) {
     ResetDB();
     LOG(ERROR) << "Failed to create media history feed items table.";
@@ -408,20 +424,97 @@ bool MediaHistoryFeedItemsTable::DeleteItems(const int64_t feed_id) {
 }
 
 std::vector<media_feeds::mojom::MediaFeedItemPtr>
-MediaHistoryFeedItemsTable::GetItemsForFeed(const int64_t feed_id) {
+MediaHistoryFeedItemsTable::GetItems(
+    const MediaHistoryKeyedService::GetMediaFeedItemsRequest& request) {
   std::vector<media_feeds::mojom::MediaFeedItemPtr> items;
   if (!CanAccessDatabase())
     return items;
 
-  sql::Statement statement(DB()->GetUniqueStatement(
+  std::vector<std::string> sql;
+  sql.push_back(
       "SELECT type, name, date_published_s, is_family_friendly, "
       "action_status, genre, duration_s, is_live, live_start_time_s, "
       "live_end_time_s, shown_count, clicked, author, action, "
       "interaction_counters, content_rating, identifiers, tv_episode, "
-      "play_next_candidate, images, safe_search_result FROM "
-      "mediaFeedItem WHERE feed_id = ?"));
+      "play_next_candidate, images, safe_search_result, id FROM mediaFeedItem");
 
-  statement.BindInt64(0, feed_id);
+  sql::Statement statement;
+
+  if (request.type ==
+      MediaHistoryKeyedService::GetMediaFeedItemsRequest::Type::kDebugAll) {
+    // Debug request should just return all feed items for a single feed.
+    sql.push_back("WHERE feed_id = ?");
+
+    statement.Assign(DB()->GetCachedStatement(
+        SQL_FROM_HERE, base::JoinString(sql, " ").c_str()));
+
+    statement.BindInt64(0, *request.feed_id);
+  } else if (request.type ==
+             MediaHistoryKeyedService::GetMediaFeedItemsRequest::Type::
+                 kItemsForFeed) {
+    // kItemsForFeed should return items for a feed. Ordered by clicked and
+    // shown count so items that have been clicked and shown a lot will be at
+    // the end. Items must not be continue watching items.
+    sql.push_back(
+        "WHERE feed_id = ? AND action_status != ? AND play_next_candidate IS "
+        "NULL");
+
+    if (request.fetched_items_should_be_safe)
+      sql.push_back("AND safe_search_result = ?");
+
+    sql.push_back("ORDER BY clicked ASC, shown_count ASC LIMIT ?");
+
+    if (request.fetched_items_should_be_safe) {
+      statement.Assign(DB()->GetCachedStatement(
+          SQL_FROM_HERE, base::JoinString(sql, " ").c_str()));
+
+      statement.BindInt64(
+          2, static_cast<int>(media_feeds::mojom::SafeSearchResult::kSafe));
+      statement.BindInt64(3, *request.limit);
+    } else {
+      statement.Assign(DB()->GetCachedStatement(
+          SQL_FROM_HERE, base::JoinString(sql, " ").c_str()));
+
+      statement.BindInt64(2, *request.limit);
+    }
+
+    // Bind common parameters.
+    statement.BindInt64(0, *request.feed_id);
+    statement.BindInt64(
+        1, static_cast<int>(
+               media_feeds::mojom::MediaFeedItemActionStatus::kActive));
+  } else if (request.type ==
+             MediaHistoryKeyedService::GetMediaFeedItemsRequest::Type::
+                 kContinueWatching) {
+    // kContinueWatching should return items across all feeds that either have
+    // an active action status or a play next candidate. Ordered by most recent
+    // first.
+    sql.push_back("WHERE action_status = ? OR play_next_candidate IS NOT NULL");
+
+    if (request.fetched_items_should_be_safe)
+      sql.push_back("AND safe_search_result = ?");
+
+    sql.push_back("ORDER BY id DESC LIMIT ?");
+
+    if (request.fetched_items_should_be_safe) {
+      statement.Assign(DB()->GetCachedStatement(
+          SQL_FROM_HERE, base::JoinString(sql, " ").c_str()));
+
+      statement.BindInt64(
+          1, static_cast<int>(media_feeds::mojom::SafeSearchResult::kSafe));
+      statement.BindInt64(2, *request.limit);
+    } else {
+      statement.Assign(DB()->GetCachedStatement(
+          SQL_FROM_HERE, base::JoinString(sql, " ").c_str()));
+
+      statement.BindInt64(1, *request.limit);
+    }
+
+    // Bind common parameters.
+    statement.BindInt64(
+        0, static_cast<int>(
+               media_feeds::mojom::MediaFeedItemActionStatus::kActive));
+  }
 
   DCHECK(statement.is_valid());
 
@@ -651,6 +744,7 @@ MediaHistoryFeedItemsTable::GetItemsForFeed(const int64_t feed_id) {
 
     item->shown_count = statement.ColumnInt64(10);
     item->clicked = statement.ColumnBool(11);
+    item->id = statement.ColumnInt64(21);
 
     items.push_back(std::move(item));
   }

chrome/browser/media/history/media_history_feed_items_table.h

@@ -67,9 +67,9 @@ class MediaHistoryFeedItemsTable : public MediaHistoryTableBase {
   // Deletes all items from a feed.
   bool DeleteItems(const int64_t feed_id);
 
-  // Gets all the items associated with |feed_id|.
-  std::vector<media_feeds::mojom::MediaFeedItemPtr> GetItemsForFeed(
-      const int64_t feed_id);
+  // Returns the feed rows in the database.
+  std::vector<media_feeds::mojom::MediaFeedItemPtr> GetItems(
+      const MediaHistoryKeyedService::GetMediaFeedItemsRequest& request);
 
   // Returns all the Media Feed Items that have an unknown safe search result.
   MediaHistoryKeyedService::PendingSafeSearchCheckList

chrome/browser/media/history/media_history_keyed_service.cc

@@ -250,14 +250,53 @@ void MediaHistoryKeyedService::SavePlaybackSession(
   }
 }
 
-void MediaHistoryKeyedService::GetItemsForMediaFeedForDebug(
-    const int64_t feed_id,
+MediaHistoryKeyedService::GetMediaFeedItemsRequest
+MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForDebug(
+    int64_t feed_id) {
+  GetMediaFeedItemsRequest request;
+  request.type = Type::kDebugAll;
+  request.feed_id = feed_id;
+  return request;
+}
+
+MediaHistoryKeyedService::GetMediaFeedItemsRequest
+MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForFeed(
+    int64_t feed_id,
+    unsigned limit,
+    bool fetched_items_should_be_safe) {
+  GetMediaFeedItemsRequest request;
+  request.type = Type::kItemsForFeed;
+  request.limit = limit;
+  request.feed_id = feed_id;
+  request.fetched_items_should_be_safe = fetched_items_should_be_safe;
+  return request;
+}
+
+MediaHistoryKeyedService::GetMediaFeedItemsRequest MediaHistoryKeyedService::
+    GetMediaFeedItemsRequest::CreateItemsForContinueWatching(
+        unsigned limit,
+        bool fetched_items_should_be_safe) {
+  GetMediaFeedItemsRequest request;
+  request.type = Type::kContinueWatching;
+  request.limit = limit;
+  request.fetched_items_should_be_safe = fetched_items_should_be_safe;
+  return request;
+}
+
+MediaHistoryKeyedService::GetMediaFeedItemsRequest::GetMediaFeedItemsRequest() =
+    default;
+
+MediaHistoryKeyedService::GetMediaFeedItemsRequest::GetMediaFeedItemsRequest(
+    const GetMediaFeedItemsRequest& t) = default;
+
+void MediaHistoryKeyedService::GetMediaFeedItems(
+    const GetMediaFeedItemsRequest& request,
     base::OnceCallback<void(std::vector<media_feeds::mojom::MediaFeedItemPtr>)>
         callback) {
   base::PostTaskAndReplyWithResult(
       store_->GetForRead()->db_task_runner_.get(), FROM_HERE,
-      base::BindOnce(&MediaHistoryStore::GetItemsForMediaFeedForDebug,
-                     store_->GetForRead(), feed_id),
+      base::BindOnce(&MediaHistoryStore::GetMediaFeedItems,
+                     store_->GetForRead(), request),
       std::move(callback));
 }
 

chrome/browser/media/history/media_history_keyed_service.h

@@ -88,9 +88,52 @@ class MediaHistoryKeyedService : public KeyedService,
       const base::Optional<media_session::MediaPosition>& position,
       const std::vector<media_session::MediaImage>& artwork);
 
-  // Gets the media items in |feed_id|.
-  void GetItemsForMediaFeedForDebug(
-      const int64_t feed_id,
+  // Returns Media Feeds items.
+  struct GetMediaFeedItemsRequest {
+    enum class Type {
+      // Return all the feed items for a feed for debugging.
+      kDebugAll,
+
+      // Returns items across all feeds that either have an active action status
+      // or a play next candidate. Ordered by most recent first.
+      kContinueWatching,
+
+      // Returns all the items for a single feed. Ordered by clicked and shown
+      // count so items that have been clicked and shown a lot will be at the
+      // end. Items must not be continue watching items.
+      kItemsForFeed
+    };
+
+    static GetMediaFeedItemsRequest CreateItemsForDebug(int64_t feed_id);
+
+    static GetMediaFeedItemsRequest CreateItemsForFeed(
+        int64_t feed_id,
+        unsigned limit,
+        bool fetched_items_should_be_safe);
+
+    static GetMediaFeedItemsRequest CreateItemsForContinueWatching(
+        unsigned limit,
+        bool fetched_items_should_be_safe);
+
+    GetMediaFeedItemsRequest();
+    GetMediaFeedItemsRequest(const GetMediaFeedItemsRequest& t);
+
+    Type type = Type::kDebugAll;
+
+    // The ID of the feed to retrieve items for. Only valid for |kDebugAll| and
+    // |kItemsForFeed|.
+    base::Optional<int64_t> feed_id;
+
+    // The maximum number of feeds to return. Only valid for |kContinueWatching|
+    // and |kItemsForFeed|.
+    base::Optional<unsigned> limit;
+
+    // True if the item should have passed Safe Search checks. Only valid for
+    // |kContinueWatching| and |kItemsForFeed|.
+    bool fetched_items_should_be_safe = false;
+  };
+  void GetMediaFeedItems(
+      const GetMediaFeedItemsRequest& request,
       base::OnceCallback<
           void(std::vector<media_feeds::mojom::MediaFeedItemPtr>)> callback);
 

chrome/browser/media/history/media_history_store.cc

@@ -474,6 +474,16 @@ MediaHistoryStore::GetMediaHistoryPlaybackRowsForDebug() {
   return playback_table_->GetPlaybackRows();
 }
 
+std::vector<media_feeds::mojom::MediaFeedItemPtr>
+MediaHistoryStore::GetMediaFeedItems(
+    const MediaHistoryKeyedService::GetMediaFeedItemsRequest& request) {
+  DCHECK(db_task_runner_->RunsTasksInCurrentSequence());
+  if (!CanAccessDatabase() || !feed_items_table_)
+    return std::vector<media_feeds::mojom::MediaFeedItemPtr>();
+
+  return feed_items_table_->GetItems(request);
+}
+
 std::vector<media_feeds::mojom::MediaFeedPtr> MediaHistoryStore::GetMediaFeeds(
     const MediaHistoryKeyedService::GetMediaFeedsRequest& request) {
   DCHECK(db_task_runner_->RunsTasksInCurrentSequence());
@@ -829,16 +839,6 @@ void MediaHistoryStore::StoreMediaFeedFetchResultInternal(
   DB()->CommitTransaction();
 }
 
-std::vector<media_feeds::mojom::MediaFeedItemPtr>
-MediaHistoryStore::GetItemsForMediaFeedForDebug(const int64_t feed_id) {
-  DCHECK(db_task_runner_->RunsTasksInCurrentSequence());
-
-  if (!CanAccessDatabase() || !feed_items_table_)
-    return std::vector<media_feeds::mojom::MediaFeedItemPtr>();
-
-  return feed_items_table_->GetItemsForFeed(feed_id);
-}
-
 MediaHistoryKeyedService::PendingSafeSearchCheckList
 MediaHistoryStore::GetPendingSafeSearchCheckMediaFeedItems() {
   DCHECK(db_task_runner_->RunsTasksInCurrentSequence());

chrome/browser/media/history/media_history_store.h

@@ -131,6 +131,9 @@ class MediaHistoryStore : public base::RefCountedThreadSafe<MediaHistoryStore> {
   std::vector<mojom::MediaHistoryPlaybackRowPtr>
   GetMediaHistoryPlaybackRowsForDebug();
 
+  std::vector<media_feeds::mojom::MediaFeedItemPtr> GetMediaFeedItems(
+      const MediaHistoryKeyedService::GetMediaFeedItemsRequest& request);
+
   std::vector<media_feeds::mojom::MediaFeedPtr> GetMediaFeeds(
       const MediaHistoryKeyedService::GetMediaFeedsRequest& request);
 
@@ -154,9 +157,6 @@ class MediaHistoryStore : public base::RefCountedThreadSafe<MediaHistoryStore> {
   void StoreMediaFeedFetchResult(
       MediaHistoryKeyedService::MediaFeedFetchResult result);
 
-  std::vector<media_feeds::mojom::MediaFeedItemPtr>
-  GetItemsForMediaFeedForDebug(const int64_t feed_id);
-
   MediaHistoryKeyedService::PendingSafeSearchCheckList
   GetPendingSafeSearchCheckMediaFeedItems();
 

chrome/browser/ui/webui/media/media_feeds_ui.cc

@@ -64,8 +64,10 @@ void MediaFeedsUI::GetMediaFeeds(GetMediaFeedsCallback callback) {
 
 void MediaFeedsUI::GetItemsForMediaFeed(int64_t feed_id,
                                         GetItemsForMediaFeedCallback callback) {
-  GetMediaHistoryService()->GetItemsForMediaFeedForDebug(feed_id,
-                                                         std::move(callback));
+  GetMediaHistoryService()->GetMediaFeedItems(
+      media_history::MediaHistoryKeyedService::GetMediaFeedItemsRequest::
+          CreateItemsForDebug(feed_id),
+      std::move(callback));
 }
 
 void MediaFeedsUI::FetchMediaFeed(int64_t feed_id,