drive: Replace GetResourceListCallback in DriveServiceInterface with FileListCallback

chrome/browser/drive/fake_drive_service.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/drive/fake_drive_service.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 using google_apis::AppList;
 using google_apis::AppListCallback;
 using google_apis::AuthStatusCallback;
 using google_apis::AuthorizeAppCallback;
 using google_apis::CancelCallback;
 using google_apis::ChangeList;
 using google_apis::ChangeListCallback;
 using google_apis::ChangeResource;
 using google_apis::DownloadActionCallback;
 using google_apis::EntryActionCallback;
+using google_apis::FileList;
+using google_apis::FileListCallback;
 using google_apis::FileResource;
 using google_apis::GDATA_FILE_ERROR;
 using google_apis::GDATA_NO_CONNECTION;
 using google_apis::GDATA_OTHER_ERROR;
 using google_apis::GDataErrorCode;
 using google_apis::GetContentCallback;
 using google_apis::GetResourceEntryCallback;
-using google_apis::GetResourceListCallback;
 using google_apis::GetShareUrlCallback;
 using google_apis::HTTP_BAD_REQUEST;
 using google_apis::HTTP_CREATED;
 using google_apis::HTTP_NOT_FOUND;
 using google_apis::HTTP_NO_CONTENT;
 using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::InitiateUploadCallback;
 using google_apis::Link;
 using google_apis::ParentReference;
 using google_apis::ProgressCallback;
 using google_apis::ResourceEntry;
-using google_apis::ResourceList;
 using google_apis::UploadRangeCallback;
 using google_apis::UploadRangeResponse;
 namespace test_util = google_apis::test_util;
 
 namespace drive {
 namespace {
 
 // Returns true if a resource entry matches with the search query.
 // Supports queries consist of following format.
 // - Phrases quoted by double/single quotes
@@ skipping 43 matching lines @@
                                      end_position),
                  base::Passed(&entry)));
 }
 
 void EntryActionCallbackAdapter(
     const EntryActionCallback& callback,
     GDataErrorCode error, scoped_ptr<ResourceEntry> resource_entry) {
   callback.Run(error);
 }
 
-void GetResourceListCallbackAdapter(const GetResourceListCallback& callback,
-                                    GDataErrorCode error,
-                                    scoped_ptr<ChangeList> change_list) {
-  callback.Run(error, change_list ?
-               util::ConvertChangeListToResourceList(*change_list) :
-               scoped_ptr<ResourceList>());
+void FileListCallbackAdapter(const FileListCallback& callback,
+                             GDataErrorCode error,
+                             scoped_ptr<ChangeList> change_list) {
+  scoped_ptr<FileList> file_list;
+  if (change_list) {
+    file_list.reset(new FileList);
+    file_list->set_next_link(change_list->next_link());
+    for (size_t i = 0; i < change_list->items().size(); ++i) {
+      const ChangeResource& entry = *change_list->items()[i];
+      if (entry.file())
+        file_list->mutable_items()->push_back(new FileResource(*entry.file()));
+    }
+  }
+  callback.Run(error, file_list.Pass());
 }
 
 }  // namespace
 
 struct FakeDriveService::EntryInfo {
   google_apis::ChangeResource change_resource;
   GURL share_url;
   std::string content_data;
 };
 
@@ skipping 27 matching lines @@
       uploaded_size(0) {
   }
 };
 
 FakeDriveService::FakeDriveService()
     : about_resource_(new AboutResource),
       published_date_seq_(0),
       next_upload_sequence_number_(0),
       default_max_results_(0),
       resource_id_count_(0),
-      resource_list_load_count_(0),
+      file_list_load_count_(0),
       change_list_load_count_(0),
       directory_load_count_(0),
       about_resource_load_count_(0),
       app_list_load_count_(0),
-      blocked_resource_list_load_count_(0),
+      blocked_file_list_load_count_(0),
       offline_(false),
-      never_return_all_resource_list_(false),
+      never_return_all_file_list_(false),
       share_url_base_("https://share_url/") {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   about_resource_->set_largest_change_id(654321);
   about_resource_->set_quota_bytes_total(9876543210);
   about_resource_->set_quota_bytes_used(6789012345);
   about_resource_->set_root_folder_id(GetRootResourceId());
 }
 
 FakeDriveService::~FakeDriveService() {
@@ skipping 66 matching lines @@
 }
 
 void FakeDriveService::ClearRefreshToken() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 std::string FakeDriveService::GetRootResourceId() const {
   return "fake_root";
 }
 
-CancelCallback FakeDriveService::GetAllResourceList(
-    const GetResourceListCallback& callback) {
+CancelCallback FakeDriveService::GetAllFileList(
+    const FileListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (never_return_all_resource_list_) {
-    ++blocked_resource_list_load_count_;
+  if (never_return_all_file_list_) {
+    ++blocked_file_list_load_count_;
     return CancelCallback();
   }
 
-  GetResourceListInternal(0,  // start changestamp
-                          std::string(),  // empty search query
-                          std::string(),  // no directory resource id,
-                          0,  // start offset
-                          default_max_results_,
-                          &resource_list_load_count_,
-                          base::Bind(&GetResourceListCallbackAdapter,
-                                     callback));
+  GetChangeListInternal(0,  // start changestamp
+                        std::string(),  // empty search query
+                        std::string(),  // no directory resource id,
+                        0,  // start offset
+                        default_max_results_,
+                        &file_list_load_count_,
+                        base::Bind(&FileListCallbackAdapter, callback));
   return CancelCallback();
 }
 
-CancelCallback FakeDriveService::GetResourceListInDirectory(
+CancelCallback FakeDriveService::GetFileListInDirectory(
     const std::string& directory_resource_id,
-    const GetResourceListCallback& callback) {
+    const FileListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!directory_resource_id.empty());
   DCHECK(!callback.is_null());
 
-  GetResourceListInternal(0,  // start changestamp
-                          std::string(),  // empty search query
-                          directory_resource_id,
-                          0,  // start offset
-                          default_max_results_,
-                          &directory_load_count_,
-                          base::Bind(&GetResourceListCallbackAdapter,
-                                     callback));
+  GetChangeListInternal(0,  // start changestamp
+                        std::string(),  // empty search query
+                        directory_resource_id,
+                        0,  // start offset
+                        default_max_results_,
+                        &directory_load_count_,
+                        base::Bind(&FileListCallbackAdapter, callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::Search(
     const std::string& search_query,
-    const GetResourceListCallback& callback) {
+    const FileListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!search_query.empty());
   DCHECK(!callback.is_null());
 
-  GetResourceListInternal(0,  // start changestamp
-                          search_query,
-                          std::string(),  // no directory resource id,
-                          0,  // start offset
-                          default_max_results_,
-                          NULL,
-                          base::Bind(&GetResourceListCallbackAdapter,
-                                     callback));
+  GetChangeListInternal(0,  // start changestamp
+                        search_query,
+                        std::string(),  // no directory resource id,
+                        0,  // start offset
+                        default_max_results_,
+                        NULL,
+                        base::Bind(&FileListCallbackAdapter, callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::SearchByTitle(
     const std::string& title,
     const std::string& directory_resource_id,
-    const GetResourceListCallback& callback) {
+    const FileListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!title.empty());
   DCHECK(!callback.is_null());
 
   // Note: the search implementation here doesn't support quotation unescape,
   // so don't escape here.
-  GetResourceListInternal(0,  // start changestamp
-                          base::StringPrintf("title:'%s'", title.c_str()),
-                          directory_resource_id,
-                          0,  // start offset
-                          default_max_results_,
-                          NULL,
-                          base::Bind(&GetResourceListCallbackAdapter,
-                                     callback));
+  GetChangeListInternal(0,  // start changestamp
+                        base::StringPrintf("title:'%s'", title.c_str()),
+                        directory_resource_id,
+                        0,  // start offset
+                        default_max_results_,
+                        NULL,
+                        base::Bind(&FileListCallbackAdapter, callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetChangeList(
     int64 start_changestamp,
     const ChangeListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  GetResourceListInternal(start_changestamp,
-                          std::string(),  // empty search query
-                          std::string(),  // no directory resource id,
-                          0,  // start offset
-                          default_max_results_,
-                          &change_list_load_count_,
-                          callback);
+  GetChangeListInternal(start_changestamp,
+                        std::string(),  // empty search query
+                        std::string(),  // no directory resource id,
+                        0,  // start offset
+                        default_max_results_,
+                        &change_list_load_count_,
+                        callback);
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetRemainingChangeList(
     const GURL& next_link,
     const ChangeListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!next_link.is_empty());
   DCHECK(!callback.is_null());
 
   // "changestamp", "q", "parent" and "start-offset" are parameters to
   // implement "paging" of the result on FakeDriveService.
-  // The URL should be the one filled in GetResourceListInternal of the
+  // The URL should be the one filled in GetChangeListInternal of the
   // previous method invocation, so it should start with "http://localhost/?".
-  // See also GetResourceListInternal.
+  // See also GetChangeListInternal.
   DCHECK_EQ(next_link.host(), "localhost");
   DCHECK_EQ(next_link.path(), "/");
 
   int64 start_changestamp = 0;
   std::string search_query;
   std::string directory_resource_id;
   int start_offset = 0;
   int max_results = default_max_results_;
   std::vector<std::pair<std::string, std::string> > parameters;
   if (base::SplitStringIntoKeyValuePairs(
@@ skipping 10 matching lines @@
             net::UnescapeURLComponent(parameters[i].second,
                                       net::UnescapeRule::URL_SPECIAL_CHARS);
       } else if (parameters[i].first == "start-offset") {
         base::StringToInt(parameters[i].second, &start_offset);
       } else if (parameters[i].first == "max-results") {
         base::StringToInt(parameters[i].second, &max_results);
       }
     }
   }
 
-  GetResourceListInternal(
-      start_changestamp, search_query, directory_resource_id,
-      start_offset, max_results, NULL, callback);
+  GetChangeListInternal(start_changestamp, search_query, directory_resource_id,
+                        start_offset, max_results, NULL, callback);
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetRemainingFileList(
     const GURL& next_link,
-    const GetResourceListCallback& callback) {
+    const FileListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!next_link.is_empty());
   DCHECK(!callback.is_null());
 
   return GetRemainingChangeList(
-      next_link, base::Bind(&GetResourceListCallbackAdapter, callback));
+      next_link, base::Bind(&FileListCallbackAdapter, callback));
 }
 
 CancelCallback FakeDriveService::GetResourceEntry(
     const std::string& resource_id,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<ResourceEntry> null;
@@ skipping 944 matching lines @@
 
   base::Time published_date =
       base::Time() + base::TimeDelta::FromMilliseconds(++published_date_seq_);
   new_file->set_created_date(published_date);
 
   EntryInfo* raw_new_entry = new_entry.release();
   entries_[resource_id] = raw_new_entry;
   return raw_new_entry;
 }
 
-void FakeDriveService::GetResourceListInternal(
+void FakeDriveService::GetChangeListInternal(
     int64 start_changestamp,
     const std::string& search_query,
     const std::string& directory_resource_id,
     int start_offset,
     int max_results,
     int* load_counter,
     const ChangeListCallback& callback) {
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
@@ skipping 73 matching lines @@
   if (start_changestamp > 0 && start_offset == 0) {
     change_list->set_largest_change_id(about_resource_->largest_change_id());
   }
 
   // If |max_results| is set, trim the entries if the number exceeded the max
   // results.
   if (max_results > 0 && entries.size() > static_cast<size_t>(max_results)) {
     entries.erase(entries.begin() + max_results, entries.end());
     // Adds the next URL.
     // Here, we embed information which is needed for continuing the
-    // GetResourceList request in the next invocation into url query
+    // GetChangeList request in the next invocation into url query
     // parameters.
     GURL next_url(base::StringPrintf(
         "http://localhost/?start-offset=%d&max-results=%d",
         start_offset + max_results,
         max_results));
     if (start_changestamp > 0) {
       next_url = net::AppendOrReplaceQueryParameter(
           next_url, "changestamp",
           base::Int64ToString(start_changestamp).c_str());
     }
@@ skipping 28 matching lines @@
     google_apis::drive::PermissionRole role,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   NOTREACHED();
   return CancelCallback();
 }
 
 }  // namespace drive