Add MostVistedSites to ContentSuggestionsMediator

ios/chrome/browser/content_suggestions/content_suggestions_mediator.mm

 // Copyright 2017 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.
 
 #import "ios/chrome/browser/content_suggestions/content_suggestions_mediator.h"
 
 #include "base/mac/bind_objc_block.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "components/favicon/core/large_icon_service.h"
 #include "components/ntp_snippets/category.h"
 #include "components/ntp_snippets/category_info.h"
 #include "components/ntp_snippets/content_suggestion.h"
+#include "components/ntp_tiles/most_visited_sites.h"
+#include "components/ntp_tiles/ntp_tile.h"
 #import "ios/chrome/browser/content_suggestions/content_suggestions_category_wrapper.h"
 #import "ios/chrome/browser/content_suggestions/content_suggestions_service_bridge_observer.h"
 #import "ios/chrome/browser/content_suggestions/mediator_util.h"
+#include "ios/chrome/browser/ntp_tiles/most_visited_sites_observer_bridge.h"
 #import "ios/chrome/browser/ui/content_suggestions/content_suggestion.h"
 #import "ios/chrome/browser/ui/content_suggestions/content_suggestions_data_sink.h"
 #import "ios/chrome/browser/ui/content_suggestions/content_suggestions_image_fetcher.h"
 #import "ios/chrome/browser/ui/content_suggestions/identifier/content_suggestion_identifier.h"
 #import "ios/chrome/browser/ui/content_suggestions/identifier/content_suggestions_section_information.h"
 #import "ios/chrome/browser/ui/favicon/favicon_attributes_provider.h"
 #include "ui/gfx/image/image.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 namespace {
 
 // Size of the favicon returned by the provider.
 const CGFloat kDefaultFaviconSize = 16;
+// Maximum number of most visited tiles fetched.
+const NSInteger kMaxNumMostVisitedTiles = 8;
 
 }  // namespace
 
 @interface ContentSuggestionsMediator ()<ContentSuggestionsImageFetcher,
-                                         ContentSuggestionsServiceObserver> {
+                                         ContentSuggestionsServiceObserver,
+                                         MostVisitedSitesObserving> {
   // Bridge for this class to become an observer of a ContentSuggestionsService.
   std::unique_ptr<ContentSuggestionsServiceBridge> _suggestionBridge;
+  std::unique_ptr<ntp_tiles::MostVisitedSites> _mostVisitedSites;
+  std::unique_ptr<ntp_tiles::MostVisitedSitesObserverBridge> _mostVisitedBridge;
 }
 
+// Most visited data from the MostVisitedSites service (copied upon receiving
+// the callback).
+@property(nonatomic, assign) std::vector<ntp_tiles::NTPTile> mostVisitedData;
+// Section Info for the Most Visited section.
+@property(nonatomic, strong)
+    ContentSuggestionsSectionInformation* mostVisitedSectionInfo;
+// Whether the page impression has been recorded.
+@property(nonatomic, assign) BOOL recordedPageImpression;
 @property(nonatomic, assign)

[lpromero, 2017/04/04 11:25:20]

For completeness, can you add a quick comment to these two properties?

[gambard, 2017/04/04 16:14:26]

Done.

     ntp_snippets::ContentSuggestionsService* contentService;
 @property(nonatomic, strong, nonnull)
     NSMutableDictionary<ContentSuggestionsCategoryWrapper*,
                         ContentSuggestionsSectionInformation*>*
         sectionInformationByCategory;
 // FaviconAttributesProvider to fetch the favicon for the suggestions.
 @property(nonatomic, nullable, strong)
     FaviconAttributesProvider* attributesProvider;
 
 // Converts the |suggestions| from |category| to ContentSuggestion and adds them
 // to the |contentArray|  if the category is available.
 - (void)addSuggestions:
             (const std::vector<ntp_snippets::ContentSuggestion>&)suggestions
           fromCategory:(ntp_snippets::Category&)category
                toArray:(NSMutableArray<ContentSuggestion*>*)contentArray;
 
 // Adds the section information for |category| in
 // self.sectionInformationByCategory.
 - (void)addSectionInformationForCategory:(ntp_snippets::Category)category;
 
 // Returns a CategoryWrapper acting as a key for this section info.
 - (ContentSuggestionsCategoryWrapper*)categoryWrapperForSectionInfo:
     (ContentSuggestionsSectionInformation*)sectionInfo;
 
 @end
 
 @implementation ContentSuggestionsMediator
 
+@synthesize mostVisitedData = _mostVisitedData;
+@synthesize mostVisitedSectionInfo = _mostVisitedSectionInfo;
+@synthesize recordedPageImpression = _recordedPageImpression;
 @synthesize contentService = _contentService;
 @synthesize dataSink = _dataSink;
 @synthesize sectionInformationByCategory = _sectionInformationByCategory;
 @synthesize attributesProvider = _attributesProvider;
 
 #pragma mark - Public
 
 - (instancetype)
 initWithContentService:(ntp_snippets::ContentSuggestionsService*)contentService
-      largeIconService:(favicon::LargeIconService*)largeIconService {
+      largeIconService:(favicon::LargeIconService*)largeIconService
+       mostVisitedSite:
+           (std::unique_ptr<ntp_tiles::MostVisitedSites>)mostVisitedSites {
   self = [super init];
   if (self) {
     _suggestionBridge =
         base::MakeUnique<ContentSuggestionsServiceBridge>(self, contentService);
     _contentService = contentService;
     _sectionInformationByCategory = [[NSMutableDictionary alloc] init];
     _attributesProvider = [[FaviconAttributesProvider alloc]
         initWithFaviconSize:kDefaultFaviconSize
              minFaviconSize:1
            largeIconService:largeIconService];
+
+    _mostVisitedSectionInfo = MostVisitedSectionInformation();
+    _mostVisitedSites = std::move(mostVisitedSites);
+    _mostVisitedBridge =
+        base::MakeUnique<ntp_tiles::MostVisitedSitesObserverBridge>(self);
+    _mostVisitedSites->SetMostVisitedURLsObserver(_mostVisitedBridge.get(),
+                                                  kMaxNumMostVisitedTiles);
   }
   return self;
 }
 
 - (void)dismissSuggestion:(ContentSuggestionIdentifier*)suggestionIdentifier {
   ContentSuggestionsCategoryWrapper* categoryWrapper =
       [self categoryWrapperForSectionInfo:suggestionIdentifier.sectionInfo];
   ntp_snippets::ContentSuggestion::ID suggestion_id =
       ntp_snippets::ContentSuggestion::ID([categoryWrapper category],
                                           suggestionIdentifier.IDInSection);
 
   self.contentService->DismissSuggestion(suggestion_id);
 }
 
 #pragma mark - ContentSuggestionsDataSource
 
 - (NSArray<ContentSuggestion*>*)allSuggestions {
+  NSMutableArray<ContentSuggestion*>* dataHolders = [NSMutableArray array];
+
+  [self addMostVisitedToArray:dataHolders];
+
   std::vector<ntp_snippets::Category> categories =

[lpromero, 2017/04/04 11:25:20]

Should you create a new -addContentSuggestionsToArray: for this second part, to
be on equal footing? (Maybe just the inner of the loop?)

[gambard, 2017/04/04 16:14:26]

Done.

       self.contentService->GetCategories();
-  NSMutableArray<ContentSuggestion*>* dataHolders = [NSMutableArray array];
   for (auto& category : categories) {
     const std::vector<ntp_snippets::ContentSuggestion>& suggestions =
         self.contentService->GetSuggestionsForCategory(category);
     [self addSuggestions:suggestions fromCategory:category toArray:dataHolders];
   }
   return dataHolders;
 }
 
 - (NSArray<ContentSuggestion*>*)suggestionsForSection:
     (ContentSuggestionsSectionInformation*)sectionInfo {
-  ntp_snippets::Category category =
-      [[self categoryWrapperForSectionInfo:sectionInfo] category];
+  NSMutableArray* convertedSuggestions = [NSMutableArray array];
 
-  NSMutableArray* convertedSuggestions = [NSMutableArray array];
-  const std::vector<ntp_snippets::ContentSuggestion>& suggestions =
-      self.contentService->GetSuggestionsForCategory(category);
-  [self addSuggestions:suggestions
-          fromCategory:category
-               toArray:convertedSuggestions];
+  if (sectionInfo == self.mostVisitedSectionInfo) {
+    [self addMostVisitedToArray:convertedSuggestions];
+  } else {
+    ntp_snippets::Category category =
+        [[self categoryWrapperForSectionInfo:sectionInfo] category];
+
+    const std::vector<ntp_snippets::ContentSuggestion>& suggestions =
+        self.contentService->GetSuggestionsForCategory(category);
+    [self addSuggestions:suggestions
+            fromCategory:category
+                 toArray:convertedSuggestions];
+  }
+
   return convertedSuggestions;
 }
 
 - (id<ContentSuggestionsImageFetcher>)imageFetcher {
   return self;
 }
 
 - (void)fetchMoreSuggestionsKnowing:
             (NSArray<ContentSuggestionIdentifier*>*)knownSuggestions
                     fromSectionInfo:
                         (ContentSuggestionsSectionInformation*)sectionInfo
                            callback:(MoreSuggestionsFetched)callback {
+  if (![self isAContentSuggestionsCategory:sectionInfo])
+    return;
+
   std::set<std::string> known_suggestion_ids;
   for (ContentSuggestionIdentifier* identifier in knownSuggestions) {
     if (identifier.sectionInfo != sectionInfo)
       continue;
     known_suggestion_ids.insert(identifier.IDInSection);
   }
 
   ContentSuggestionsCategoryWrapper* wrapper =
       [self categoryWrapperForSectionInfo:sectionInfo];
 
@@ skipping 84 matching lines @@
           suggestionIdentifier.IDInSection),
       base::BindBlockArc(^(const gfx::Image& image) {
         if (image.IsEmpty() || !callback) {
           return;
         }
 
         callback([image.ToUIImage() copy]);
       }));
 }
 
+#pragma mark - MostVisitedSitesObserving
+
+- (void)onMostVisitedURLsAvailable:
+    (const ntp_tiles::NTPTilesVector&)mostVisited {
+  self.mostVisitedData = mostVisited;
+  [self.dataSink reloadSection:self.mostVisitedSectionInfo];
+
+  if (mostVisited.size() && !self.recordedPageImpression) {
+    self.recordedPageImpression = YES;
+    RecordPageImpression(mostVisited);
+  }
+}
+
+- (void)onIconMadeAvailable:(const GURL&)siteURL {
+  [self.dataSink faviconAvailableForURL:siteURL];
+}
+
 #pragma mark - Private
 
 - (void)addSuggestions:
             (const std::vector<ntp_snippets::ContentSuggestion>&)suggestions
           fromCategory:(ntp_snippets::Category&)category
                toArray:(NSMutableArray<ContentSuggestion*>*)contentArray {
   if (!ntp_snippets::IsCategoryStatusAvailable(
           self.contentService->GetCategoryStatus(category))) {
     return;
   }
 
   ContentSuggestionsCategoryWrapper* categoryWrapper =
       [ContentSuggestionsCategoryWrapper wrapperWithCategory:category];
   if (!self.sectionInformationByCategory[categoryWrapper]) {
     [self addSectionInformationForCategory:category];
   }
 
   for (auto& contentSuggestion : suggestions) {
     ContentSuggestion* suggestion = ConvertContentSuggestion(contentSuggestion);
 
     suggestion.type = TypeForCategory(category);
 
     suggestion.suggestionIdentifier.sectionInfo =
         self.sectionInformationByCategory[categoryWrapper];
 
     [contentArray addObject:suggestion];
   }
 
   if (suggestions.size() == 0) {
-    ContentSuggestion* suggestion = [[ContentSuggestion alloc] init];
-    suggestion.type = ContentSuggestionTypeEmpty;
-    suggestion.suggestionIdentifier =
-        [[ContentSuggestionIdentifier alloc] init];
+    ContentSuggestion* suggestion = EmptySuggestion();
     suggestion.suggestionIdentifier.sectionInfo =
         self.sectionInformationByCategory[categoryWrapper];
 
     [contentArray addObject:suggestion];
   }
 }
 
 - (void)addSectionInformationForCategory:(ntp_snippets::Category)category {
   base::Optional<ntp_snippets::CategoryInfo> categoryInfo =
       self.contentService->GetCategoryInfo(category);
@@ skipping 21 matching lines @@
     NSMutableArray<ContentSuggestion*>* contentSuggestions =
         [NSMutableArray array];
     ntp_snippets::Category category = suggestions[0].id().category();
     [self addSuggestions:suggestions
             fromCategory:category
                  toArray:contentSuggestions];
     callback(contentSuggestions);
   }
 }
 
+// Adds all the suggestions for the |mostVisitedData| to |suggestions|.
+- (void)addMostVisitedToArray:(NSMutableArray<ContentSuggestion*>*)suggestions {
+  if (self.mostVisitedData.empty()) {
+    ContentSuggestion* suggestion = EmptySuggestion();
+    suggestion.suggestionIdentifier.sectionInfo = self.mostVisitedSectionInfo;
+    [suggestions addObject:suggestion];
+
+    return;
+  }
+
+  for (const ntp_tiles::NTPTile& tile : self.mostVisitedData) {
+    ContentSuggestion* suggestion = ConvertNTPTile(tile);
+    suggestion.suggestionIdentifier.sectionInfo = self.mostVisitedSectionInfo;
+    [suggestions addObject:suggestion];
+  }
+}
+
+// Returns whether the |sectionInfo| is associated with a category from the
+// content suggestions service.
+- (BOOL)isAContentSuggestionsCategory:
+    (ContentSuggestionsSectionInformation*)sectionInfo {
+  return sectionInfo != self.mostVisitedSectionInfo;

[lpromero, 2017/04/04 11:25:20]

Feels weird since mostVisitedSectionInfo is a
ContentSuggestionsSectionInformation.

For a quick fix:
Since you use this method by using the negation of the result, what about:
-isMostVisitedCategory: or -isMostVisitedSection:

If MostVisited can't be considered as a Content Suggestion with our definition,
then maybe we need a more generic type name to avoid confusion.

[gambard, 2017/04/04 16:14:26]

i have changed the name to isRelatedToContentSuggestionsService

+}
+
 @end