Home | History | Annotate | Download | only in drive 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/drive/fake_drive_service.h"
      6 
      7 #include <string>
      8 
      9 #include "base/files/file_util.h"
     10 #include "base/json/json_string_value_serializer.h"
     11 #include "base/logging.h"
     12 #include "base/md5.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "base/strings/string_split.h"
     16 #include "base/strings/string_tokenizer.h"
     17 #include "base/strings/string_util.h"
     18 #include "base/strings/stringprintf.h"
     19 #include "base/strings/utf_string_conversions.h"
     20 #include "base/values.h"
     21 #include "chrome/browser/drive/drive_api_util.h"
     22 #include "content/public/browser/browser_thread.h"
     23 #include "google_apis/drive/drive_api_parser.h"
     24 #include "google_apis/drive/test_util.h"
     25 #include "net/base/escape.h"
     26 #include "net/base/url_util.h"
     27 
     28 using content::BrowserThread;
     29 using google_apis::AboutResource;
     30 using google_apis::AboutResourceCallback;
     31 using google_apis::AppList;
     32 using google_apis::AppListCallback;
     33 using google_apis::AuthStatusCallback;
     34 using google_apis::AuthorizeAppCallback;
     35 using google_apis::CancelCallback;
     36 using google_apis::ChangeList;
     37 using google_apis::ChangeListCallback;
     38 using google_apis::ChangeResource;
     39 using google_apis::DownloadActionCallback;
     40 using google_apis::EntryActionCallback;
     41 using google_apis::FileList;
     42 using google_apis::FileListCallback;
     43 using google_apis::FileResource;
     44 using google_apis::FileResourceCallback;
     45 using google_apis::GDATA_FILE_ERROR;
     46 using google_apis::GDATA_NO_CONNECTION;
     47 using google_apis::GDATA_OTHER_ERROR;
     48 using google_apis::GDataErrorCode;
     49 using google_apis::GetContentCallback;
     50 using google_apis::GetShareUrlCallback;
     51 using google_apis::HTTP_BAD_REQUEST;
     52 using google_apis::HTTP_CREATED;
     53 using google_apis::HTTP_FORBIDDEN;
     54 using google_apis::HTTP_NOT_FOUND;
     55 using google_apis::HTTP_NO_CONTENT;
     56 using google_apis::HTTP_PRECONDITION;
     57 using google_apis::HTTP_RESUME_INCOMPLETE;
     58 using google_apis::HTTP_SUCCESS;
     59 using google_apis::InitiateUploadCallback;
     60 using google_apis::ParentReference;
     61 using google_apis::ProgressCallback;
     62 using google_apis::UploadRangeResponse;
     63 using google_apis::drive::UploadRangeCallback;
     64 namespace test_util = google_apis::test_util;
     65 
     66 namespace drive {
     67 namespace {
     68 
     69 // Returns true if the entry matches with the search query.
     70 // Supports queries consist of following format.
     71 // - Phrases quoted by double/single quotes
     72 // - AND search for multiple words/phrases segmented by space
     73 // - Limited attribute search.  Only "title:" is supported.
     74 bool EntryMatchWithQuery(const ChangeResource& entry,
     75                          const std::string& query) {
     76   base::StringTokenizer tokenizer(query, " ");
     77   tokenizer.set_quote_chars("\"'");
     78   while (tokenizer.GetNext()) {
     79     std::string key, value;
     80     const std::string& token = tokenizer.token();
     81     if (token.find(':') == std::string::npos) {
     82       base::TrimString(token, "\"'", &value);
     83     } else {
     84       base::StringTokenizer key_value(token, ":");
     85       key_value.set_quote_chars("\"'");
     86       if (!key_value.GetNext())
     87         return false;
     88       key = key_value.token();
     89       if (!key_value.GetNext())
     90         return false;
     91       base::TrimString(key_value.token(), "\"'", &value);
     92     }
     93 
     94     // TODO(peria): Deal with other attributes than title.
     95     if (!key.empty() && key != "title")
     96       return false;
     97     // Search query in the title.
     98     if (!entry.file() ||
     99         entry.file()->title().find(value) == std::string::npos)
    100       return false;
    101   }
    102   return true;
    103 }
    104 
    105 void ScheduleUploadRangeCallback(const UploadRangeCallback& callback,
    106                                  int64 start_position,
    107                                  int64 end_position,
    108                                  GDataErrorCode error,
    109                                  scoped_ptr<FileResource> entry) {
    110   base::MessageLoop::current()->PostTask(
    111       FROM_HERE,
    112       base::Bind(callback,
    113                  UploadRangeResponse(error,
    114                                      start_position,
    115                                      end_position),
    116                  base::Passed(&entry)));
    117 }
    118 
    119 void FileListCallbackAdapter(const FileListCallback& callback,
    120                              GDataErrorCode error,
    121                              scoped_ptr<ChangeList> change_list) {
    122   scoped_ptr<FileList> file_list;
    123   if (!change_list) {
    124     callback.Run(error, file_list.Pass());
    125     return;
    126   }
    127 
    128   file_list.reset(new FileList);
    129   file_list->set_next_link(change_list->next_link());
    130   for (size_t i = 0; i < change_list->items().size(); ++i) {
    131     const ChangeResource& entry = *change_list->items()[i];
    132     if (entry.file())
    133       file_list->mutable_items()->push_back(new FileResource(*entry.file()));
    134   }
    135   callback.Run(error, file_list.Pass());
    136 }
    137 
    138 bool UserHasWriteAccess(google_apis::drive::PermissionRole user_permission) {
    139   switch (user_permission) {
    140     case google_apis::drive::PERMISSION_ROLE_OWNER:
    141     case google_apis::drive::PERMISSION_ROLE_WRITER:
    142       return true;
    143     case google_apis::drive::PERMISSION_ROLE_READER:
    144     case google_apis::drive::PERMISSION_ROLE_COMMENTER:
    145       break;
    146   }
    147   return false;
    148 }
    149 
    150 }  // namespace
    151 
    152 struct FakeDriveService::EntryInfo {
    153   EntryInfo() : user_permission(google_apis::drive::PERMISSION_ROLE_OWNER) {}
    154 
    155   google_apis::ChangeResource change_resource;
    156   GURL share_url;
    157   std::string content_data;
    158 
    159   // Behaves in the same way as "userPermission" described in
    160   // https://developers.google.com/drive/v2/reference/files
    161   google_apis::drive::PermissionRole user_permission;
    162 };
    163 
    164 struct FakeDriveService::UploadSession {
    165   std::string content_type;
    166   int64 content_length;
    167   std::string parent_resource_id;
    168   std::string resource_id;
    169   std::string etag;
    170   std::string title;
    171 
    172   int64 uploaded_size;
    173 
    174   UploadSession()
    175       : content_length(0),
    176         uploaded_size(0) {}
    177 
    178   UploadSession(
    179       std::string content_type,
    180       int64 content_length,
    181       std::string parent_resource_id,
    182       std::string resource_id,
    183       std::string etag,
    184       std::string title)
    185     : content_type(content_type),
    186       content_length(content_length),
    187       parent_resource_id(parent_resource_id),
    188       resource_id(resource_id),
    189       etag(etag),
    190       title(title),
    191       uploaded_size(0) {
    192   }
    193 };
    194 
    195 FakeDriveService::FakeDriveService()
    196     : about_resource_(new AboutResource),
    197       published_date_seq_(0),
    198       next_upload_sequence_number_(0),
    199       default_max_results_(0),
    200       resource_id_count_(0),
    201       file_list_load_count_(0),
    202       change_list_load_count_(0),
    203       directory_load_count_(0),
    204       about_resource_load_count_(0),
    205       app_list_load_count_(0),
    206       blocked_file_list_load_count_(0),
    207       offline_(false),
    208       never_return_all_file_list_(false),
    209       share_url_base_("https://share_url/"),
    210       weak_ptr_factory_(this) {
    211   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    212 
    213   about_resource_->set_largest_change_id(654321);
    214   about_resource_->set_quota_bytes_total(9876543210);
    215   about_resource_->set_quota_bytes_used(6789012345);
    216   about_resource_->set_root_folder_id(GetRootResourceId());
    217 }
    218 
    219 FakeDriveService::~FakeDriveService() {
    220   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    221   STLDeleteValues(&entries_);
    222 }
    223 
    224 bool FakeDriveService::LoadAppListForDriveApi(
    225     const std::string& relative_path) {
    226   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    227 
    228   // Load JSON data, which must be a dictionary.
    229   scoped_ptr<base::Value> value = test_util::LoadJSONFile(relative_path);
    230   CHECK_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
    231   app_info_value_.reset(
    232       static_cast<base::DictionaryValue*>(value.release()));
    233   return app_info_value_;
    234 }
    235 
    236 void FakeDriveService::AddApp(const std::string& app_id,
    237                               const std::string& app_name,
    238                               const std::string& product_id,
    239                               const std::string& create_url) {
    240   if (app_json_template_.empty()) {
    241     base::FilePath path =
    242         test_util::GetTestFilePath("drive/applist_app_template.json");
    243     CHECK(base::ReadFileToString(path, &app_json_template_));
    244   }
    245 
    246   std::string app_json = app_json_template_;
    247   ReplaceSubstringsAfterOffset(&app_json, 0, "$AppId", app_id);
    248   ReplaceSubstringsAfterOffset(&app_json, 0, "$AppName", app_name);
    249   ReplaceSubstringsAfterOffset(&app_json, 0, "$ProductId", product_id);
    250   ReplaceSubstringsAfterOffset(&app_json, 0, "$CreateUrl", create_url);
    251 
    252   JSONStringValueSerializer json(app_json);
    253   std::string error_message;
    254   scoped_ptr<base::Value> value(json.Deserialize(NULL, &error_message));
    255   CHECK_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
    256 
    257   base::ListValue* item_list;
    258   CHECK(app_info_value_->GetListWithoutPathExpansion("items", &item_list));
    259   item_list->Append(value.release());
    260 }
    261 
    262 void FakeDriveService::RemoveAppByProductId(const std::string& product_id) {
    263   base::ListValue* item_list;
    264   CHECK(app_info_value_->GetListWithoutPathExpansion("items", &item_list));
    265   for (size_t i = 0; i < item_list->GetSize(); ++i) {
    266     base::DictionaryValue* item;
    267     CHECK(item_list->GetDictionary(i, &item));
    268     const char kKeyProductId[] = "productId";
    269     std::string item_product_id;
    270     if (item->GetStringWithoutPathExpansion(kKeyProductId, &item_product_id) &&
    271         product_id == item_product_id) {
    272       item_list->Remove(i, NULL);
    273       return;
    274     }
    275   }
    276 }
    277 
    278 bool FakeDriveService::HasApp(const std::string& app_id) const {
    279   base::ListValue* item_list;
    280   CHECK(app_info_value_->GetListWithoutPathExpansion("items", &item_list));
    281   for (size_t i = 0; i < item_list->GetSize(); ++i) {
    282     base::DictionaryValue* item;
    283     CHECK(item_list->GetDictionary(i, &item));
    284     const char kKeyId[] = "id";
    285     std::string item_id;
    286     if (item->GetStringWithoutPathExpansion(kKeyId, &item_id) &&
    287         item_id == app_id) {
    288       return true;
    289     }
    290   }
    291 
    292   return false;
    293 }
    294 
    295 void FakeDriveService::SetQuotaValue(int64 used, int64 total) {
    296   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    297 
    298   about_resource_->set_quota_bytes_used(used);
    299   about_resource_->set_quota_bytes_total(total);
    300 }
    301 
    302 GURL FakeDriveService::GetFakeLinkUrl(const std::string& resource_id) {
    303   return GURL("https://fake_server/" + net::EscapePath(resource_id));
    304 }
    305 
    306 void FakeDriveService::Initialize(const std::string& account_id) {
    307   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    308 }
    309 
    310 void FakeDriveService::AddObserver(DriveServiceObserver* observer) {
    311   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    312 }
    313 
    314 void FakeDriveService::RemoveObserver(DriveServiceObserver* observer) {
    315   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    316 }
    317 
    318 bool FakeDriveService::CanSendRequest() const {
    319   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    320   return true;
    321 }
    322 
    323 bool FakeDriveService::HasAccessToken() const {
    324   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    325   return true;
    326 }
    327 
    328 void FakeDriveService::RequestAccessToken(const AuthStatusCallback& callback) {
    329   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    330   DCHECK(!callback.is_null());
    331   callback.Run(google_apis::HTTP_NOT_MODIFIED, "fake_access_token");
    332 }
    333 
    334 bool FakeDriveService::HasRefreshToken() const {
    335   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    336   return true;
    337 }
    338 
    339 void FakeDriveService::ClearAccessToken() {
    340   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    341 }
    342 
    343 void FakeDriveService::ClearRefreshToken() {
    344   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    345 }
    346 
    347 std::string FakeDriveService::GetRootResourceId() const {
    348   return "fake_root";
    349 }
    350 
    351 CancelCallback FakeDriveService::GetAllFileList(
    352     const FileListCallback& callback) {
    353   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    354   DCHECK(!callback.is_null());
    355 
    356   if (never_return_all_file_list_) {
    357     ++blocked_file_list_load_count_;
    358     return CancelCallback();
    359   }
    360 
    361   GetChangeListInternal(0,  // start changestamp
    362                         std::string(),  // empty search query
    363                         std::string(),  // no directory resource id,
    364                         0,  // start offset
    365                         default_max_results_,
    366                         &file_list_load_count_,
    367                         base::Bind(&FileListCallbackAdapter, callback));
    368   return CancelCallback();
    369 }
    370 
    371 CancelCallback FakeDriveService::GetFileListInDirectory(
    372     const std::string& directory_resource_id,
    373     const FileListCallback& callback) {
    374   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    375   DCHECK(!directory_resource_id.empty());
    376   DCHECK(!callback.is_null());
    377 
    378   GetChangeListInternal(0,  // start changestamp
    379                         std::string(),  // empty search query
    380                         directory_resource_id,
    381                         0,  // start offset
    382                         default_max_results_,
    383                         &directory_load_count_,
    384                         base::Bind(&FileListCallbackAdapter, callback));
    385   return CancelCallback();
    386 }
    387 
    388 CancelCallback FakeDriveService::Search(
    389     const std::string& search_query,
    390     const FileListCallback& callback) {
    391   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    392   DCHECK(!search_query.empty());
    393   DCHECK(!callback.is_null());
    394 
    395   GetChangeListInternal(0,  // start changestamp
    396                         search_query,
    397                         std::string(),  // no directory resource id,
    398                         0,  // start offset
    399                         default_max_results_,
    400                         NULL,
    401                         base::Bind(&FileListCallbackAdapter, callback));
    402   return CancelCallback();
    403 }
    404 
    405 CancelCallback FakeDriveService::SearchByTitle(
    406     const std::string& title,
    407     const std::string& directory_resource_id,
    408     const FileListCallback& callback) {
    409   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    410   DCHECK(!title.empty());
    411   DCHECK(!callback.is_null());
    412 
    413   // Note: the search implementation here doesn't support quotation unescape,
    414   // so don't escape here.
    415   GetChangeListInternal(0,  // start changestamp
    416                         base::StringPrintf("title:'%s'", title.c_str()),
    417                         directory_resource_id,
    418                         0,  // start offset
    419                         default_max_results_,
    420                         NULL,
    421                         base::Bind(&FileListCallbackAdapter, callback));
    422   return CancelCallback();
    423 }
    424 
    425 CancelCallback FakeDriveService::GetChangeList(
    426     int64 start_changestamp,
    427     const ChangeListCallback& callback) {
    428   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    429   DCHECK(!callback.is_null());
    430 
    431   GetChangeListInternal(start_changestamp,
    432                         std::string(),  // empty search query
    433                         std::string(),  // no directory resource id,
    434                         0,  // start offset
    435                         default_max_results_,
    436                         &change_list_load_count_,
    437                         callback);
    438   return CancelCallback();
    439 }
    440 
    441 CancelCallback FakeDriveService::GetRemainingChangeList(
    442     const GURL& next_link,
    443     const ChangeListCallback& callback) {
    444   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    445   DCHECK(!next_link.is_empty());
    446   DCHECK(!callback.is_null());
    447 
    448   // "changestamp", "q", "parent" and "start-offset" are parameters to
    449   // implement "paging" of the result on FakeDriveService.
    450   // The URL should be the one filled in GetChangeListInternal of the
    451   // previous method invocation, so it should start with "http://localhost/?".
    452   // See also GetChangeListInternal.
    453   DCHECK_EQ(next_link.host(), "localhost");
    454   DCHECK_EQ(next_link.path(), "/");
    455 
    456   int64 start_changestamp = 0;
    457   std::string search_query;
    458   std::string directory_resource_id;
    459   int start_offset = 0;
    460   int max_results = default_max_results_;
    461   base::StringPairs parameters;
    462   if (base::SplitStringIntoKeyValuePairs(
    463           next_link.query(), '=', '&', &parameters)) {
    464     for (size_t i = 0; i < parameters.size(); ++i) {
    465       if (parameters[i].first == "changestamp") {
    466         base::StringToInt64(parameters[i].second, &start_changestamp);
    467       } else if (parameters[i].first == "q") {
    468         search_query =
    469             net::UnescapeURLComponent(parameters[i].second,
    470                                       net::UnescapeRule::URL_SPECIAL_CHARS);
    471       } else if (parameters[i].first == "parent") {
    472         directory_resource_id =
    473             net::UnescapeURLComponent(parameters[i].second,
    474                                       net::UnescapeRule::URL_SPECIAL_CHARS);
    475       } else if (parameters[i].first == "start-offset") {
    476         base::StringToInt(parameters[i].second, &start_offset);
    477       } else if (parameters[i].first == "max-results") {
    478         base::StringToInt(parameters[i].second, &max_results);
    479       }
    480     }
    481   }
    482 
    483   GetChangeListInternal(start_changestamp, search_query, directory_resource_id,
    484                         start_offset, max_results, NULL, callback);
    485   return CancelCallback();
    486 }
    487 
    488 CancelCallback FakeDriveService::GetRemainingFileList(
    489     const GURL& next_link,
    490     const FileListCallback& callback) {
    491   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    492   DCHECK(!next_link.is_empty());
    493   DCHECK(!callback.is_null());
    494 
    495   return GetRemainingChangeList(
    496       next_link, base::Bind(&FileListCallbackAdapter, callback));
    497 }
    498 
    499 CancelCallback FakeDriveService::GetFileResource(
    500     const std::string& resource_id,
    501     const FileResourceCallback& callback) {
    502   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    503   DCHECK(!callback.is_null());
    504 
    505   if (offline_) {
    506     base::MessageLoop::current()->PostTask(
    507         FROM_HERE,
    508         base::Bind(callback,
    509                    GDATA_NO_CONNECTION,
    510                    base::Passed(scoped_ptr<FileResource>())));
    511     return CancelCallback();
    512   }
    513 
    514   EntryInfo* entry = FindEntryByResourceId(resource_id);
    515   if (entry && entry->change_resource.file()) {
    516     base::MessageLoop::current()->PostTask(
    517         FROM_HERE,
    518         base::Bind(callback, HTTP_SUCCESS, base::Passed(make_scoped_ptr(
    519             new FileResource(*entry->change_resource.file())))));
    520     return CancelCallback();
    521   }
    522 
    523   base::MessageLoop::current()->PostTask(
    524       FROM_HERE,
    525       base::Bind(callback, HTTP_NOT_FOUND,
    526                  base::Passed(scoped_ptr<FileResource>())));
    527   return CancelCallback();
    528 }
    529 
    530 CancelCallback FakeDriveService::GetShareUrl(
    531     const std::string& resource_id,
    532     const GURL& /* embed_origin */,
    533     const GetShareUrlCallback& callback) {
    534   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    535   DCHECK(!callback.is_null());
    536 
    537   if (offline_) {
    538     base::MessageLoop::current()->PostTask(
    539         FROM_HERE,
    540         base::Bind(callback,
    541                    GDATA_NO_CONNECTION,
    542                    GURL()));
    543     return CancelCallback();
    544   }
    545 
    546   EntryInfo* entry = FindEntryByResourceId(resource_id);
    547   if (entry) {
    548     base::MessageLoop::current()->PostTask(
    549         FROM_HERE,
    550         base::Bind(callback, HTTP_SUCCESS, entry->share_url));
    551     return CancelCallback();
    552   }
    553 
    554   base::MessageLoop::current()->PostTask(
    555       FROM_HERE,
    556       base::Bind(callback, HTTP_NOT_FOUND, GURL()));
    557   return CancelCallback();
    558 }
    559 
    560 CancelCallback FakeDriveService::GetAboutResource(
    561     const AboutResourceCallback& callback) {
    562   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    563   DCHECK(!callback.is_null());
    564 
    565   if (offline_) {
    566     scoped_ptr<AboutResource> null;
    567     base::MessageLoop::current()->PostTask(
    568         FROM_HERE,
    569         base::Bind(callback,
    570                    GDATA_NO_CONNECTION, base::Passed(&null)));
    571     return CancelCallback();
    572   }
    573 
    574   ++about_resource_load_count_;
    575   scoped_ptr<AboutResource> about_resource(new AboutResource(*about_resource_));
    576   base::MessageLoop::current()->PostTask(
    577       FROM_HERE,
    578       base::Bind(callback,
    579                  HTTP_SUCCESS, base::Passed(&about_resource)));
    580   return CancelCallback();
    581 }
    582 
    583 CancelCallback FakeDriveService::GetAppList(const AppListCallback& callback) {
    584   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    585   DCHECK(!callback.is_null());
    586   DCHECK(app_info_value_);
    587 
    588   if (offline_) {
    589     scoped_ptr<AppList> null;
    590     base::MessageLoop::current()->PostTask(
    591         FROM_HERE,
    592         base::Bind(callback,
    593                    GDATA_NO_CONNECTION,
    594                    base::Passed(&null)));
    595     return CancelCallback();
    596   }
    597 
    598   ++app_list_load_count_;
    599   scoped_ptr<AppList> app_list(AppList::CreateFrom(*app_info_value_));
    600   base::MessageLoop::current()->PostTask(
    601       FROM_HERE,
    602       base::Bind(callback, HTTP_SUCCESS, base::Passed(&app_list)));
    603   return CancelCallback();
    604 }
    605 
    606 CancelCallback FakeDriveService::DeleteResource(
    607     const std::string& resource_id,
    608     const std::string& etag,
    609     const EntryActionCallback& callback) {
    610   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    611   DCHECK(!callback.is_null());
    612 
    613   if (offline_) {
    614     base::MessageLoop::current()->PostTask(
    615         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
    616     return CancelCallback();
    617   }
    618 
    619   EntryInfo* entry = FindEntryByResourceId(resource_id);
    620   if (!entry) {
    621     base::MessageLoop::current()->PostTask(
    622         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
    623     return CancelCallback();
    624   }
    625 
    626   ChangeResource* change = &entry->change_resource;
    627   const FileResource* file = change->file();
    628   if (change->is_deleted()) {
    629     base::MessageLoop::current()->PostTask(
    630         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
    631     return CancelCallback();
    632   }
    633 
    634   if (!etag.empty() && etag != file->etag()) {
    635     base::MessageLoop::current()->PostTask(
    636         FROM_HERE, base::Bind(callback, HTTP_PRECONDITION));
    637     return CancelCallback();
    638   }
    639 
    640   if (entry->user_permission != google_apis::drive::PERMISSION_ROLE_OWNER) {
    641     base::MessageLoop::current()->PostTask(
    642         FROM_HERE, base::Bind(callback, HTTP_FORBIDDEN));
    643     return CancelCallback();
    644   }
    645 
    646   change->set_deleted(true);
    647   AddNewChangestamp(change);
    648   change->set_file(scoped_ptr<FileResource>());
    649   base::MessageLoop::current()->PostTask(
    650       FROM_HERE, base::Bind(callback, HTTP_NO_CONTENT));
    651   base::MessageLoop::current()->PostTask(
    652       FROM_HERE,
    653       base::Bind(&FakeDriveService::NotifyObservers,
    654                  weak_ptr_factory_.GetWeakPtr()));
    655   return CancelCallback();
    656 }
    657 
    658 CancelCallback FakeDriveService::TrashResource(
    659     const std::string& resource_id,
    660     const EntryActionCallback& callback) {
    661   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    662   DCHECK(!callback.is_null());
    663 
    664   if (offline_) {
    665     base::MessageLoop::current()->PostTask(
    666         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
    667     return CancelCallback();
    668   }
    669 
    670   EntryInfo* entry = FindEntryByResourceId(resource_id);
    671   if (!entry) {
    672     base::MessageLoop::current()->PostTask(
    673         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
    674     return CancelCallback();
    675   }
    676 
    677   ChangeResource* change = &entry->change_resource;
    678   FileResource* file = change->mutable_file();
    679   if (change->is_deleted() || file->labels().is_trashed()) {
    680     base::MessageLoop::current()->PostTask(
    681         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
    682     return CancelCallback();
    683   }
    684 
    685   if (entry->user_permission != google_apis::drive::PERMISSION_ROLE_OWNER) {
    686     base::MessageLoop::current()->PostTask(
    687         FROM_HERE, base::Bind(callback, HTTP_FORBIDDEN));
    688     return CancelCallback();
    689   }
    690 
    691   file->mutable_labels()->set_trashed(true);
    692   AddNewChangestamp(change);
    693   base::MessageLoop::current()->PostTask(
    694       FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
    695   base::MessageLoop::current()->PostTask(
    696       FROM_HERE,
    697       base::Bind(&FakeDriveService::NotifyObservers,
    698                  weak_ptr_factory_.GetWeakPtr()));
    699   return CancelCallback();
    700 }
    701 
    702 CancelCallback FakeDriveService::DownloadFile(
    703     const base::FilePath& local_cache_path,
    704     const std::string& resource_id,
    705     const DownloadActionCallback& download_action_callback,
    706     const GetContentCallback& get_content_callback,
    707     const ProgressCallback& progress_callback) {
    708   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    709   DCHECK(!download_action_callback.is_null());
    710 
    711   if (offline_) {
    712     base::MessageLoop::current()->PostTask(
    713         FROM_HERE,
    714         base::Bind(download_action_callback,
    715                    GDATA_NO_CONNECTION,
    716                    base::FilePath()));
    717     return CancelCallback();
    718   }
    719 
    720   EntryInfo* entry = FindEntryByResourceId(resource_id);
    721   if (!entry || entry->change_resource.file()->IsHostedDocument()) {
    722     base::MessageLoopProxy::current()->PostTask(
    723         FROM_HERE,
    724         base::Bind(download_action_callback, HTTP_NOT_FOUND, base::FilePath()));
    725     return CancelCallback();
    726   }
    727 
    728   const FileResource* file = entry->change_resource.file();
    729   const std::string& content_data = entry->content_data;
    730   int64 file_size = file->file_size();
    731   DCHECK_EQ(static_cast<size_t>(file_size), content_data.size());
    732 
    733   if (!get_content_callback.is_null()) {
    734     const int64 kBlockSize = 5;
    735     for (int64 i = 0; i < file_size; i += kBlockSize) {
    736       const int64 size = std::min(kBlockSize, file_size - i);
    737       scoped_ptr<std::string> content_for_callback(
    738           new std::string(content_data.substr(i, size)));
    739       base::MessageLoopProxy::current()->PostTask(
    740           FROM_HERE,
    741           base::Bind(get_content_callback, HTTP_SUCCESS,
    742                      base::Passed(&content_for_callback)));
    743     }
    744   }
    745 
    746   if (!test_util::WriteStringToFile(local_cache_path, content_data)) {
    747     // Failed to write the content.
    748     base::MessageLoopProxy::current()->PostTask(
    749         FROM_HERE,
    750         base::Bind(download_action_callback,
    751                    GDATA_FILE_ERROR, base::FilePath()));
    752     return CancelCallback();
    753   }
    754 
    755   if (!progress_callback.is_null()) {
    756     // See also the comment in ResumeUpload(). For testing that clients
    757     // can handle the case progress_callback is called multiple times,
    758     // here we invoke the callback twice.
    759     base::MessageLoopProxy::current()->PostTask(
    760         FROM_HERE,
    761         base::Bind(progress_callback, file_size / 2, file_size));
    762     base::MessageLoopProxy::current()->PostTask(
    763         FROM_HERE,
    764         base::Bind(progress_callback, file_size, file_size));
    765   }
    766   base::MessageLoopProxy::current()->PostTask(
    767       FROM_HERE,
    768       base::Bind(download_action_callback,
    769                  HTTP_SUCCESS,
    770                  local_cache_path));
    771   return CancelCallback();
    772 }
    773 
    774 CancelCallback FakeDriveService::CopyResource(
    775     const std::string& resource_id,
    776     const std::string& in_parent_resource_id,
    777     const std::string& new_title,
    778     const base::Time& last_modified,
    779     const FileResourceCallback& callback) {
    780   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    781   DCHECK(!callback.is_null());
    782 
    783   if (offline_) {
    784     base::MessageLoop::current()->PostTask(
    785         FROM_HERE,
    786         base::Bind(callback,
    787                    GDATA_NO_CONNECTION,
    788                    base::Passed(scoped_ptr<FileResource>())));
    789     return CancelCallback();
    790   }
    791 
    792   const std::string& parent_resource_id = in_parent_resource_id.empty() ?
    793       GetRootResourceId() : in_parent_resource_id;
    794 
    795   EntryInfo* entry = FindEntryByResourceId(resource_id);
    796   if (!entry) {
    797     base::MessageLoop::current()->PostTask(
    798         FROM_HERE,
    799         base::Bind(callback, HTTP_NOT_FOUND,
    800                    base::Passed(scoped_ptr<FileResource>())));
    801     return CancelCallback();
    802   }
    803 
    804   // Make a copy and set the new resource ID and the new title.
    805   scoped_ptr<EntryInfo> copied_entry(new EntryInfo);
    806   copied_entry->content_data = entry->content_data;
    807   copied_entry->share_url = entry->share_url;
    808   copied_entry->change_resource.set_file(
    809       make_scoped_ptr(new FileResource(*entry->change_resource.file())));
    810 
    811   ChangeResource* new_change = &copied_entry->change_resource;
    812   FileResource* new_file = new_change->mutable_file();
    813   const std::string new_resource_id = GetNewResourceId();
    814   new_change->set_file_id(new_resource_id);
    815   new_file->set_file_id(new_resource_id);
    816   new_file->set_title(new_title);
    817 
    818   ParentReference parent;
    819   parent.set_file_id(parent_resource_id);
    820   parent.set_parent_link(GetFakeLinkUrl(parent_resource_id));
    821   std::vector<ParentReference> parents;
    822   parents.push_back(parent);
    823   *new_file->mutable_parents() = parents;
    824 
    825   if (!last_modified.is_null())
    826     new_file->set_modified_date(last_modified);
    827 
    828   AddNewChangestamp(new_change);
    829   UpdateETag(new_file);
    830 
    831   // Add the new entry to the map.
    832   entries_[new_resource_id] = copied_entry.release();
    833 
    834   base::MessageLoop::current()->PostTask(
    835       FROM_HERE,
    836       base::Bind(callback,
    837                  HTTP_SUCCESS,
    838                  base::Passed(make_scoped_ptr(new FileResource(*new_file)))));
    839   base::MessageLoop::current()->PostTask(
    840       FROM_HERE,
    841       base::Bind(&FakeDriveService::NotifyObservers,
    842                  weak_ptr_factory_.GetWeakPtr()));
    843   return CancelCallback();
    844 }
    845 
    846 CancelCallback FakeDriveService::UpdateResource(
    847     const std::string& resource_id,
    848     const std::string& parent_resource_id,
    849     const std::string& new_title,
    850     const base::Time& last_modified,
    851     const base::Time& last_viewed_by_me,
    852     const google_apis::FileResourceCallback& callback) {
    853   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    854   DCHECK(!callback.is_null());
    855 
    856   if (offline_) {
    857     base::MessageLoop::current()->PostTask(
    858         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION,
    859                               base::Passed(scoped_ptr<FileResource>())));
    860     return CancelCallback();
    861   }
    862 
    863   EntryInfo* entry = FindEntryByResourceId(resource_id);
    864   if (!entry) {
    865     base::MessageLoop::current()->PostTask(
    866         FROM_HERE,
    867         base::Bind(callback, HTTP_NOT_FOUND,
    868                    base::Passed(scoped_ptr<FileResource>())));
    869     return CancelCallback();
    870   }
    871 
    872   if (!UserHasWriteAccess(entry->user_permission)) {
    873     base::MessageLoop::current()->PostTask(
    874         FROM_HERE,
    875         base::Bind(callback, HTTP_FORBIDDEN,
    876                    base::Passed(scoped_ptr<FileResource>())));
    877     return CancelCallback();
    878   }
    879 
    880   ChangeResource* change = &entry->change_resource;
    881   FileResource* file = change->mutable_file();
    882 
    883   if (!new_title.empty())
    884     file->set_title(new_title);
    885 
    886   // Set parent if necessary.
    887   if (!parent_resource_id.empty()) {
    888     ParentReference parent;
    889     parent.set_file_id(parent_resource_id);
    890     parent.set_parent_link(GetFakeLinkUrl(parent_resource_id));
    891 
    892     std::vector<ParentReference> parents;
    893     parents.push_back(parent);
    894     *file->mutable_parents() = parents;
    895   }
    896 
    897   if (!last_modified.is_null())
    898     file->set_modified_date(last_modified);
    899 
    900   if (!last_viewed_by_me.is_null())
    901     file->set_last_viewed_by_me_date(last_viewed_by_me);
    902 
    903   AddNewChangestamp(change);
    904   UpdateETag(file);
    905 
    906   base::MessageLoop::current()->PostTask(
    907       FROM_HERE,
    908       base::Bind(callback, HTTP_SUCCESS,
    909                  base::Passed(make_scoped_ptr(new FileResource(*file)))));
    910   base::MessageLoop::current()->PostTask(
    911       FROM_HERE,
    912       base::Bind(&FakeDriveService::NotifyObservers,
    913                  weak_ptr_factory_.GetWeakPtr()));
    914   return CancelCallback();
    915 }
    916 
    917 CancelCallback FakeDriveService::AddResourceToDirectory(
    918     const std::string& parent_resource_id,
    919     const std::string& resource_id,
    920     const EntryActionCallback& callback) {
    921   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    922   DCHECK(!callback.is_null());
    923 
    924   if (offline_) {
    925     base::MessageLoop::current()->PostTask(
    926         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
    927     return CancelCallback();
    928   }
    929 
    930   EntryInfo* entry = FindEntryByResourceId(resource_id);
    931   if (!entry) {
    932     base::MessageLoop::current()->PostTask(
    933         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
    934     return CancelCallback();
    935   }
    936 
    937   ChangeResource* change = &entry->change_resource;
    938   // On the real Drive server, resources do not necessary shape a tree
    939   // structure. That is, each resource can have multiple parent.
    940   // We mimic the behavior here; AddResourceToDirectoy just adds
    941   // one more parent, not overwriting old ones.
    942   ParentReference parent;
    943   parent.set_file_id(parent_resource_id);
    944   parent.set_parent_link(GetFakeLinkUrl(parent_resource_id));
    945   change->mutable_file()->mutable_parents()->push_back(parent);
    946 
    947   AddNewChangestamp(change);
    948   base::MessageLoop::current()->PostTask(
    949       FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
    950   base::MessageLoop::current()->PostTask(
    951       FROM_HERE,
    952       base::Bind(&FakeDriveService::NotifyObservers,
    953                  weak_ptr_factory_.GetWeakPtr()));
    954   return CancelCallback();
    955 }
    956 
    957 CancelCallback FakeDriveService::RemoveResourceFromDirectory(
    958     const std::string& parent_resource_id,
    959     const std::string& resource_id,
    960     const EntryActionCallback& callback) {
    961   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    962   DCHECK(!callback.is_null());
    963 
    964   if (offline_) {
    965     base::MessageLoop::current()->PostTask(
    966         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
    967     return CancelCallback();
    968   }
    969 
    970   EntryInfo* entry = FindEntryByResourceId(resource_id);
    971   if (!entry) {
    972     base::MessageLoop::current()->PostTask(
    973         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
    974     return CancelCallback();
    975   }
    976 
    977   ChangeResource* change = &entry->change_resource;
    978   FileResource* file = change->mutable_file();
    979   std::vector<ParentReference>* parents = file->mutable_parents();
    980   for (size_t i = 0; i < parents->size(); ++i) {
    981     if ((*parents)[i].file_id() == parent_resource_id) {
    982       parents->erase(parents->begin() + i);
    983       AddNewChangestamp(change);
    984       base::MessageLoop::current()->PostTask(
    985           FROM_HERE, base::Bind(callback, HTTP_NO_CONTENT));
    986       base::MessageLoop::current()->PostTask(
    987           FROM_HERE,
    988           base::Bind(&FakeDriveService::NotifyObservers,
    989                      weak_ptr_factory_.GetWeakPtr()));
    990       return CancelCallback();
    991     }
    992   }
    993 
    994   base::MessageLoop::current()->PostTask(
    995       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
    996   return CancelCallback();
    997 }
    998 
    999 CancelCallback FakeDriveService::AddNewDirectory(
   1000     const std::string& parent_resource_id,
   1001     const std::string& directory_title,
   1002     const AddNewDirectoryOptions& options,
   1003     const FileResourceCallback& callback) {
   1004   return AddNewDirectoryWithResourceId(
   1005       "",
   1006       parent_resource_id.empty() ? GetRootResourceId() : parent_resource_id,
   1007       directory_title,
   1008       options,
   1009       callback);
   1010 }
   1011 
   1012 CancelCallback FakeDriveService::InitiateUploadNewFile(
   1013     const std::string& content_type,
   1014     int64 content_length,
   1015     const std::string& parent_resource_id,
   1016     const std::string& title,
   1017     const InitiateUploadNewFileOptions& options,
   1018     const InitiateUploadCallback& callback) {
   1019   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1020   DCHECK(!callback.is_null());
   1021 
   1022   if (offline_) {
   1023     base::MessageLoop::current()->PostTask(
   1024         FROM_HERE,
   1025         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
   1026     return CancelCallback();
   1027   }
   1028 
   1029   if (parent_resource_id != GetRootResourceId() &&
   1030       !entries_.count(parent_resource_id)) {
   1031     base::MessageLoop::current()->PostTask(
   1032         FROM_HERE,
   1033         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
   1034     return CancelCallback();
   1035   }
   1036 
   1037   GURL session_url = GetNewUploadSessionUrl();
   1038   upload_sessions_[session_url] =
   1039       UploadSession(content_type, content_length,
   1040                     parent_resource_id,
   1041                     "",  // resource_id
   1042                     "",  // etag
   1043                     title);
   1044 
   1045   base::MessageLoop::current()->PostTask(
   1046       FROM_HERE,
   1047       base::Bind(callback, HTTP_SUCCESS, session_url));
   1048   return CancelCallback();
   1049 }
   1050 
   1051 CancelCallback FakeDriveService::InitiateUploadExistingFile(
   1052     const std::string& content_type,
   1053     int64 content_length,
   1054     const std::string& resource_id,
   1055     const InitiateUploadExistingFileOptions& options,
   1056     const InitiateUploadCallback& callback) {
   1057   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1058   DCHECK(!callback.is_null());
   1059 
   1060   if (offline_) {
   1061     base::MessageLoop::current()->PostTask(
   1062         FROM_HERE,
   1063         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
   1064     return CancelCallback();
   1065   }
   1066 
   1067   EntryInfo* entry = FindEntryByResourceId(resource_id);
   1068   if (!entry) {
   1069     base::MessageLoop::current()->PostTask(
   1070         FROM_HERE,
   1071         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
   1072     return CancelCallback();
   1073   }
   1074 
   1075   if (!UserHasWriteAccess(entry->user_permission)) {
   1076     base::MessageLoop::current()->PostTask(
   1077         FROM_HERE,
   1078         base::Bind(callback, HTTP_FORBIDDEN, GURL()));
   1079     return CancelCallback();
   1080   }
   1081 
   1082   FileResource* file = entry->change_resource.mutable_file();
   1083   if (!options.etag.empty() && options.etag != file->etag()) {
   1084     base::MessageLoop::current()->PostTask(
   1085         FROM_HERE,
   1086         base::Bind(callback, HTTP_PRECONDITION, GURL()));
   1087     return CancelCallback();
   1088   }
   1089   // TODO(hashimoto): Update |file|'s metadata with |options|.
   1090 
   1091   GURL session_url = GetNewUploadSessionUrl();
   1092   upload_sessions_[session_url] =
   1093       UploadSession(content_type, content_length,
   1094                     "",  // parent_resource_id
   1095                     resource_id,
   1096                     file->etag(),
   1097                     "" /* title */);
   1098 
   1099   base::MessageLoop::current()->PostTask(
   1100       FROM_HERE,
   1101       base::Bind(callback, HTTP_SUCCESS, session_url));
   1102   return CancelCallback();
   1103 }
   1104 
   1105 CancelCallback FakeDriveService::GetUploadStatus(
   1106     const GURL& upload_url,
   1107     int64 content_length,
   1108     const UploadRangeCallback& callback) {
   1109   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1110   DCHECK(!callback.is_null());
   1111   return CancelCallback();
   1112 }
   1113 
   1114 CancelCallback FakeDriveService::ResumeUpload(
   1115       const GURL& upload_url,
   1116       int64 start_position,
   1117       int64 end_position,
   1118       int64 content_length,
   1119       const std::string& content_type,
   1120       const base::FilePath& local_file_path,
   1121       const UploadRangeCallback& callback,
   1122       const ProgressCallback& progress_callback) {
   1123   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1124   DCHECK(!callback.is_null());
   1125 
   1126   FileResourceCallback completion_callback
   1127       = base::Bind(&ScheduleUploadRangeCallback,
   1128                    callback, start_position, end_position);
   1129 
   1130   if (offline_) {
   1131     completion_callback.Run(GDATA_NO_CONNECTION, scoped_ptr<FileResource>());
   1132     return CancelCallback();
   1133   }
   1134 
   1135   if (!upload_sessions_.count(upload_url)) {
   1136     completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
   1137     return CancelCallback();
   1138   }
   1139 
   1140   UploadSession* session = &upload_sessions_[upload_url];
   1141 
   1142   // Chunks are required to be sent in such a ways that they fill from the start
   1143   // of the not-yet-uploaded part with no gaps nor overlaps.
   1144   if (session->uploaded_size != start_position) {
   1145     completion_callback.Run(HTTP_BAD_REQUEST, scoped_ptr<FileResource>());
   1146     return CancelCallback();
   1147   }
   1148 
   1149   if (!progress_callback.is_null()) {
   1150     // In the real GDataWapi/Drive DriveService, progress is reported in
   1151     // nondeterministic timing. In this fake implementation, we choose to call
   1152     // it twice per one ResumeUpload. This is for making sure that client code
   1153     // works fine even if the callback is invoked more than once; it is the
   1154     // crucial difference of the progress callback from others.
   1155     // Note that progress is notified in the relative offset in each chunk.
   1156     const int64 chunk_size = end_position - start_position;
   1157     base::MessageLoop::current()->PostTask(
   1158         FROM_HERE, base::Bind(progress_callback, chunk_size / 2, chunk_size));
   1159     base::MessageLoop::current()->PostTask(
   1160         FROM_HERE, base::Bind(progress_callback, chunk_size, chunk_size));
   1161   }
   1162 
   1163   if (content_length != end_position) {
   1164     session->uploaded_size = end_position;
   1165     completion_callback.Run(HTTP_RESUME_INCOMPLETE, scoped_ptr<FileResource>());
   1166     return CancelCallback();
   1167   }
   1168 
   1169   std::string content_data;
   1170   if (!base::ReadFileToString(local_file_path, &content_data)) {
   1171     session->uploaded_size = end_position;
   1172     completion_callback.Run(GDATA_FILE_ERROR, scoped_ptr<FileResource>());
   1173     return CancelCallback();
   1174   }
   1175   session->uploaded_size = end_position;
   1176 
   1177   // |resource_id| is empty if the upload is for new file.
   1178   if (session->resource_id.empty()) {
   1179     DCHECK(!session->parent_resource_id.empty());
   1180     DCHECK(!session->title.empty());
   1181     const EntryInfo* new_entry = AddNewEntry(
   1182         "",  // auto generate resource id.
   1183         session->content_type,
   1184         content_data,
   1185         session->parent_resource_id,
   1186         session->title,
   1187         false);  // shared_with_me
   1188     if (!new_entry) {
   1189       completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
   1190       return CancelCallback();
   1191     }
   1192 
   1193     completion_callback.Run(HTTP_CREATED, make_scoped_ptr(
   1194         new FileResource(*new_entry->change_resource.file())));
   1195     base::MessageLoop::current()->PostTask(
   1196         FROM_HERE,
   1197         base::Bind(&FakeDriveService::NotifyObservers,
   1198                    weak_ptr_factory_.GetWeakPtr()));
   1199     return CancelCallback();
   1200   }
   1201 
   1202   EntryInfo* entry = FindEntryByResourceId(session->resource_id);
   1203   if (!entry) {
   1204     completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
   1205     return CancelCallback();
   1206   }
   1207 
   1208   ChangeResource* change = &entry->change_resource;
   1209   FileResource* file = change->mutable_file();
   1210   if (file->etag().empty() || session->etag != file->etag()) {
   1211     completion_callback.Run(HTTP_PRECONDITION, scoped_ptr<FileResource>());
   1212     return CancelCallback();
   1213   }
   1214 
   1215   file->set_md5_checksum(base::MD5String(content_data));
   1216   entry->content_data = content_data;
   1217   file->set_file_size(end_position);
   1218   AddNewChangestamp(change);
   1219   UpdateETag(file);
   1220 
   1221   completion_callback.Run(HTTP_SUCCESS, make_scoped_ptr(
   1222       new FileResource(*file)));
   1223   base::MessageLoop::current()->PostTask(
   1224       FROM_HERE,
   1225       base::Bind(&FakeDriveService::NotifyObservers,
   1226                  weak_ptr_factory_.GetWeakPtr()));
   1227   return CancelCallback();
   1228 }
   1229 
   1230 CancelCallback FakeDriveService::AuthorizeApp(
   1231     const std::string& resource_id,
   1232     const std::string& app_id,
   1233     const AuthorizeAppCallback& callback) {
   1234   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1235   DCHECK(!callback.is_null());
   1236 
   1237   if (entries_.count(resource_id) == 0) {
   1238     callback.Run(google_apis::HTTP_NOT_FOUND, GURL());
   1239     return CancelCallback();
   1240   }
   1241 
   1242   callback.Run(HTTP_SUCCESS,
   1243                GURL(base::StringPrintf(open_url_format_.c_str(),
   1244                                        resource_id.c_str(),
   1245                                        app_id.c_str())));
   1246   return CancelCallback();
   1247 }
   1248 
   1249 CancelCallback FakeDriveService::UninstallApp(
   1250     const std::string& app_id,
   1251     const google_apis::EntryActionCallback& callback) {
   1252   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1253   DCHECK(!callback.is_null());
   1254 
   1255   if (offline_) {
   1256     base::MessageLoop::current()->PostTask(
   1257         FROM_HERE,
   1258         base::Bind(callback, google_apis::GDATA_NO_CONNECTION));
   1259     return CancelCallback();
   1260   }
   1261 
   1262   // Find app_id from app_info_value_ and delete.
   1263   base::ListValue* items = NULL;
   1264   if (!app_info_value_->GetList("items", &items)) {
   1265     base::MessageLoop::current()->PostTask(
   1266         FROM_HERE,
   1267         base::Bind(callback, google_apis::HTTP_NOT_FOUND));
   1268     return CancelCallback();
   1269   }
   1270 
   1271   for (size_t i = 0; i < items->GetSize(); ++i) {
   1272     base::DictionaryValue* item = NULL;
   1273     std::string id;
   1274     if (items->GetDictionary(i, &item) && item->GetString("id", &id) &&
   1275         id == app_id) {
   1276       base::MessageLoop::current()->PostTask(
   1277           FROM_HERE,
   1278           base::Bind(callback,
   1279                      items->Remove(i, NULL) ? google_apis::HTTP_NO_CONTENT
   1280                                             : google_apis::HTTP_NOT_FOUND));
   1281       return CancelCallback();
   1282     }
   1283   }
   1284 
   1285   base::MessageLoop::current()->PostTask(
   1286       FROM_HERE,
   1287       base::Bind(callback, google_apis::HTTP_NOT_FOUND));
   1288   return CancelCallback();
   1289 }
   1290 
   1291 void FakeDriveService::AddNewFile(const std::string& content_type,
   1292                                   const std::string& content_data,
   1293                                   const std::string& parent_resource_id,
   1294                                   const std::string& title,
   1295                                   bool shared_with_me,
   1296                                   const FileResourceCallback& callback) {
   1297   AddNewFileWithResourceId("", content_type, content_data, parent_resource_id,
   1298                            title, shared_with_me, callback);
   1299 }
   1300 
   1301 void FakeDriveService::AddNewFileWithResourceId(
   1302     const std::string& resource_id,
   1303     const std::string& content_type,
   1304     const std::string& content_data,
   1305     const std::string& parent_resource_id,
   1306     const std::string& title,
   1307     bool shared_with_me,
   1308     const FileResourceCallback& callback) {
   1309   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1310   DCHECK(!callback.is_null());
   1311 
   1312   if (offline_) {
   1313     base::MessageLoop::current()->PostTask(
   1314         FROM_HERE,
   1315         base::Bind(callback,
   1316                    GDATA_NO_CONNECTION,
   1317                    base::Passed(scoped_ptr<FileResource>())));
   1318     return;
   1319   }
   1320 
   1321   const EntryInfo* new_entry = AddNewEntry(resource_id,
   1322                                            content_type,
   1323                                            content_data,
   1324                                            parent_resource_id,
   1325                                            title,
   1326                                            shared_with_me);
   1327   if (!new_entry) {
   1328     base::MessageLoop::current()->PostTask(
   1329         FROM_HERE,
   1330         base::Bind(callback, HTTP_NOT_FOUND,
   1331                    base::Passed(scoped_ptr<FileResource>())));
   1332     return;
   1333   }
   1334 
   1335   base::MessageLoop::current()->PostTask(
   1336       FROM_HERE,
   1337       base::Bind(callback, HTTP_CREATED,
   1338                  base::Passed(make_scoped_ptr(
   1339                      new FileResource(*new_entry->change_resource.file())))));
   1340   base::MessageLoop::current()->PostTask(
   1341       FROM_HERE,
   1342       base::Bind(&FakeDriveService::NotifyObservers,
   1343                  weak_ptr_factory_.GetWeakPtr()));
   1344 }
   1345 
   1346 CancelCallback FakeDriveService::AddNewDirectoryWithResourceId(
   1347     const std::string& resource_id,
   1348     const std::string& parent_resource_id,
   1349     const std::string& directory_title,
   1350     const AddNewDirectoryOptions& options,
   1351     const FileResourceCallback& callback) {
   1352   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1353   DCHECK(!callback.is_null());
   1354 
   1355   if (offline_) {
   1356     base::MessageLoop::current()->PostTask(
   1357         FROM_HERE,
   1358         base::Bind(callback,
   1359                    GDATA_NO_CONNECTION,
   1360                    base::Passed(scoped_ptr<FileResource>())));
   1361     return CancelCallback();
   1362   }
   1363 
   1364   const EntryInfo* new_entry = AddNewEntry(resource_id,
   1365                                            util::kDriveFolderMimeType,
   1366                                            "",  // content_data
   1367                                            parent_resource_id,
   1368                                            directory_title,
   1369                                            false);  // shared_with_me
   1370   if (!new_entry) {
   1371     base::MessageLoop::current()->PostTask(
   1372         FROM_HERE,
   1373         base::Bind(callback, HTTP_NOT_FOUND,
   1374                    base::Passed(scoped_ptr<FileResource>())));
   1375     return CancelCallback();
   1376   }
   1377 
   1378   base::MessageLoop::current()->PostTask(
   1379       FROM_HERE,
   1380       base::Bind(callback, HTTP_CREATED,
   1381                  base::Passed(make_scoped_ptr(
   1382                      new FileResource(*new_entry->change_resource.file())))));
   1383   base::MessageLoop::current()->PostTask(
   1384       FROM_HERE,
   1385       base::Bind(&FakeDriveService::NotifyObservers,
   1386                  weak_ptr_factory_.GetWeakPtr()));
   1387   return CancelCallback();
   1388 }
   1389 
   1390 void FakeDriveService::SetLastModifiedTime(
   1391     const std::string& resource_id,
   1392     const base::Time& last_modified_time,
   1393     const FileResourceCallback& callback) {
   1394   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1395   DCHECK(!callback.is_null());
   1396 
   1397   if (offline_) {
   1398     base::MessageLoop::current()->PostTask(
   1399         FROM_HERE,
   1400         base::Bind(callback,
   1401                    GDATA_NO_CONNECTION,
   1402                    base::Passed(scoped_ptr<FileResource>())));
   1403     return;
   1404   }
   1405 
   1406   EntryInfo* entry = FindEntryByResourceId(resource_id);
   1407   if (!entry) {
   1408     base::MessageLoop::current()->PostTask(
   1409         FROM_HERE,
   1410         base::Bind(callback, HTTP_NOT_FOUND,
   1411                    base::Passed(scoped_ptr<FileResource>())));
   1412     return;
   1413   }
   1414 
   1415   ChangeResource* change = &entry->change_resource;
   1416   FileResource* file = change->mutable_file();
   1417   file->set_modified_date(last_modified_time);
   1418 
   1419   base::MessageLoop::current()->PostTask(
   1420       FROM_HERE,
   1421       base::Bind(callback, HTTP_SUCCESS,
   1422                  base::Passed(make_scoped_ptr(new FileResource(*file)))));
   1423 }
   1424 
   1425 google_apis::GDataErrorCode FakeDriveService::SetUserPermission(
   1426     const std::string& resource_id,
   1427     google_apis::drive::PermissionRole user_permission) {
   1428   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1429 
   1430   EntryInfo* entry = FindEntryByResourceId(resource_id);
   1431   if (!entry)
   1432     return HTTP_NOT_FOUND;
   1433 
   1434   entry->user_permission = user_permission;
   1435   return HTTP_SUCCESS;
   1436 }
   1437 
   1438 void FakeDriveService::AddChangeObserver(ChangeObserver* change_observer) {
   1439   change_observers_.AddObserver(change_observer);
   1440 }
   1441 
   1442 void FakeDriveService::RemoveChangeObserver(ChangeObserver* change_observer) {
   1443   change_observers_.RemoveObserver(change_observer);
   1444 }
   1445 
   1446 FakeDriveService::EntryInfo* FakeDriveService::FindEntryByResourceId(
   1447     const std::string& resource_id) {
   1448   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1449 
   1450   EntryInfoMap::iterator it = entries_.find(resource_id);
   1451   // Deleted entries don't have FileResource.
   1452   return it != entries_.end() && it->second->change_resource.file() ?
   1453       it->second : NULL;
   1454 }
   1455 
   1456 std::string FakeDriveService::GetNewResourceId() {
   1457   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1458 
   1459   ++resource_id_count_;
   1460   return base::StringPrintf("resource_id_%d", resource_id_count_);
   1461 }
   1462 
   1463 void FakeDriveService::UpdateETag(google_apis::FileResource* file) {
   1464   file->set_etag(
   1465       "etag_" + base::Int64ToString(about_resource_->largest_change_id()));
   1466 }
   1467 
   1468 void FakeDriveService::AddNewChangestamp(google_apis::ChangeResource* change) {
   1469   about_resource_->set_largest_change_id(
   1470       about_resource_->largest_change_id() + 1);
   1471   change->set_change_id(about_resource_->largest_change_id());
   1472 }
   1473 
   1474 const FakeDriveService::EntryInfo* FakeDriveService::AddNewEntry(
   1475     const std::string& given_resource_id,
   1476     const std::string& content_type,
   1477     const std::string& content_data,
   1478     const std::string& parent_resource_id,
   1479     const std::string& title,
   1480     bool shared_with_me) {
   1481   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1482 
   1483   if (!parent_resource_id.empty() &&
   1484       parent_resource_id != GetRootResourceId() &&
   1485       !entries_.count(parent_resource_id)) {
   1486     return NULL;
   1487   }
   1488 
   1489   const std::string resource_id =
   1490       given_resource_id.empty() ? GetNewResourceId() : given_resource_id;
   1491   if (entries_.count(resource_id))
   1492     return NULL;
   1493   GURL upload_url = GURL("https://xxx/upload/" + resource_id);
   1494 
   1495   scoped_ptr<EntryInfo> new_entry(new EntryInfo);
   1496   ChangeResource* new_change = &new_entry->change_resource;
   1497   FileResource* new_file = new FileResource;
   1498   new_change->set_file(make_scoped_ptr(new_file));
   1499 
   1500   // Set the resource ID and the title
   1501   new_change->set_file_id(resource_id);
   1502   new_file->set_file_id(resource_id);
   1503   new_file->set_title(title);
   1504   // Set the contents, size and MD5 for a file.
   1505   if (content_type != util::kDriveFolderMimeType &&
   1506       !util::IsKnownHostedDocumentMimeType(content_type)) {
   1507     new_entry->content_data = content_data;
   1508     new_file->set_file_size(content_data.size());
   1509     new_file->set_md5_checksum(base::MD5String(content_data));
   1510   }
   1511 
   1512   if (shared_with_me) {
   1513     // Set current time to mark the file as shared_with_me.
   1514     new_file->set_shared_with_me_date(base::Time::Now());
   1515   }
   1516 
   1517   std::string escaped_resource_id = net::EscapePath(resource_id);
   1518 
   1519   // Set mime type.
   1520   new_file->set_mime_type(content_type);
   1521 
   1522   // Set alternate link if needed.
   1523   if (content_type == util::kGoogleDocumentMimeType)
   1524     new_file->set_alternate_link(GURL("https://document_alternate_link"));
   1525 
   1526   // Set parents.
   1527   if (!parent_resource_id.empty()) {
   1528     ParentReference parent;
   1529     parent.set_file_id(parent_resource_id);
   1530     parent.set_parent_link(GetFakeLinkUrl(parent.file_id()));
   1531     std::vector<ParentReference> parents;
   1532     parents.push_back(parent);
   1533     *new_file->mutable_parents() = parents;
   1534   }
   1535 
   1536   new_entry->share_url = net::AppendOrReplaceQueryParameter(
   1537       share_url_base_, "name", title);
   1538 
   1539   AddNewChangestamp(new_change);
   1540   UpdateETag(new_file);
   1541 
   1542   base::Time published_date =
   1543       base::Time() + base::TimeDelta::FromMilliseconds(++published_date_seq_);
   1544   new_file->set_created_date(published_date);
   1545 
   1546   EntryInfo* raw_new_entry = new_entry.release();
   1547   entries_[resource_id] = raw_new_entry;
   1548   return raw_new_entry;
   1549 }
   1550 
   1551 void FakeDriveService::GetChangeListInternal(
   1552     int64 start_changestamp,
   1553     const std::string& search_query,
   1554     const std::string& directory_resource_id,
   1555     int start_offset,
   1556     int max_results,
   1557     int* load_counter,
   1558     const ChangeListCallback& callback) {
   1559   if (offline_) {
   1560     base::MessageLoop::current()->PostTask(
   1561         FROM_HERE,
   1562         base::Bind(callback,
   1563                    GDATA_NO_CONNECTION,
   1564                    base::Passed(scoped_ptr<ChangeList>())));
   1565     return;
   1566   }
   1567 
   1568   // Filter out entries per parameters like |directory_resource_id| and
   1569   // |search_query|.
   1570   ScopedVector<ChangeResource> entries;
   1571   int num_entries_matched = 0;
   1572   for (EntryInfoMap::iterator it = entries_.begin(); it != entries_.end();
   1573        ++it) {
   1574     const ChangeResource& entry = it->second->change_resource;
   1575     bool should_exclude = false;
   1576 
   1577     // If |directory_resource_id| is set, exclude the entry if it's not in
   1578     // the target directory.
   1579     if (!directory_resource_id.empty()) {
   1580       // Get the parent resource ID of the entry.
   1581       std::string parent_resource_id;
   1582       if (entry.file() && !entry.file()->parents().empty())
   1583         parent_resource_id = entry.file()->parents()[0].file_id();
   1584 
   1585       if (directory_resource_id != parent_resource_id)
   1586         should_exclude = true;
   1587     }
   1588 
   1589     // If |search_query| is set, exclude the entry if it does not contain the
   1590     // search query in the title.
   1591     if (!should_exclude && !search_query.empty() &&
   1592         !EntryMatchWithQuery(entry, search_query)) {
   1593       should_exclude = true;
   1594     }
   1595 
   1596     // If |start_changestamp| is set, exclude the entry if the
   1597     // changestamp is older than |largest_changestamp|.
   1598     // See https://developers.google.com/google-apps/documents-list/
   1599     // #retrieving_all_changes_since_a_given_changestamp
   1600     if (start_changestamp > 0 && entry.change_id() < start_changestamp)
   1601       should_exclude = true;
   1602 
   1603     // If the caller requests other list than change list by specifying
   1604     // zero-|start_changestamp|, exclude deleted entry from the result.
   1605     const bool deleted = entry.is_deleted() ||
   1606         (entry.file() && entry.file()->labels().is_trashed());
   1607     if (!start_changestamp && deleted)
   1608       should_exclude = true;
   1609 
   1610     // The entry matched the criteria for inclusion.
   1611     if (!should_exclude)
   1612       ++num_entries_matched;
   1613 
   1614     // If |start_offset| is set, exclude the entry if the entry is before the
   1615     // start index. <= instead of < as |num_entries_matched| was
   1616     // already incremented.
   1617     if (start_offset > 0 && num_entries_matched <= start_offset)
   1618       should_exclude = true;
   1619 
   1620     if (!should_exclude) {
   1621       scoped_ptr<ChangeResource> entry_copied(new ChangeResource);
   1622       entry_copied->set_change_id(entry.change_id());
   1623       entry_copied->set_file_id(entry.file_id());
   1624       entry_copied->set_deleted(entry.is_deleted());
   1625       if (entry.file()) {
   1626         entry_copied->set_file(
   1627             make_scoped_ptr(new FileResource(*entry.file())));
   1628       }
   1629       entry_copied->set_modification_date(entry.modification_date());
   1630       entries.push_back(entry_copied.release());
   1631     }
   1632   }
   1633 
   1634   scoped_ptr<ChangeList> change_list(new ChangeList);
   1635   if (start_changestamp > 0 && start_offset == 0) {
   1636     change_list->set_largest_change_id(about_resource_->largest_change_id());
   1637   }
   1638 
   1639   // If |max_results| is set, trim the entries if the number exceeded the max
   1640   // results.
   1641   if (max_results > 0 && entries.size() > static_cast<size_t>(max_results)) {
   1642     entries.erase(entries.begin() + max_results, entries.end());
   1643     // Adds the next URL.
   1644     // Here, we embed information which is needed for continuing the
   1645     // GetChangeList request in the next invocation into url query
   1646     // parameters.
   1647     GURL next_url(base::StringPrintf(
   1648         "http://localhost/?start-offset=%d&max-results=%d",
   1649         start_offset + max_results,
   1650         max_results));
   1651     if (start_changestamp > 0) {
   1652       next_url = net::AppendOrReplaceQueryParameter(
   1653           next_url, "changestamp",
   1654           base::Int64ToString(start_changestamp).c_str());
   1655     }
   1656     if (!search_query.empty()) {
   1657       next_url = net::AppendOrReplaceQueryParameter(
   1658           next_url, "q", search_query);
   1659     }
   1660     if (!directory_resource_id.empty()) {
   1661       next_url = net::AppendOrReplaceQueryParameter(
   1662           next_url, "parent", directory_resource_id);
   1663     }
   1664 
   1665     change_list->set_next_link(next_url);
   1666   }
   1667   *change_list->mutable_items() = entries.Pass();
   1668 
   1669   if (load_counter)
   1670     *load_counter += 1;
   1671   base::MessageLoop::current()->PostTask(
   1672       FROM_HERE,
   1673       base::Bind(callback, HTTP_SUCCESS, base::Passed(&change_list)));
   1674 }
   1675 
   1676 GURL FakeDriveService::GetNewUploadSessionUrl() {
   1677   return GURL("https://upload_session_url/" +
   1678               base::Int64ToString(next_upload_sequence_number_++));
   1679 }
   1680 
   1681 google_apis::CancelCallback FakeDriveService::AddPermission(
   1682     const std::string& resource_id,
   1683     const std::string& email,
   1684     google_apis::drive::PermissionRole role,
   1685     const google_apis::EntryActionCallback& callback) {
   1686   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1687   DCHECK(!callback.is_null());
   1688 
   1689   NOTREACHED();
   1690   return CancelCallback();
   1691 }
   1692 
   1693 void FakeDriveService::NotifyObservers() {
   1694   FOR_EACH_OBSERVER(ChangeObserver, change_observers_, OnNewChangeAvailable());
   1695 }
   1696 
   1697 }  // namespace drive
   1698