drive: Change DriveServiceInterface::GetChangeList's callback type to ChangeListCallback

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 15 matching lines @@
 #include "net/base/url_util.h"
 
 using content::BrowserThread;
 using google_apis::AboutResource;
 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::ChangeResource;
 using google_apis::DownloadActionCallback;
 using google_apis::EntryActionCallback;
 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;
@@ skipping 17 matching lines @@
 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
 // - AND search for multiple words/phrases segmented by space
 // - Limited attribute search.  Only "title:" is supported.
-bool EntryMatchWithQuery(const ResourceEntry& entry,
+bool EntryMatchWithQuery(const ChangeResource& entry,
                          const std::string& query) {
   base::StringTokenizer tokenizer(query, " ");
   tokenizer.set_quote_chars("\"'");
   while (tokenizer.GetNext()) {
     std::string key, value;
     const std::string& token = tokenizer.token();
     if (token.find(':') == std::string::npos) {
       base::TrimString(token, "\"'", &value);
     } else {
       base::StringTokenizer key_value(token, ":");
       key_value.set_quote_chars("\"'");
       if (!key_value.GetNext())
         return false;
       key = key_value.token();
       if (!key_value.GetNext())
         return false;
       base::TrimString(key_value.token(), "\"'", &value);
     }
 
     // TODO(peria): Deal with other attributes than title.
     if (!key.empty() && key != "title")
       return false;
     // Search query in the title.
-    if (entry.title().find(value) == std::string::npos)
+    if (!entry.file() ||
+        entry.file()->title().find(value) == std::string::npos)
       return false;
   }
   return true;
 }
 
 void ScheduleUploadRangeCallback(const UploadRangeCallback& callback,
                                  int64 start_position,
                                  int64 end_position,
                                  GDataErrorCode error,
                                  scoped_ptr<ResourceEntry> entry) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  UploadRangeResponse(error,
                                      start_position,
                                      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>());
+}
+
 }  // namespace
 
 struct FakeDriveService::EntryInfo {
   google_apis::ChangeResource change_resource;
   GURL share_url;
   std::string content_data;
 };
 
 struct FakeDriveService::UploadSession {
   std::string content_type;
@@ skipping 135 matching lines @@
     ++blocked_resource_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_,
-                          callback);
+                          base::Bind(&GetResourceListCallbackAdapter,
+                                     callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetResourceListInDirectory(
     const std::string& directory_resource_id,
     const GetResourceListCallback& 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_,
-                          callback);
+                          base::Bind(&GetResourceListCallbackAdapter,
+                                     callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::Search(
     const std::string& search_query,
     const GetResourceListCallback& 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,
-                          callback);
+                          base::Bind(&GetResourceListCallbackAdapter,
+                                     callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::SearchByTitle(
     const std::string& title,
     const std::string& directory_resource_id,
     const GetResourceListCallback& 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,
-                          callback);
+                          base::Bind(&GetResourceListCallbackAdapter,
+                                     callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetChangeList(
     int64 start_changestamp,
-    const GetResourceListCallback& callback) {
+    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);
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetRemainingChangeList(
     const GURL& next_link,
-    const GetResourceListCallback& callback) {
+    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
   // previous method invocation, so it should start with "http://localhost/?".
   // See also GetResourceListInternal.
   DCHECK_EQ(next_link.host(), "localhost");
@@ skipping 32 matching lines @@
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetRemainingFileList(
     const GURL& next_link,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!next_link.is_empty());
   DCHECK(!callback.is_null());
 
-  return GetRemainingChangeList(next_link, callback);
+  return GetRemainingChangeList(
+      next_link, base::Bind(&GetResourceListCallbackAdapter, 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 951 matching lines @@
   return raw_new_entry;
 }
 
 void FakeDriveService::GetResourceListInternal(
     int64 start_changestamp,
     const std::string& search_query,
     const std::string& directory_resource_id,
     int start_offset,
     int max_results,
     int* load_counter,
-    const GetResourceListCallback& callback) {
+    const ChangeListCallback& callback) {
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    GDATA_NO_CONNECTION,
-                   base::Passed(scoped_ptr<ResourceList>())));
+                   base::Passed(scoped_ptr<ChangeList>())));
     return;
   }
 
   // Filter out entries per parameters like |directory_resource_id| and
   // |search_query|.
-  ScopedVector<ResourceEntry> entries;
+  ScopedVector<ChangeResource> entries;
   int num_entries_matched = 0;
   for (EntryInfoMap::iterator it = entries_.begin(); it != entries_.end();
        ++it) {
-    scoped_ptr<ResourceEntry> entry =
-        util::ConvertChangeResourceToResourceEntry(it->second->change_resource);
+    const ChangeResource& entry = it->second->change_resource;
     bool should_exclude = false;
 
     // If |directory_resource_id| is set, exclude the entry if it's not in
     // the target directory.
     if (!directory_resource_id.empty()) {
       // Get the parent resource ID of the entry.
       std::string parent_resource_id;
-      const google_apis::Link* parent_link =
-          entry->GetLinkByType(Link::LINK_PARENT);
-      if (parent_link) {
-        parent_resource_id =
-            net::UnescapeURLComponent(parent_link->href().ExtractFileName(),
-                                      net::UnescapeRule::URL_SPECIAL_CHARS);
-      }
+      if (entry.file() && !entry.file()->parents().empty())
+        parent_resource_id = entry.file()->parents()[0].file_id();
+
       if (directory_resource_id != parent_resource_id)
         should_exclude = true;
     }
 
     // If |search_query| is set, exclude the entry if it does not contain the
     // search query in the title.
     if (!should_exclude && !search_query.empty() &&
-        !EntryMatchWithQuery(*entry, search_query)) {
+        !EntryMatchWithQuery(entry, search_query)) {
       should_exclude = true;
     }
 
     // If |start_changestamp| is set, exclude the entry if the
     // changestamp is older than |largest_changestamp|.
     // See https://developers.google.com/google-apps/documents-list/
     // #retrieving_all_changes_since_a_given_changestamp
-    if (start_changestamp > 0 && entry->changestamp() < start_changestamp)
+    if (start_changestamp > 0 && entry.change_id() < start_changestamp)
       should_exclude = true;
 
     // If the caller requests other list than change list by specifying
     // zero-|start_changestamp|, exclude deleted entry from the result.
-    if (!start_changestamp && entry->deleted())
+    const bool deleted = entry.is_deleted() ||
+        (entry.file() && entry.file()->labels().is_trashed());
+    if (!start_changestamp && deleted)
       should_exclude = true;
 
     // The entry matched the criteria for inclusion.
     if (!should_exclude)
       ++num_entries_matched;
 
     // If |start_offset| is set, exclude the entry if the entry is before the
     // start index. <= instead of < as |num_entries_matched| was
     // already incremented.
     if (start_offset > 0 && num_entries_matched <= start_offset)
       should_exclude = true;
 
-    if (!should_exclude)
-      entries.push_back(entry.release());
+    if (!should_exclude) {
+      scoped_ptr<ChangeResource> entry_copied(new ChangeResource);
+      entry_copied->set_change_id(entry.change_id());
+      entry_copied->set_file_id(entry.file_id());
+      entry_copied->set_deleted(entry.is_deleted());
+      if (entry.file()) {
+        entry_copied->set_file(
+            make_scoped_ptr(new FileResource(*entry.file())));
+      }
+      entry_copied->set_modification_date(entry.modification_date());
+      entries.push_back(entry_copied.release());
+    }
   }
 
-  scoped_ptr<ResourceList> resource_list(new ResourceList);
+  scoped_ptr<ChangeList> change_list(new ChangeList);
   if (start_changestamp > 0 && start_offset == 0) {
-    resource_list->set_largest_changestamp(
-        about_resource_->largest_change_id());
+    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
     // 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());
     }
     if (!search_query.empty()) {
       next_url = net::AppendOrReplaceQueryParameter(
           next_url, "q", search_query);
     }
     if (!directory_resource_id.empty()) {
       next_url = net::AppendOrReplaceQueryParameter(
           next_url, "parent", directory_resource_id);
     }
 
-    Link* link = new Link;
-    link->set_type(Link::LINK_NEXT);
-    link->set_href(next_url);
-    resource_list->mutable_links()->push_back(link);
+    change_list->set_next_link(next_url);
   }
-  resource_list->set_entries(entries.Pass());
+  *change_list->mutable_items() = entries.Pass();
 
   if (load_counter)
     *load_counter += 1;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback, HTTP_SUCCESS, base::Passed(&resource_list)));
+      base::Bind(callback, HTTP_SUCCESS, base::Passed(&change_list)));
 }
 
 GURL FakeDriveService::GetNewUploadSessionUrl() {
   return GURL("https://upload_session_url/" +
               base::Int64ToString(next_upload_sequence_number_++));
 }
 
 google_apis::CancelCallback FakeDriveService::AddPermission(
     const std::string& resource_id,
     const std::string& email,
     google_apis::drive::PermissionRole role,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   NOTREACHED();
   return CancelCallback();
 }
 
 }  // namespace drive