drive: Add support for pagenation to FakeDriveService

chrome/browser/google_apis/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/google_apis/fake_drive_service.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
+#include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 
 using content::BrowserThread;
 
 namespace google_apis {
 
 FakeDriveService::FakeDriveService()
     : largest_changestamp_(0),
+      default_max_results_(0),
       resource_id_count_(0),
       resource_list_load_count_(0),
       account_metadata_load_count_(0),
       offline_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 FakeDriveService::~FakeDriveService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
@@ skipping 112 matching lines @@
   if (offline_) {
     scoped_ptr<ResourceList> null;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    GDATA_NO_CONNECTION,
                    base::Passed(&null)));
     return;
   }
 
+  // "start-offset" is a parameter only used in the FakeDriveService to
+  // implement pagenation.
+  int start_offset = 0;
+  int max_results = default_max_results_;
+  std::vector<std::pair<std::string, std::string> > parameters;
+  if (base::SplitStringIntoKeyValuePairs(
+          feed_url.query(), '=', '&', &parameters)) {
+    for (size_t i = 0; i < parameters.size(); ++i) {
+      if (parameters[i].first == "start-offset")
+        base::StringToInt(parameters[i].second, &start_offset);
+      if (parameters[i].first == "max-results")
+        base::StringToInt(parameters[i].second, &max_results);
+    }
+  }
+
   scoped_ptr<ResourceList> resource_list =
       ResourceList::CreateFrom(*resource_list_value_);
 
   // Filter out entries per parameters like |directory_resource_id| and
   // |search_query|.
   ScopedVector<ResourceEntry>* entries = resource_list->mutable_entries();
+
+  int num_entries_matched = 0;
   for (size_t i = 0; i < entries->size();) {
     ResourceEntry* entry = (*entries)[i];
     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. If the parent link does
       // not exist, the entry must be in the root directory.
       std::string parent_resource_id = "folder:root";
       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 (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 (!search_query.empty()) {
       if (UTF16ToUTF8(entry->title()).find(search_query) == std::string::npos)
         should_exclude = true;
     }
 
-    // If |start_changestamp| is non-zero, exclude the entry if the
+    // 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) {
-      if (entry->changestamp() < start_changestamp) {
-        should_exclude = true;
-      }
-    }
+    if (start_changestamp > 0 && entry->changestamp() < start_changestamp)
+      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->erase(entries->begin() + i);
     else
       ++i;
   }
 
+  // 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.
+    const GURL next_url(
+        base::StringPrintf(
+            "http://localhost/?start-offset=%d&max-results=%d",
+            start_offset + max_results,
+            max_results));
+    Link* link = new Link;
+    link->set_type(Link::LINK_NEXT);
+    link->set_href(next_url);
+    resource_list->mutable_links()->push_back(link);
+  }
+
   ++resource_list_load_count_;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(&resource_list)));
 }
 
 void FakeDriveService::GetResourceEntry(
     const std::string& resource_id,
@@ skipping 580 matching lines @@
   return base::StringPrintf("resource_id_%d", resource_id_count_);
 }
 
 void FakeDriveService::AddNewChangestamp(base::DictionaryValue* entry) {
   ++largest_changestamp_;
   entry->SetString("docs$changestamp.value",
                    base::Int64ToString(largest_changestamp_));
 }
 
 }  // namespace google_apis