[FileManager] Do drive search incrementally

chrome/browser/chromeos/gdata/gdata_file_system.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 383 matching lines @@
 // Adds |entry| to |results|. Runs |callback| with |results| when
 // |run_callback| is true. When |entry| is not present in our local file system
 // snapshot, it is not added to |results|. Instead, |entry_skipped_callback| is
 // called.
 void AddEntryToSearchResults(
     std::vector<SearchResultInfo>* results,
     const SearchCallback& callback,
     const base::Closure& entry_skipped_callback,
     GDataFileError error,
     bool run_callback,
+    const GURL& next_feed,
     GDataEntry* entry) {
   // If a result is not present in our local file system snapshot, invoke
   // |entry_skipped_callback| and refreshes the snapshot with delta feed.
   // For example, this may happen if the entry has recently been added to the
   // drive (and we still haven't received its delta feed).
   if (entry) {
     const bool is_directory = entry->AsGDataDirectory() != NULL;
     results->push_back(SearchResultInfo(entry->GetFilePath(), is_directory));
   } else {
     if (!entry_skipped_callback.is_null())
       entry_skipped_callback.Run();
   }
 
   if (run_callback) {
     scoped_ptr<std::vector<SearchResultInfo> > result_vec(results);
     if (!callback.is_null())
-      callback.Run(error, result_vec.Pass());
+      callback.Run(error, next_feed, result_vec.Pass());
   }
 }
 
 // Runs task on UI thread.
 void RunTaskOnUIThread(const base::Closure& task) {
   RunTaskOnThread(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI), task);
 }
 
 // RelayCallback relays arguments for callback running on the given thread.
@@ skipping 584 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFromServer(initial_origin,
                    local_changestamp + 1, 0,
                    true,  /* should_fetch_multiple_feeds */
                    search_file_path,
                    std::string() /* no search query */,
+                   GURL(), /* feed not explicitly set */
                    std::string() /* no directory resource ID */,
                    callback,
                    base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
                               weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> account_metadata;
   if (feed_data.get()) {
     account_metadata = AccountMetadataFeed::CreateFrom(*feed_data);
 #ifndef NDEBUG
     // Save account metadata feed for analysis.
     const FilePath path =
         cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
             kAccountMetadataFile);
     PostBlockingPoolSequencedTask(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&SaveFeedOnBlockingPoolForDebugging,
                    path, base::Passed(&feed_data)));
 #endif
   }
 
   if (!account_metadata.get()) {
     LoadFromServer(initial_origin,
                    local_changestamp + 1, 0,
                    true,  /* should_fetch_multiple_feeds */
                    search_file_path,
                    std::string() /* no search query */,
+                   GURL(), /* feed not explicitly set */
                    std::string() /* no directory resource ID */,
                    callback,
                    base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
                               weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   webapps_registry_->UpdateFromFeed(account_metadata.get());
 
   bool changes_detected = true;
@@ skipping 20 matching lines @@
     return;
   }
 
   // Load changes from the server.
   LoadFromServer(initial_origin,
                  local_changestamp > 0 ? local_changestamp + 1 : 0,
                  account_metadata->largest_changestamp(),
                  true,  /* should_fetch_multiple_feeds */
                  search_file_path,
                  std::string() /* no search query */,
+                 GURL(), /* feed not explicitly set */
                  std::string() /* no directory resource ID */,
                  callback,
                  base::Bind(&GDataWapiFeedLoader::OnFeedFromServerLoaded,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 void GDataWapiFeedLoader::LoadFromServer(
     ContentOrigin initial_origin,
     int start_changestamp,
     int root_feed_changestamp,
     bool should_fetch_multiple_feeds,
     const FilePath& search_file_path,
     const std::string& search_query,
+    const GURL& feed_to_load,
     const std::string& directory_resource_id,
     const FindEntryCallback& entry_found_callback,
     const LoadDocumentFeedCallback& feed_load_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |feed_list| will contain the list of all collected feed updates that
   // we will receive through calls of DocumentsService::GetDocuments().
   scoped_ptr<std::vector<DocumentFeed*> > feed_list(
       new std::vector<DocumentFeed*>);
   const base::TimeTicks start_time = base::TimeTicks::Now();
   documents_service_->GetDocuments(
-      GURL(),   // root feed start.
+      feed_to_load,
       start_changestamp,
       search_query,
       directory_resource_id,
       base::Bind(&GDataWapiFeedLoader::OnGetDocuments,
                  weak_ptr_factory_.GetWeakPtr(),
                  initial_origin,
                  feed_load_callback,
                  base::Owned(new GetDocumentsParams(start_changestamp,
                                                     root_feed_changestamp,
                                                     feed_list.release(),
@@ skipping 1271 matching lines @@
     return;
   }
 
   feed_loader_->LoadFromServer(
       directory_service_->origin(),
       0,  // Not delta feed.
       0,  // Not used.
       true,  // multiple feeds
       file_path,
       std::string(),  // No search query
+      GURL(), /* feed not explicitly set */
       entry_proto->resource_id(),
       FindEntryCallback(),  // Not used.
       base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
                  ui_weak_ptr_));
 }
 
 void GDataFileSystem::OnRequestDirectoryRefresh(
     GetDocumentsParams* params,
     GDataFileError error) {
   DCHECK(params);
@@ skipping 302 matching lines @@
   }
 }
 
 void GDataFileSystem::OnSearch(const SearchCallback& callback,
                                GetDocumentsParams* params,
                                GDataFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
-      callback.Run(error, scoped_ptr<std::vector<SearchResultInfo> >());
+      callback.Run(error, GURL(), scoped_ptr<std::vector<SearchResultInfo> >());
     return;
   }
 
   // The search results will be returned using virtual directory.
   // The directory is not really part of the file system, so it has no parent or
   // root.
   std::vector<SearchResultInfo>* results(new std::vector<SearchResultInfo>());
 
   DCHECK_EQ(1u, params->feed_list->size());
   DocumentFeed* feed = params->feed_list->at(0);
 
+  // TODO(tbarzic): Limit total number of returned results for the query.
+  GURL next_feed;
+  feed->GetNextFeedURL(&next_feed);
+
   if (feed->entries().empty()) {
     scoped_ptr<std::vector<SearchResultInfo> > result_vec(results);
     if (!callback.is_null())
-      callback.Run(error, result_vec.Pass());
+      callback.Run(error, next_feed, result_vec.Pass());
     return;
   }
 
   // Go through all entires generated by the feed and add them to the search
   // result directory.
   for (size_t i = 0; i < feed->entries().size(); ++i) {
     DocumentEntry* doc = const_cast<DocumentEntry*>(feed->entries()[i]);
     scoped_ptr<GDataEntry> entry(
         GDataEntry::FromDocumentEntry(NULL, doc, directory_service_.get()));
 
@@ skipping 16 matching lines @@
     // We will need information about result entry to create info for callback.
     // We can't use |entry| anymore, so we have to refetch entry from file
     // system. Also, |entry| doesn't have file path set before |RefreshFile|
     // call, so we can't get file path from there.
     directory_service_->GetEntryByResourceIdAsync(entry_resource_id,
         base::Bind(&AddEntryToSearchResults,
                    results,
                    callback,
                    base::Bind(&GDataFileSystem::CheckForUpdates, ui_weak_ptr_),
                    error,
-                   i+1 == feed->entries().size()));
+                   i+1 == feed->entries().size(),
+                   next_feed));
   }
 }
 
 void GDataFileSystem::Search(const std::string& search_query,
+                             const GURL& next_feed,
                              const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::SearchAsyncOnUIThread,
                                ui_weak_ptr_,
                                search_query,
+                               next_feed,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::SearchAsyncOnUIThread(
     const std::string& search_query,
+    const GURL& next_feed,
     const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<std::vector<DocumentFeed*> > feed_list(
       new std::vector<DocumentFeed*>);
 
   ContentOrigin initial_origin = directory_service_->origin();
   feed_loader_->LoadFromServer(
       initial_origin,
       0, 0,  // We don't use change stamps when fetching search
       // data; we always fetch the whole result feed.
       false,  // Stop fetching search results after first feed
       // chunk to avoid displaying huge number of search
       // results (especially since we don't cache them).
       FilePath(),  // Not used.
       search_query,
+      next_feed,
       std::string(),  // No directory resource ID.
       FindEntryCallback(),  // Not used.
       base::Bind(&GDataFileSystem::OnSearch, ui_weak_ptr_, callback));
 }
 
 void GDataWapiFeedLoader::OnGetDocuments(
     ContentOrigin initial_origin,
     const LoadDocumentFeedCallback& callback,
     GetDocumentsParams* params,
     base::TimeTicks start_time,
@@ skipping 1343 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata