gdata: Add ability to fetch documents in a particular directory

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 <errno.h>
 #include <sys/stat.h>
 
 #include <set>
@@ skipping 892 matching lines @@
 
 // GDataFileSystem::GetDocumentsParams struct implementation.
 
 GDataFileSystem::GetDocumentsParams::GetDocumentsParams(
     int start_changestamp,
     int root_feed_changestamp,
     std::vector<DocumentFeed*>* feed_list,
     bool should_fetch_multiple_feeds,
     const FilePath& search_file_path,
     const std::string& search_query,
+    const std::string& directory_resource_id,
     const FindEntryCallback& callback)
     : start_changestamp(start_changestamp),
       root_feed_changestamp(root_feed_changestamp),
       feed_list(feed_list),
       should_fetch_multiple_feeds(should_fetch_multiple_feeds),
       search_file_path(search_file_path),
       search_query(search_query),
+      directory_resource_id(directory_resource_id),
       callback(callback) {
 }
 
 GDataFileSystem::GetDocumentsParams::~GetDocumentsParams() {
   STLDeleteElements(feed_list.get());
 }
 
 // GDataFileSystem::CreateDirectoryParams struct implementation.
 
 GDataFileSystem::CreateDirectoryParams::CreateDirectoryParams(
@@ skipping 267 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::PlatformFileError error = GDataToPlatformError(status);
   if (error != base::PLATFORM_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFeedFromServer(initial_origin,
                        local_changestamp + 1, 0,
                        true,  /* should_fetch_multiple_feeds */
                        search_file_path,
                        std::string() /* no search query */,
+                       std::string() /* no directory resource ID */,
                        callback,
                        base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
                                   ui_weak_ptr_));
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> account_metadata;
   if (feed_data.get())
     account_metadata = AccountMetadataFeed::CreateFrom(*feed_data);
 
   if (!account_metadata.get()) {
     LoadFeedFromServer(initial_origin,
                        local_changestamp + 1, 0,
                        true,  /* should_fetch_multiple_feeds */
                        search_file_path,
                        std::string() /* no search query */,
+                       std::string() /* no directory resource ID */,
                        callback,
                        base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
                                   ui_weak_ptr_));
     return;
   }
 
   GDataSystemService* service =
       GDataSystemServiceFactory::GetForProfile(profile_);
   service->webapps_registry()->UpdateFromFeed(account_metadata.get());
 
@@ skipping 24 matching lines @@
 
   SaveFeed(feed_data.Pass(), FilePath(kAccountMetadataFile));
 
   // Load changes from the server.
   LoadFeedFromServer(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 */,
+                     std::string() /* no directory resource ID */,
                      callback,
                      base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
                                 ui_weak_ptr_));
 }
 
 void GDataFileSystem::LoadFeedFromServer(
     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 std::string& directory_resource_id,
     const FindEntryCallback& entry_found_callback,
     const LoadDocumentFeedCallback& feed_load_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // ...then also kick off document feed fetching from the server as well.
   // |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*>);
   // Kick off document feed fetching here if we don't have complete data
   // to finish this call.
   documents_service_->GetDocuments(
       GURL(),   // root feed start.
       start_changestamp,
       search_query,
+      directory_resource_id,
       base::Bind(&GDataFileSystem::OnGetDocuments,
                  ui_weak_ptr_,
                  initial_origin,
                  feed_load_callback,
                  base::Owned(new GetDocumentsParams(start_changestamp,
                                                     root_feed_changestamp,
                                                     feed_list.release(),
                                                     should_fetch_multiple_feeds,
                                                     search_file_path,
                                                     search_query,
+                                                    directory_resource_id,
                                                     entry_found_callback))));
 }
 
 void GDataFileSystem::OnFeedFromServerLoaded(GetDocumentsParams* params,
                                              base::PlatformFileError error) {
   if (error != base::PLATFORM_FILE_OK) {
     if (!params->callback.is_null()) {
       params->callback.Run(error, FilePath(),
                            reinterpret_cast<GDataEntry*>(NULL));
     }
@@ skipping 1675 matching lines @@
   base::AutoLock lock(lock_);
   ContentOrigin initial_origin = root_->origin();
   LoadFeedFromServer(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,
+                     std::string(),  // No directory resource ID.
                      FindEntryCallback(),  // Not used.
                      base::Bind(&GDataFileSystem::OnSearch,
                                 ui_weak_ptr_, callback));
 }
 
 void GDataFileSystem::OnGetDocuments(ContentOrigin initial_origin,
                                      const LoadDocumentFeedCallback& callback,
                                      GetDocumentsParams* params,
                                      GDataErrorCode status,
                                      scoped_ptr<base::Value> data) {
@@ skipping 49 matching lines @@
   NotifyDocumentFeedFetched(num_accumulated_entries);
 
   // Check if we need to collect more data to complete the directory list.
   if (params->should_fetch_multiple_feeds && has_next_feed_url &&
       !next_feed_url.is_empty()) {
     // Kick of the remaining part of the feeds.
     documents_service_->GetDocuments(
         next_feed_url,
         params->start_changestamp,
         params->search_query,
+        params->directory_resource_id,
         base::Bind(&GDataFileSystem::OnGetDocuments,
                    ui_weak_ptr_,
                    initial_origin,
                    callback,
                    base::Owned(
                        new GetDocumentsParams(
                            params->start_changestamp,
                            params->root_feed_changestamp,
                            params->feed_list.release(),
                            params->should_fetch_multiple_feeds,
                            params->search_file_path,
                            params->search_query,
+                           params->directory_resource_id,
                            params->callback))));
     return;
   }
 
   if (!callback.is_null())
     callback.Run(params, error);
 }
 
 void GDataFileSystem::LoadRootFeedFromCache(
     bool should_load_from_server,
@@ skipping 2048 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata