[Media Feeds] Filter by content type

We have different areas for different content
when it is displayed. This updates the mojo
API to filter the content type of the feed
content based on the current tab.

BUG=1053599

Change-Id: I658e85c00fe43e10be94d9585a397b2a0771ee44
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2308997
Commit-Queue: Becca Hughes <beccahughes@chromium.org>
Reviewed-by: Tommy Steimel <steimel@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#790911}

chrome/browser/media/history/media_history_feed_items_table.cc

@@ -146,6 +146,14 @@ void FillLiveDetails(const media_feeds::mojom::LiveDetailsPtr& live_details,
         live_details->end_time->ToDeltaSinceWindowsEpoch().InSeconds());
 }
 
+void AssignStatement(sql::Statement* statement,
+                     sql::Database* db,
+                     const sql::StatementID& id,
+                     const std::vector<std::string>& sql) {
+  statement->Assign(
+      db->GetCachedStatement(id, base::JoinString(sql, " ").c_str()));
+}
+
 }  // namespace
 
 const char MediaHistoryFeedItemsTable::kTableName[] = "mediaFeedItem";
@@ -215,6 +223,14 @@ sql::InitStatus MediaHistoryFeedItemsTable::CreateTableIfNonExistent() {
         "safe_search_result)");
   }
 
+  if (success) {
+    success = DB()->Execute(
+        "CREATE INDEX IF NOT EXISTS "
+        "mediaFeedItem_continue_watching_with_type_index ON "
+        "mediaFeedItem (action_status, play_next_candidate, type, "
+        "safe_search_result)");
+  }
+
   if (success) {
     success = DB()->Execute(
         "CREATE INDEX IF NOT EXISTS "
@@ -462,58 +478,91 @@ MediaHistoryFeedItemsTable::GetItems(
     if (request.fetched_items_should_be_safe)
       sql.push_back("AND safe_search_result = ?");
 
+    if (request.filter_by_type.has_value())
+      sql.push_back("AND type = ?");
+
     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()));
+    // For each different query combination we should have an assign statement
+    // call that will generate a unique SQL_FROM_HERE value.
+    if (request.fetched_items_should_be_safe && request.filter_by_type) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else if (request.fetched_items_should_be_safe) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else if (request.filter_by_type) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    }
 
+    // Now bind all the parameters to the query.
+    int bind_index = 0;
+    statement.BindInt64(bind_index++, *request.feed_id);
+    statement.BindInt64(
+        bind_index++,
+        static_cast<int>(
+            media_feeds::mojom::MediaFeedItemActionStatus::kActive));
+
+    if (request.fetched_items_should_be_safe) {
       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()));
+          bind_index++,
+          static_cast<int>(media_feeds::mojom::SafeSearchResult::kSafe));
+    }
 
-      statement.BindInt64(2, *request.limit);
+    if (request.filter_by_type.has_value()) {
+      statement.BindInt64(bind_index++,
+                          static_cast<int>(*request.filter_by_type));
     }
 
-    // Bind common parameters.
-    statement.BindInt64(0, *request.feed_id);
-    statement.BindInt64(
-        1, static_cast<int>(
-               media_feeds::mojom::MediaFeedItemActionStatus::kActive));
+    statement.BindInt64(bind_index++, *request.limit);
   } 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");
+    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 = ?");
 
+    if (request.filter_by_type.has_value())
+      sql.push_back("AND type = ?");
+
     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()));
+    // For each different query combination we should have an assign statement
+    // call that will generate a unique SQL_FROM_HERE value.
+    if (request.fetched_items_should_be_safe && request.filter_by_type) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else if (request.fetched_items_should_be_safe) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else if (request.filter_by_type) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    }
+
+    // Now bind all the parameters to the query.
+    int bind_index = 0;
+    statement.BindInt64(
+        bind_index++,
+        static_cast<int>(
+            media_feeds::mojom::MediaFeedItemActionStatus::kActive));
 
+    if (request.fetched_items_should_be_safe) {
       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()));
+          bind_index++,
+          static_cast<int>(media_feeds::mojom::SafeSearchResult::kSafe));
+    }
 
-      statement.BindInt64(1, *request.limit);
+    if (request.filter_by_type.has_value()) {
+      statement.BindInt64(bind_index++,
+                          static_cast<int>(*request.filter_by_type));
     }
 
-    // Bind common parameters.
-    statement.BindInt64(
-        0, static_cast<int>(
-               media_feeds::mojom::MediaFeedItemActionStatus::kActive));
+    statement.BindInt64(bind_index++, *request.limit);
   }
 
   DCHECK(statement.is_valid());

chrome/browser/media/history/media_history_feeds_table.cc

@@ -30,6 +30,14 @@ base::UnguessableToken ProtoToUnguessableToken(
   return base::UnguessableToken::Deserialize(proto.high(), proto.low());
 }
 
+void AssignStatement(sql::Statement* statement,
+                     sql::Database* db,
+                     const sql::StatementID& id,
+                     const std::vector<std::string>& sql) {
+  statement->Assign(
+      db->GetCachedStatement(id, base::JoinString(sql, " ").c_str()));
+}
+
 }  // namespace
 
 const char MediaHistoryFeedsTable::kTableName[] = "mediaFeed";
@@ -99,6 +107,19 @@ sql::InitStatus MediaHistoryFeedsTable::CreateTableIfNonExistent() {
         "mediaFeed (safe_search_result)");
   }
 
+  if (success) {
+    success = DB()->Execute(
+        "CREATE INDEX IF NOT EXISTS mediaFeed_last_fetch_content_types_index "
+        "ON "
+        "mediaFeed (last_fetch_content_types)");
+  }
+
+  if (success) {
+    success = DB()->Execute(
+        "CREATE INDEX IF NOT EXISTS mediaFeed_top_feeds_index ON "
+        "mediaFeed (last_fetch_content_types, safe_search_result)");
+  }
+
   if (!success) {
     ResetDB();
     LOG(ERROR) << "Failed to create media history feeds table.";
@@ -226,6 +247,10 @@ std::vector<media_feeds::mojom::MediaFeedPtr> MediaHistoryFeedsTable::GetRows(
     if (request.audio_video_watchtime_min.has_value())
       sql.push_back("WHERE origin.aggregate_watchtime_audio_video_s >= ?");
 
+    // If we have a content type filter then we should add that.
+    if (request.filter_by_type.has_value())
+      sql.push_back("WHERE mediaFeed.last_fetch_content_types & ?");
+
     // Finally, order the results by watchtime.
     sql.push_back("ORDER BY origin.aggregate_watchtime_audio_video_s DESC");
 
@@ -240,14 +265,30 @@ std::vector<media_feeds::mojom::MediaFeedPtr> MediaHistoryFeedsTable::GetRows(
 
     DCHECK(origin_count.has_value());
 
+    // For each different query combination we should have an assign statement
+    // call that will generate a unique SQL_FROM_HERE value.
+    if (request.audio_video_watchtime_min.has_value() &&
+        request.filter_by_type) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else if (request.audio_video_watchtime_min.has_value()) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else if (request.filter_by_type) {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    } else {
+      AssignStatement(&statement, DB(), SQL_FROM_HERE, sql);
+    }
+
+    // Now bind all the parameters to the query.
+    int bind_index = 0;
+
     if (request.audio_video_watchtime_min.has_value()) {
-      statement.Assign(DB()->GetCachedStatement(
-          SQL_FROM_HERE, base::JoinString(sql, " ").c_str()));
+      statement.BindInt64(bind_index++,
+                          request.audio_video_watchtime_min->InSeconds());
+    }
 
-      statement.BindInt64(0, request.audio_video_watchtime_min->InSeconds());
-    } else {
-      statement.Assign(DB()->GetCachedStatement(
-          SQL_FROM_HERE, base::JoinString(sql, " ").c_str()));
+    if (request.filter_by_type.has_value()) {
+      statement.BindInt64(bind_index++,
+                          static_cast<int>(*request.filter_by_type));
     }
   } else {
     sql.push_back("FROM mediaFeed");

chrome/browser/media/history/media_history_keyed_service.cc

@@ -275,23 +275,27 @@ MediaHistoryKeyedService::GetMediaFeedItemsRequest
 MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForFeed(
     int64_t feed_id,
     unsigned limit,
-    bool fetched_items_should_be_safe) {
+    bool fetched_items_should_be_safe,
+    base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type) {
   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;
+  request.filter_by_type = filter_by_type;
   return request;
 }
 
 MediaHistoryKeyedService::GetMediaFeedItemsRequest MediaHistoryKeyedService::
     GetMediaFeedItemsRequest::CreateItemsForContinueWatching(
         unsigned limit,
-        bool fetched_items_should_be_safe) {
+        bool fetched_items_should_be_safe,
+        base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type) {
   GetMediaFeedItemsRequest request;
   request.type = Type::kContinueWatching;
   request.limit = limit;
   request.fetched_items_should_be_safe = fetched_items_should_be_safe;
+  request.filter_by_type = filter_by_type;
   return request;
 }
 
@@ -403,12 +407,14 @@ MediaHistoryKeyedService::GetMediaFeedsRequest
 MediaHistoryKeyedService::GetMediaFeedsRequest::CreateTopFeedsForDisplay(
     unsigned limit,
     int fetched_items_min,
-    bool fetched_items_min_should_be_safe) {
+    bool fetched_items_min_should_be_safe,
+    base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type) {
   GetMediaFeedsRequest request;
   request.type = Type::kTopFeedsForDisplay;
   request.limit = limit;
   request.fetched_items_min = fetched_items_min;
   request.fetched_items_min_should_be_safe = fetched_items_min_should_be_safe;
+  request.filter_by_type = filter_by_type;
   return request;
 }
 

chrome/browser/media/history/media_history_keyed_service.h

@@ -116,11 +116,13 @@ class MediaHistoryKeyedService : public KeyedService,
     static GetMediaFeedItemsRequest CreateItemsForFeed(
         int64_t feed_id,
         unsigned limit,
-        bool fetched_items_should_be_safe);
+        bool fetched_items_should_be_safe,
+        base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type);
 
     static GetMediaFeedItemsRequest CreateItemsForContinueWatching(
         unsigned limit,
-        bool fetched_items_should_be_safe);
+        bool fetched_items_should_be_safe,
+        base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type);
 
     GetMediaFeedItemsRequest();
     GetMediaFeedItemsRequest(const GetMediaFeedItemsRequest& t);
@@ -138,6 +140,9 @@ class MediaHistoryKeyedService : public KeyedService,
     // True if the item should have passed Safe Search checks. Only valid for
     // |kContinueWatching| and |kItemsForFeed|.
     bool fetched_items_should_be_safe = false;
+
+    // The item type to filter by.
+    base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type;
   };
   void GetMediaFeedItems(
       const GetMediaFeedItemsRequest& request,
@@ -252,7 +257,8 @@ class MediaHistoryKeyedService : public KeyedService,
     static GetMediaFeedsRequest CreateTopFeedsForDisplay(
         unsigned limit,
         int fetched_items_min,
-        bool fetched_items_min_should_be_safe);
+        bool fetched_items_min_should_be_safe,
+        base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type);
 
     GetMediaFeedsRequest();
     GetMediaFeedsRequest(const GetMediaFeedsRequest& t);
@@ -271,6 +277,9 @@ class MediaHistoryKeyedService : public KeyedService,
     // should have passed safe search. Only valid for |kTopFeedsForDisplay|.
     base::Optional<int> fetched_items_min;
     bool fetched_items_min_should_be_safe = false;
+
+    // The item type to filter by.
+    base::Optional<media_feeds::mojom::MediaFeedItemType> filter_by_type;
   };
   void GetMediaFeeds(
       const GetMediaFeedsRequest& request,

chrome/browser/media/history/media_history_store_unittest.cc

@@ -2006,8 +2006,9 @@ TEST_P(MediaHistoryStoreFeedsTest, GetMediaFeedsSortByWatchtimePercentile) {
   {
     // Check the media feed fetched items for display works.
     auto feeds = GetMediaFeedsSync(
-        service(), MediaHistoryKeyedService::GetMediaFeedsRequest::
-                       CreateTopFeedsForDisplay(kNumberOfFeeds, 1, false));
+        service(),
+        MediaHistoryKeyedService::GetMediaFeedsRequest::
+            CreateTopFeedsForDisplay(kNumberOfFeeds, 1, false, base::nullopt));
 
     if (IsReadOnly()) {
       EXPECT_TRUE(feeds.empty());
@@ -2042,8 +2043,9 @@ TEST_P(MediaHistoryStoreFeedsTest, GetMediaFeedsSortByWatchtimePercentile) {
   {
     // Check the media feed fetched items for display works for safe search.
     auto feeds = GetMediaFeedsSync(
-        service(), MediaHistoryKeyedService::GetMediaFeedsRequest::
-                       CreateTopFeedsForDisplay(kNumberOfFeeds, 1, true));
+        service(),
+        MediaHistoryKeyedService::GetMediaFeedsRequest::
+            CreateTopFeedsForDisplay(kNumberOfFeeds, 1, true, base::nullopt));
 
     if (IsReadOnly()) {
       EXPECT_TRUE(feeds.empty());
@@ -2052,6 +2054,38 @@ TEST_P(MediaHistoryStoreFeedsTest, GetMediaFeedsSortByWatchtimePercentile) {
       EXPECT_EQ(1, feeds[0]->id);
     }
   }
+
+  {
+    // Check the media feed fetched items for display works with a content type
+    // filter for web video content.
+    auto feeds = GetMediaFeedsSync(
+        service(), MediaHistoryKeyedService::GetMediaFeedsRequest::
+                       CreateTopFeedsForDisplay(
+                           kNumberOfFeeds, 1, false,
+                           media_feeds::mojom::MediaFeedItemType::kVideo));
+
+    if (IsReadOnly()) {
+      EXPECT_TRUE(feeds.empty());
+    } else {
+      ASSERT_EQ(54u, feeds.size());
+    }
+  }
+
+  {
+    // Check the media feed fetched items for display works with a content type
+    // filter for movies.
+    auto feeds = GetMediaFeedsSync(
+        service(), MediaHistoryKeyedService::GetMediaFeedsRequest::
+                       CreateTopFeedsForDisplay(
+                           kNumberOfFeeds, 1, false,
+                           media_feeds::mojom::MediaFeedItemType::kMovie));
+
+    if (IsReadOnly()) {
+      EXPECT_TRUE(feeds.empty());
+    } else {
+      ASSERT_EQ(1u, feeds.size());
+    }
+  }
 }
 
 TEST_P(MediaHistoryStoreFeedsTest, FeedItemsClickAndShown) {
@@ -2762,7 +2796,7 @@ TEST_P(MediaHistoryStoreFeedsTest, GetContinueWatching) {
   {
     auto items = GetItemsForMediaFeedSync(
         service(), MediaHistoryKeyedService::GetMediaFeedItemsRequest::
-                       CreateItemsForContinueWatching(5, false));
+                       CreateItemsForContinueWatching(5, false, base::nullopt));
 
     if (IsReadOnly()) {
       EXPECT_TRUE(items.empty());
@@ -2778,7 +2812,7 @@ TEST_P(MediaHistoryStoreFeedsTest, GetContinueWatching) {
   {
     auto items = GetItemsForMediaFeedSync(
         service(), MediaHistoryKeyedService::GetMediaFeedItemsRequest::
-                       CreateItemsForContinueWatching(5, true));
+                       CreateItemsForContinueWatching(5, true, base::nullopt));
 
     if (IsReadOnly()) {
       EXPECT_TRUE(items.empty());
@@ -2793,7 +2827,7 @@ TEST_P(MediaHistoryStoreFeedsTest, GetContinueWatching) {
   {
     auto items = GetItemsForMediaFeedSync(
         service(), MediaHistoryKeyedService::GetMediaFeedItemsRequest::
-                       CreateItemsForContinueWatching(1, false));
+                       CreateItemsForContinueWatching(1, false, base::nullopt));
 
     if (IsReadOnly()) {
       EXPECT_TRUE(items.empty());
@@ -2804,6 +2838,43 @@ TEST_P(MediaHistoryStoreFeedsTest, GetContinueWatching) {
       EXPECT_EQ(2, items[0]->id);
     }
   }
+
+  {
+    auto items = GetItemsForMediaFeedSync(
+        service(),
+        MediaHistoryKeyedService::GetMediaFeedItemsRequest::
+            CreateItemsForContinueWatching(
+                5, false, media_feeds::mojom::MediaFeedItemType::kMovie));
+
+    if (IsReadOnly()) {
+      EXPECT_TRUE(items.empty());
+    } else {
+      // We should only return the second item because we are limiting to
+      // Movies.
+      ASSERT_EQ(1u, items.size());
+      EXPECT_EQ(1, items[0]->id);
+      EXPECT_EQ(media_feeds::mojom::MediaFeedItemType::kMovie, items[0]->type);
+    }
+  }
+
+  {
+    auto items = GetItemsForMediaFeedSync(
+        service(),
+        MediaHistoryKeyedService::GetMediaFeedItemsRequest::
+            CreateItemsForContinueWatching(
+                5, false, media_feeds::mojom::MediaFeedItemType::kTVSeries));
+
+    if (IsReadOnly()) {
+      EXPECT_TRUE(items.empty());
+    } else {
+      // We should only return the second item because we are limiting to TV
+      // series.
+      ASSERT_EQ(1u, items.size());
+      EXPECT_EQ(2, items[0]->id);
+      EXPECT_EQ(media_feeds::mojom::MediaFeedItemType::kTVSeries,
+                items[0]->type);
+    }
+  }
 }
 
 TEST_P(MediaHistoryStoreFeedsTest, GetItemsForFeed) {
@@ -2826,7 +2897,7 @@ TEST_P(MediaHistoryStoreFeedsTest, GetItemsForFeed) {
     auto items = GetItemsForMediaFeedSync(
         service(),
         MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForFeed(
-            1, 5, false));
+            1, 5, false, base::nullopt));
 
     if (IsReadOnly()) {
       EXPECT_TRUE(items.empty());
@@ -2842,7 +2913,7 @@ TEST_P(MediaHistoryStoreFeedsTest, GetItemsForFeed) {
     auto items = GetItemsForMediaFeedSync(
         service(),
         MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForFeed(
-            1, 5, true));
+            1, 5, true, base::nullopt));
 
     // Do not return anything since all the feed items are "unsafe".
     EXPECT_TRUE(items.empty());
@@ -2852,11 +2923,39 @@ TEST_P(MediaHistoryStoreFeedsTest, GetItemsForFeed) {
     auto items = GetItemsForMediaFeedSync(
         service(),
         MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForFeed(
-            1, 0, false));
+            1, 0, false, base::nullopt));
 
     // Do not return anything since the limit is 0.
     EXPECT_TRUE(items.empty());
   }
+
+  {
+    auto items = GetItemsForMediaFeedSync(
+        service(),
+        MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForFeed(
+            1, 5, false, media_feeds::mojom::MediaFeedItemType::kTVSeries));
+
+    if (IsReadOnly()) {
+      EXPECT_TRUE(items.empty());
+    } else {
+      // We should have the third item because the others have continue
+      // watching details are have been removed and it is also a TV series.
+      ASSERT_EQ(1u, items.size());
+      EXPECT_EQ(3, items[0]->id);
+      EXPECT_EQ(media_feeds::mojom::MediaFeedItemType::kTVSeries,
+                items[0]->type);
+    }
+  }
+
+  {
+    auto items = GetItemsForMediaFeedSync(
+        service(),
+        MediaHistoryKeyedService::GetMediaFeedItemsRequest::CreateItemsForFeed(
+            1, 5, false, media_feeds::mojom::MediaFeedItemType::kMovie));
+
+    // Do not return anything since we don't have any movies.
+    EXPECT_TRUE(items.empty());
+  }
 }
 
 #endif  // !defined(OS_ANDROID)

chrome/browser/media/kaleidoscope/kaleidoscope_data_provider_impl.cc

@@ -43,6 +43,18 @@ constexpr char kChromeMediaRecommendationsOAuth2Scope[] =
 constexpr base::TimeDelta kProviderHighWatchTimeMin =
     base::TimeDelta::FromMinutes(30);
 
+base::Optional<media_feeds::mojom::MediaFeedItemType> GetFeedItemTypeForTab(
+    media::mojom::KaleidoscopeTab tab) {
+  switch (tab) {
+    case media::mojom::KaleidoscopeTab::kForYou:
+      return base::nullopt;
+    case media::mojom::KaleidoscopeTab::kMovies:
+      return media_feeds::mojom::MediaFeedItemType::kMovie;
+    case media::mojom::KaleidoscopeTab::kTVShows:
+      return media_feeds::mojom::MediaFeedItemType::kTVSeries;
+  }
+}
+
 }  // namespace
 
 KaleidoscopeDataProviderImpl::KaleidoscopeDataProviderImpl(
@@ -98,38 +110,44 @@ void KaleidoscopeDataProviderImpl::GetHighWatchTimeOrigins(
 }
 
 void KaleidoscopeDataProviderImpl::GetTopMediaFeeds(
+    media::mojom::KaleidoscopeTab tab,
     GetTopMediaFeedsCallback callback) {
   GetMediaHistoryService()->GetMediaFeeds(
       media_history::MediaHistoryKeyedService::GetMediaFeedsRequest::
           CreateTopFeedsForDisplay(
               kMediaFeedsLoadLimit, kMediaFeedsFetchedItemsMin,
               // Require Safe Search checking if the integration is enabled.
-              base::FeatureList::IsEnabled(media::kMediaFeedsSafeSearch)),
+              base::FeatureList::IsEnabled(media::kMediaFeedsSafeSearch),
+              GetFeedItemTypeForTab(tab)),
       std::move(callback));
 }
 
 void KaleidoscopeDataProviderImpl::GetMediaFeedContents(
     int64_t feed_id,
+    media::mojom::KaleidoscopeTab tab,
     GetMediaFeedContentsCallback callback) {
   GetMediaHistoryService()->GetMediaFeedItems(
       media_history::MediaHistoryKeyedService::GetMediaFeedItemsRequest::
           CreateItemsForFeed(
               feed_id, kMediaFeedsItemsMaxCount,
               // Require Safe Search checking if the integration is enabled.
-              base::FeatureList::IsEnabled(media::kMediaFeedsSafeSearch)),
+              base::FeatureList::IsEnabled(media::kMediaFeedsSafeSearch),
+              GetFeedItemTypeForTab(tab)),
       base::BindOnce(&KaleidoscopeDataProviderImpl::OnGotMediaFeedContents,
                      weak_ptr_factory.GetWeakPtr(), std::move(callback),
                      feed_id));
 }
 
 void KaleidoscopeDataProviderImpl::GetContinueWatchingMediaFeedItems(
+    media::mojom::KaleidoscopeTab tab,
     GetContinueWatchingMediaFeedItemsCallback callback) {
   GetMediaHistoryService()->GetMediaFeedItems(
       media_history::MediaHistoryKeyedService::GetMediaFeedItemsRequest::
           CreateItemsForContinueWatching(
               kMediaFeedsItemsMaxCount,
               // Require Safe Search checking if the integration is enabled.
-              base::FeatureList::IsEnabled(media::kMediaFeedsSafeSearch)),
+              base::FeatureList::IsEnabled(media::kMediaFeedsSafeSearch),
+              GetFeedItemTypeForTab(tab)),
       base::BindOnce(
           &KaleidoscopeDataProviderImpl::OnGotContinueWatchingMediaFeedItems,
           weak_ptr_factory.GetWeakPtr(), std::move(callback)));

chrome/browser/media/kaleidoscope/kaleidoscope_data_provider_impl.h

@@ -38,10 +38,13 @@ class KaleidoscopeDataProviderImpl
   ~KaleidoscopeDataProviderImpl() override;
 
   // media::mojom::KaleidoscopeDataProvider implementation.
-  void GetTopMediaFeeds(GetTopMediaFeedsCallback callback) override;
+  void GetTopMediaFeeds(media::mojom::KaleidoscopeTab tab,
+                        GetTopMediaFeedsCallback callback) override;
   void GetMediaFeedContents(int64_t feed_id,
+                            media::mojom::KaleidoscopeTab tab,
                             GetMediaFeedContentsCallback callback) override;
   void GetContinueWatchingMediaFeedItems(
+      media::mojom::KaleidoscopeTab tab,
       GetContinueWatchingMediaFeedItemsCallback callback) override;
   void GetCredentials(GetCredentialsCallback cb) override;
   void GetHighWatchTimeOrigins(GetHighWatchTimeOriginsCallback cb) override;

chrome/browser/media/kaleidoscope/mojom/kaleidoscope.mojom

@@ -17,18 +17,30 @@ struct Credentials {
   string? access_token;
 };
 
+enum KaleidoscopeTab {
+  // The content will include content of all different types.
+  kForYou,
+
+  // The content will contain only TV shows.
+  kTVShows,
+
+  // The content will contain only Movies.
+  kMovies,
+};
+
 // Provides data for the kaleidoscope page.
 interface KaleidoscopeDataProvider {
   // Returns all the Media Feeds that Kaleidoscope might decide to show.
-  GetTopMediaFeeds() => (array<media_feeds.mojom.MediaFeed> feeds);
+  // Returned feeds will be appropriate for the |tab|.
+  GetTopMediaFeeds(KaleidoscopeTab tab) => (array<media_feeds.mojom.MediaFeed> feeds);
 
   // Returns all the items from a Media Feed that Kaleidoscope might decide to
-  // show.
-  GetMediaFeedContents(int64 feed_id) => (array<media_feeds.mojom.MediaFeedItem> items);
+  // show. Returned items will be appropriate for the |tab|.
+  GetMediaFeedContents(int64 feed_id, KaleidoscopeTab tab) => (array<media_feeds.mojom.MediaFeedItem> items);
 
   // Returns all the items from the Media Feeds Store that can be displayed for
-  // continue watching.
-  GetContinueWatchingMediaFeedItems() => (array<media_feeds.mojom.MediaFeedItem> items);
+  // continue watching. Returned items will be appropriate for the |tab|.
+  GetContinueWatchingMediaFeedItems(KaleidoscopeTab tab) => (array<media_feeds.mojom.MediaFeedItem> items);
 
   // Retrieves the current credentials.
   GetCredentials() => (Credentials credentials);