drive: Replace GetResourceListCallback in DriveServiceInterface with FileListCallback

chrome/browser/drive/drive_api_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/drive_api_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/auth_service.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/drive_api_requests.h"
 #include "google_apis/drive/gdata_errorcode.h"
 #include "google_apis/drive/gdata_wapi_parser.h"
 #include "google_apis/drive/gdata_wapi_requests.h"
 #include "google_apis/drive/request_sender.h"
 #include "google_apis/google_api_keys.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
+using google_apis::AboutResourceCallback;
 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::DownloadActionCallback;
 using google_apis::EntryActionCallback;
 using google_apis::FileList;
+using google_apis::FileListCallback;
 using google_apis::FileResource;
 using google_apis::GDATA_OTHER_ERROR;
 using google_apis::GDATA_PARSE_ERROR;
 using google_apis::GDataErrorCode;
-using google_apis::AboutResourceCallback;
 using google_apis::GetContentCallback;
 using google_apis::GetResourceEntryCallback;
 using google_apis::GetResourceEntryRequest;
-using google_apis::GetResourceListCallback;
 using google_apis::GetShareUrlCallback;
 using google_apis::HTTP_NOT_IMPLEMENTED;
 using google_apis::HTTP_SUCCESS;
 using google_apis::InitiateUploadCallback;
 using google_apis::Link;
 using google_apis::ProgressCallback;
 using google_apis::RequestSender;
 using google_apis::ResourceEntry;
-using google_apis::ResourceList;
 using google_apis::UploadRangeCallback;
 using google_apis::UploadRangeResponse;
 using google_apis::drive::AboutGetRequest;
 using google_apis::drive::AppsListRequest;
 using google_apis::drive::ChangesListRequest;
 using google_apis::drive::ChangesListNextPageRequest;
 using google_apis::drive::ChildrenDeleteRequest;
 using google_apis::drive::ChildrenInsertRequest;
 using google_apis::drive::DownloadFileRequest;
 using google_apis::drive::FilesCopyRequest;
@@ skipping 50 matching lines @@
     "imageMediaMetadata/height,imageMediaMetadata/rotation,etag,"
     "parents/parentLink,alternateLink,"
     "modifiedDate,lastViewedByMeDate,shared),nextLink";
 const char kChangeListFields[] =
     "kind,items(file(kind,id,title,createdDate,sharedWithMeDate,"
     "mimeType,md5Checksum,fileSize,labels/trashed,imageMediaMetadata/width,"
     "imageMediaMetadata/height,imageMediaMetadata/rotation,etag,"
     "parents/parentLink,alternateLink,modifiedDate,lastViewedByMeDate,shared),"
     "deleted,id,fileId,modificationDate),nextLink,largestChangeId";
 
-// Callback invoked when the parsing of resource list is completed,
-// regardless whether it is succeeded or not.
-void DidConvertToResourceListOnBlockingPool(
-    const GetResourceListCallback& callback,
-    scoped_ptr<ResourceList> resource_list) {
-  GDataErrorCode error = resource_list ? HTTP_SUCCESS : GDATA_PARSE_ERROR;
-  callback.Run(error, resource_list.Pass());
-}
-
 // Converts the FileResource value to ResourceEntry and runs |callback| on the
 // UI thread.
 void ConvertFileEntryToResourceEntryAndRun(
     const GetResourceEntryCallback& callback,
     GDataErrorCode error,
     scoped_ptr<FileResource> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!value) {
     callback.Run(error, scoped_ptr<ResourceEntry>());
     return;
   }
 
   // Converting to ResourceEntry is cheap enough to do on UI thread.
   scoped_ptr<ResourceEntry> entry =
       util::ConvertFileResourceToResourceEntry(*value);
   if (!entry) {
     callback.Run(GDATA_PARSE_ERROR, scoped_ptr<ResourceEntry>());
     return;
   }
 
   callback.Run(error, entry.Pass());
 }
 
-// Thin adapter of ConvertFileListToResourceList.
-scoped_ptr<ResourceList> ConvertFileListToResourceList(
-    scoped_ptr<FileList> file_list) {
-  return util::ConvertFileListToResourceList(*file_list);
-}
-
-// Converts the FileList value to ResourceList on blocking pool and runs
-// |callback| on the UI thread.
-void ConvertFileListToResourceListOnBlockingPoolAndRun(
-    scoped_refptr<base::TaskRunner> blocking_task_runner,
-    const GetResourceListCallback& callback,
-    GDataErrorCode error,
-    scoped_ptr<FileList> value) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
-
-  if (!value) {
-    callback.Run(error, scoped_ptr<ResourceList>());
-    return;
-  }
-
-  // Convert the value on blocking pool.
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner.get(),
-      FROM_HERE,
-      base::Bind(&ConvertFileListToResourceList, base::Passed(&value)),
-      base::Bind(&DidConvertToResourceListOnBlockingPool, callback));
-}
-
 // Converts the FileResource value to ResourceEntry for upload range request,
 // and runs |callback| on the UI thread.
 void ConvertFileResourceToResourceEntryForUploadRangeAndRun(
     const UploadRangeCallback& callback,
     const UploadRangeResponse& response,
     scoped_ptr<FileResource> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!value) {
@@ skipping 77 matching lines @@
 }
 
 void DriveAPIService::Initialize(const std::string& account_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::vector<std::string> scopes;
   scopes.push_back(kDriveScope);
   scopes.push_back(kDriveAppsReadonlyScope);
   scopes.push_back(util::kDriveAppsScope);
 
-  // GData WAPI token for GetShareUrl() and GetResourceListInDirectoryByWapi().
+  // GData WAPI token for GetShareUrl().
   scopes.push_back(util::kDocsListScope);
 
   sender_.reset(new RequestSender(
       new google_apis::AuthService(oauth2_token_service_,
                                    account_id,
                                    url_request_context_getter_.get(),
                                    scopes),
       url_request_context_getter_.get(),
       blocking_task_runner_.get(),
       custom_user_agent_));
@@ skipping 15 matching lines @@
 }
 
 ResourceIdCanonicalizer DriveAPIService::GetResourceIdCanonicalizer() const {
   return base::Bind(&drive::util::CanonicalizeResourceId);
 }
 
 std::string DriveAPIService::GetRootResourceId() const {
   return kDriveApiRootDirectoryResourceId;
 }
 
-CancelCallback DriveAPIService::GetAllResourceList(
-    const GetResourceListCallback& callback) {
+CancelCallback DriveAPIService::GetAllFileList(
+    const FileListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   FilesListRequest* request = new FilesListRequest(
-      sender_.get(), url_generator_,
-      base::Bind(&ConvertFileListToResourceListOnBlockingPoolAndRun,
-                 blocking_task_runner_, callback));
+      sender_.get(), url_generator_, callback);
   request->set_max_results(kMaxNumFilesResourcePerRequest);
   request->set_q("trashed = false");  // Exclude trashed files.
   request->set_fields(kFileListFields);
   return sender_->StartRequestWithRetry(request);
 }
 
-CancelCallback DriveAPIService::GetResourceListInDirectory(
+CancelCallback DriveAPIService::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());
 
   // Because children.list method on Drive API v2 returns only the list of
   // children's references, but we need all file resource list.
   // So, here we use files.list method instead, with setting parents query.
   // After the migration from GData WAPI to Drive API v2, we should clean the
   // code up by moving the responsibility to include "parents" in the query
   // to client side.
   // We aren't interested in files in trash in this context, neither.
   FilesListRequest* request = new FilesListRequest(
-      sender_.get(), url_generator_,
-      base::Bind(&ConvertFileListToResourceListOnBlockingPoolAndRun,
-                 blocking_task_runner_, callback));
+      sender_.get(), url_generator_, callback);
   request->set_max_results(kMaxNumFilesResourcePerRequest);
   request->set_q(base::StringPrintf(
       "'%s' in parents and trashed = false",
       drive::util::EscapeQueryStringValue(directory_resource_id).c_str()));
   request->set_fields(kFileListFields);
   return sender_->StartRequestWithRetry(request);
 }
 
 CancelCallback DriveAPIService::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());
 
   FilesListRequest* request = new FilesListRequest(
-      sender_.get(), url_generator_,
-      base::Bind(&ConvertFileListToResourceListOnBlockingPoolAndRun,
-                 blocking_task_runner_, callback));
+      sender_.get(), url_generator_, callback);
   request->set_max_results(kMaxNumFilesResourcePerRequestForSearch);
   request->set_q(drive::util::TranslateQuery(search_query));
   request->set_fields(kFileListFields);
   return sender_->StartRequestWithRetry(request);
 }
 
 CancelCallback DriveAPIService::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());
 
   std::string query;
   base::StringAppendF(&query, "title = '%s'",
                       drive::util::EscapeQueryStringValue(title).c_str());
   if (!directory_resource_id.empty()) {
     base::StringAppendF(
         &query, " and '%s' in parents",
         drive::util::EscapeQueryStringValue(directory_resource_id).c_str());
   }
   query += " and trashed = false";
 
   FilesListRequest* request = new FilesListRequest(
-      sender_.get(), url_generator_,
-      base::Bind(&ConvertFileListToResourceListOnBlockingPoolAndRun,
-                 blocking_task_runner_, callback));
+      sender_.get(), url_generator_, callback);
   request->set_max_results(kMaxNumFilesResourcePerRequest);
   request->set_q(query);
   request->set_fields(kFileListFields);
   return sender_->StartRequestWithRetry(request);
 }
 
 CancelCallback DriveAPIService::GetChangeList(
     int64 start_changestamp,
     const ChangeListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 16 matching lines @@
 
   ChangesListNextPageRequest* request = new ChangesListNextPageRequest(
       sender_.get(), callback);
   request->set_next_link(next_link);
   request->set_fields(kChangeListFields);
   return sender_->StartRequestWithRetry(request);
 }
 
 CancelCallback DriveAPIService::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());
 
   FilesListNextPageRequest* request = new FilesListNextPageRequest(
-      sender_.get(),
-      base::Bind(&ConvertFileListToResourceListOnBlockingPoolAndRun,
-                 blocking_task_runner_, callback));
+      sender_.get(), callback);
   request->set_next_link(next_link);
   request->set_fields(kFileListFields);
   return sender_->StartRequestWithRetry(request);
 }
 
 CancelCallback DriveAPIService::GetResourceEntry(
     const std::string& resource_id,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
@@ skipping 401 matching lines @@
   if (CanSendRequest()) {
     FOR_EACH_OBSERVER(
         DriveServiceObserver, observers_, OnReadyToSendRequests());
   } else if (!HasRefreshToken()) {
     FOR_EACH_OBSERVER(
         DriveServiceObserver, observers_, OnRefreshTokenInvalid());
   }
 }
 
 }  // namespace drive