[ios] Wait for sync query to return before displaying history

ios/chrome/browser/ui/history/history_collection_view_controller.mm

 // 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 "ios/chrome/browser/ui/history/history_collection_view_controller.h"
 
 #import <MobileCoreServices/MobileCoreServices.h>
 
 #include <memory>
 
 #import "base/ios/weak_nsobject.h"
 #include "base/mac/foundation_util.h"
 #import "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/browsing_data/core/history_notice_utils.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/url_formatter/url_formatter.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/chrome_url_constants.h"
 #import "ios/chrome/browser/signin/authentication_service.h"
 #include "ios/chrome/browser/signin/authentication_service_factory.h"
+#include "ios/chrome/browser/sync/sync_setup_service.h"
+#include "ios/chrome/browser/sync/sync_setup_service_factory.h"
 #import "ios/chrome/browser/ui/collection_view/cells/MDCCollectionViewCell+Chrome.h"
 #import "ios/chrome/browser/ui/collection_view/cells/activity_indicator_cell.h"
 #import "ios/chrome/browser/ui/collection_view/cells/collection_view_item.h"
 #import "ios/chrome/browser/ui/collection_view/cells/collection_view_text_item.h"
 #import "ios/chrome/browser/ui/collection_view/collection_view_model.h"
 #import "ios/chrome/browser/ui/context_menu/context_menu_coordinator.h"
 #include "ios/chrome/browser/ui/history/history_entries_status_item.h"
 #include "ios/chrome/browser/ui/history/history_entry.h"
 #include "ios/chrome/browser/ui/history/history_entry_inserter.h"
 #import "ios/chrome/browser/ui/history/history_entry_item.h"
 #include "ios/chrome/browser/ui/history/history_service_facade.h"
 #include "ios/chrome/browser/ui/history/history_service_facade_delegate.h"
 #include "ios/chrome/browser/ui/history/history_util.h"
 #import "ios/chrome/browser/ui/url_loader.h"
 #include "ios/chrome/grit/ios_strings.h"
 #import "ios/third_party/material_components_ios/src/components/Collections/src/MaterialCollections.h"
 #import "ios/third_party/material_components_ios/src/components/Palettes/src/MaterialPalettes.h"
 #import "ios/web/public/referrer.h"
 #import "ios/web/public/web_state/context_menu_params.h"
 #import "net/base/mac/url_conversions.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
 namespace {
+typedef NS_ENUM(NSInteger, ItemType) {
+  ItemTypeHistoryEntry = kItemTypeEnumZero,
+  ItemTypeEntriesStatus,
+  ItemTypeActivityIndicator,
+};
 // Section identifier for the header (sync information) section.
 const NSInteger kEntriesStatusSectionIdentifier = kSectionIdentifierEnumZero;
 // Maximum number of entries to retrieve in a single query to history service.
 const int kMaxFetchCount = 100;
 // Horizontal inset for item separators.
 const CGFloat kSeparatorInset = 10;
 }
 
 @interface HistoryCollectionViewController ()<HistoryEntriesStatusItemDelegate,
                                               HistoryEntryInserterDelegate,
@@ skipping 42 matching lines @@
 - (void)fetchHistoryForQuery:(NSString*)query
                  priorToTime:(const base::Time&)time;
 // Updates header section to provide relevant information about the currently
 // displayed history entries.
 - (void)updateEntriesStatusMessage;
 // Removes selected items from the visible collection, but does not delete them
 // from browser history.
 - (void)removeSelectedItemsFromCollection;
 // Removes all items in the collection that are not included in entries.
 - (void)filterForHistoryEntries:(NSArray*)entries;
+// Adds loading indicator to the top of the history collection, if one is not
+// already present.
+- (void)addLoadingIndicator;
 // Displays context menu on cell pressed with gestureRecognizer.
 - (void)displayContextMenuInvokedByGestureRecognizer:
     (UILongPressGestureRecognizer*)gestureRecognizer;
 // Opens URL in the current tab and dismisses the history view.
 - (void)openURL:(const GURL&)URL;
 // Opens URL in a new non-incognito tab and dismisses the history view.
 - (void)openURLInNewTab:(const GURL&)URL;
 // Opens URL in a new incognito tab and dismisses the history view.
 - (void)openURLInNewIncognitoTab:(const GURL&)URL;
 // Copies URL to the clipboard.
@@ skipping 188 matching lines @@
          inSectionWithIdentifier:
              [self.entryInserter sectionIdentifierForTimestamp:item.timestamp]];
   }
 }
 
 #pragma mark - HistoryServiceFacadeDelegate
 
 - (void)historyServiceFacade:(HistoryServiceFacade*)facade
        didReceiveQueryResult:(HistoryServiceFacade::QueryResult)result {
   self.loading = NO;
-  // Remove loading indicator.
-  CollectionViewItem* headerItem = [self.collectionViewModel
-      itemAtIndexPath:[NSIndexPath indexPathForItem:0 inSection:0]];
-  if ([headerItem.cellClass isSubclassOfClass:[ActivityIndicatorCell class]]) {
-    [self.collectionViewModel removeItemWithType:kItemTypeEnumZero
-                       fromSectionWithIdentifier:kSectionIdentifierEnumZero];
-    [self.collectionView
-        deleteItemsAtIndexPaths:@[ [NSIndexPath indexPathForItem:0
-                                                       inSection:0] ]];
+  // If history sync is enabled and there hasn't been a response from synced
+  // history, try fetching again.
+  SyncSetupService* syncSetupService =
+      SyncSetupServiceFactory::GetForBrowserState(_browserState);
+  if (syncSetupService->IsSyncEnabled() &&
+      syncSetupService->IsDataTypeEnabled(syncer::HISTORY_DELETE_DIRECTIVES) &&
+      !result.sync_returned) {
+    [self showHistoryMatchingQuery:_currentQuery];
+    return;
   }
 
   // If there are no results and no URLs have been loaded, report that no
   // history entries were found.
   if (result.entries.empty() && !self.hasHistoryEntries) {
     DCHECK(self.entriesType == NO_ENTRIES);
     [self updateEntriesStatusMessage];
     [self.delegate historyCollectionViewControllerDidChangeEntries:self];
     return;
   }
@@ skipping 10 matching lines @@
 
   __block base::scoped_nsobject<NSMutableArray> searchResults(
       [[NSMutableArray array] retain]);
   __block base::scoped_nsobject<NSString> searchQuery(
       [base::SysUTF16ToNSString(result.query) copy]);
   [self.collectionView performBatchUpdates:^{
     // There should always be at least a header section present.
     DCHECK([[self collectionViewModel] numberOfSections]);
     for (const history::HistoryEntry& entry : entries) {
       HistoryEntryItem* item =
-          [[[HistoryEntryItem alloc] initWithType:kItemTypeEnumZero
+          [[[HistoryEntryItem alloc] initWithType:ItemTypeHistoryEntry
                                      historyEntry:entry
                                      browserState:_browserState
                                          delegate:self] autorelease];
       [self.entryInserter insertHistoryEntryItem:item];
       if ([self isSearching]) {
         [searchResults addObject:item];
       }
     }
     [self.delegate historyCollectionViewControllerDidChangeEntries:self];
   }
@@ skipping 151 matching lines @@
         [self.collectionViewModel itemAtIndexPath:indexPath]);
     [self fetchHistoryForQuery:_currentQuery priorToTime:lastItem.timestamp];
   }
 }
 
 #pragma mark - Private methods
 
 - (void)fetchHistoryForQuery:(NSString*)query
                  priorToTime:(const base::Time&)time {
   self.loading = YES;
-  // Add loading indicator if nothing else is shown.
+  // Add loading indicator if no items are shown.
   if (!self.hasHistoryEntries && !self.isSearching) {
-    [self.collectionView performBatchUpdates:^{
-      NSIndexPath* indexPath = [NSIndexPath indexPathForItem:0 inSection:0];
-      if ([self.collectionViewModel hasItemAtIndexPath:indexPath]) {
-        [self.collectionViewModel
-                   removeItemWithType:kItemTypeEnumZero
-            fromSectionWithIdentifier:kSectionIdentifierEnumZero];
-        [self.collectionView deleteItemsAtIndexPaths:@[ indexPath ]];
-      }
-      CollectionViewItem* loadingIndicatorItem = [[[CollectionViewItem alloc]
-          initWithType:kItemTypeEnumZero] autorelease];
-      loadingIndicatorItem.cellClass = [ActivityIndicatorCell class];
-      [self.collectionViewModel addItem:loadingIndicatorItem
-                toSectionWithIdentifier:kEntriesStatusSectionIdentifier];
-      [self.collectionView insertItemsAtIndexPaths:@[ indexPath ]];
-    }
-                                  completion:nil];
+    [self addLoadingIndicator];
   }
 
   BOOL fetchAllHistory = !query || [query isEqualToString:@""];
   base::string16 queryString =
       fetchAllHistory ? base::string16() : base::SysNSStringToUTF16(query);
   history::QueryOptions options;
   options.end_time = time;
   options.duplicate_policy =
       fetchAllHistory ? history::QueryOptions::REMOVE_DUPLICATES_PER_DAY
                       : history::QueryOptions::REMOVE_ALL_DUPLICATES;
   options.max_count = kMaxFetchCount;
   options.matching_algorithm =
       query_parser::MatchingAlgorithm::ALWAYS_PREFIX_SEARCH;
-  _historyServiceFacade->QueryOtherFormsOfBrowsingHistory();
   _historyServiceFacade->QueryHistory(queryString, options);
   // Also determine whether notice regarding other forms of browsing history
   // should be shown.
   _historyServiceFacade->QueryOtherFormsOfBrowsingHistory();
 }
 
 - (void)updateEntriesStatusMessage {
   CollectionViewItem* entriesStatusItem = nil;
   if (!self.hasHistoryEntries) {
     CollectionViewTextItem* noResultsItem = [[[CollectionViewTextItem alloc]
-        initWithType:kItemTypeEnumZero] autorelease];
+        initWithType:ItemTypeEntriesStatus] autorelease];
     noResultsItem.text =
         self.isSearching ? l10n_util::GetNSString(IDS_HISTORY_NO_SEARCH_RESULTS)
                          : l10n_util::GetNSString(IDS_HISTORY_NO_RESULTS);
     entriesStatusItem = noResultsItem;
   } else {
     HistoryEntriesStatusItem* historyEntriesStatusItem =
-        [[[HistoryEntriesStatusItem alloc] initWithType:kItemTypeEnumZero]
+        [[[HistoryEntriesStatusItem alloc] initWithType:ItemTypeEntriesStatus]
             autorelease];
     historyEntriesStatusItem.delegate = self;
     AuthenticationService* authService =
         AuthenticationServiceFactory::GetForBrowserState(_browserState);
     BOOL signedIn = authService->IsAuthenticated();
 
     historyEntriesStatusItem.hidden =
         self.isSearching || (!signedIn && self.hasHistoryEntries);
     historyEntriesStatusItem.entriesStatus = self.entriesType;
     historyEntriesStatusItem.showsOtherBrowsingDataNotice =
         _shouldShowNoticeAboutOtherFormsOfBrowsingHistory;
     entriesStatusItem = historyEntriesStatusItem;
   }
   // Replace the item in the first section, which is always present.
   NSArray* items = [self.collectionViewModel
       itemsInSectionWithIdentifier:kEntriesStatusSectionIdentifier];
   if ([items count]) {
     // There should only ever be one item in this section.
     DCHECK([items count] == 1);
     // Only update if the item has changed.
     if ([items[0] isEqual:entriesStatusItem]) {
       return;
     }
   }
   [self.collectionView performBatchUpdates:^{
     NSIndexPath* indexPath = [NSIndexPath indexPathForItem:0 inSection:0];
     if ([items count]) {
       [self.collectionViewModel
-                 removeItemWithType:kItemTypeEnumZero
+                 removeItemWithType:[self.collectionViewModel
+                                        itemTypeForIndexPath:indexPath]
           fromSectionWithIdentifier:kEntriesStatusSectionIdentifier];
       [self.collectionView deleteItemsAtIndexPaths:@[ indexPath ]];
     }
     [self.collectionViewModel addItem:entriesStatusItem
               toSectionWithIdentifier:kEntriesStatusSectionIdentifier];
     [self.collectionView insertItemsAtIndexPaths:@[ indexPath ]];
   }
                                 completion:nil];
 }
 
@@ skipping 42 matching lines @@
               selectItemAtIndexPath:indexPath
                            animated:NO
                      scrollPosition:UICollectionViewScrollPositionNone];
         }
       }
     }
   }
   [self removeSelectedItemsFromCollection];
 }
 
+- (void)addLoadingIndicator {
+  NSIndexPath* indexPath = [NSIndexPath indexPathForItem:0 inSection:0];
+  if ([self.collectionViewModel hasItemAtIndexPath:indexPath] &&
+      [self.collectionViewModel itemTypeForIndexPath:indexPath] ==
+          ItemTypeActivityIndicator) {
+    // Do not add indicator a second time.
+    return;
+  }
+
+  [self.collectionView performBatchUpdates:^{
+    if ([self.collectionViewModel hasItemAtIndexPath:indexPath]) {
+      [self.collectionViewModel
+                 removeItemWithType:[self.collectionViewModel
+                                        itemTypeForIndexPath:indexPath]
+          fromSectionWithIdentifier:kSectionIdentifierEnumZero];
+      [self.collectionView deleteItemsAtIndexPaths:@[ indexPath ]];
+    }
+    CollectionViewItem* loadingIndicatorItem = [[[CollectionViewItem alloc]
+        initWithType:ItemTypeActivityIndicator] autorelease];
+    loadingIndicatorItem.cellClass = [ActivityIndicatorCell class];
+    [self.collectionViewModel addItem:loadingIndicatorItem
+              toSectionWithIdentifier:kEntriesStatusSectionIdentifier];
+    [self.collectionView insertItemsAtIndexPaths:@[ indexPath ]];
+  }
+                                completion:nil];
+}
+
 #pragma mark Context Menu
 
 - (void)displayContextMenuInvokedByGestureRecognizer:
     (UILongPressGestureRecognizer*)gestureRecognizer {
   if (gestureRecognizer.numberOfTouches != 1 || self.editing ||
       gestureRecognizer.state != UIGestureRecognizerStateBegan) {
     return;
   }
 
   CGPoint touchLocation =
@@ skipping 102 matching lines @@
   NSData* plainText = [base::SysUTF8ToNSString(URL.spec())
       dataUsingEncoding:NSUTF8StringEncoding];
   NSDictionary* copiedItem = @{
     (NSString*)kUTTypeURL : net::NSURLWithGURL(URL),
     (NSString*)kUTTypeUTF8PlainText : plainText,
   };
   [[UIPasteboard generalPasteboard] setItems:@[ copiedItem ]];
 }
 
 @end