Home | History | Annotate | Download | only in sync 
      1 // Copyright 2013 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/chromeos/drive/sync/entry_update_performer.h"
      6 
      7 #include "base/callback_helpers.h"
      8 #include "base/files/file_util.h"
      9 #include "base/md5.h"
     10 #include "base/task_runner_util.h"
     11 #include "chrome/browser/chromeos/drive/file_cache.h"
     12 #include "chrome/browser/chromeos/drive/file_system/download_operation.h"
     13 #include "chrome/browser/chromeos/drive/file_system/operation_test_base.h"
     14 #include "chrome/browser/chromeos/drive/job_scheduler.h"
     15 #include "chrome/browser/chromeos/drive/resource_metadata.h"
     16 #include "chrome/browser/drive/drive_api_util.h"
     17 #include "chrome/browser/drive/fake_drive_service.h"
     18 #include "content/public/test/test_utils.h"
     19 #include "google_apis/drive/drive_api_parser.h"
     20 #include "google_apis/drive/test_util.h"
     21 #include "testing/gtest/include/gtest/gtest.h"
     22 
     23 namespace drive {
     24 namespace internal {
     25 
     26 class EntryUpdatePerformerTest : public file_system::OperationTestBase {
     27  protected:
     28   virtual void SetUp() OVERRIDE {
     29     OperationTestBase::SetUp();
     30     performer_.reset(new EntryUpdatePerformer(blocking_task_runner(),
     31                                               delegate(),
     32                                               scheduler(),
     33                                               metadata(),
     34                                               cache(),
     35                                               loader_controller()));
     36   }
     37 
     38   // Stores |content| to the cache and mark it as dirty.
     39   FileError StoreAndMarkDirty(const std::string& local_id,
     40                               const std::string& content) {
     41     base::FilePath path;
     42     if (!base::CreateTemporaryFileInDir(temp_dir(), &path) ||
     43         !google_apis::test_util::WriteStringToFile(path, content))
     44       return FILE_ERROR_FAILED;
     45 
     46     // Store the file to cache.
     47     FileError error = FILE_ERROR_FAILED;
     48     base::PostTaskAndReplyWithResult(
     49         blocking_task_runner(),
     50         FROM_HERE,
     51         base::Bind(&FileCache::Store,
     52                    base::Unretained(cache()),
     53                    local_id, std::string(), path,
     54                    FileCache::FILE_OPERATION_COPY),
     55         google_apis::test_util::CreateCopyResultCallback(&error));
     56     content::RunAllBlockingPoolTasksUntilIdle();
     57     return error;
     58   }
     59 
     60   scoped_ptr<EntryUpdatePerformer> performer_;
     61 };
     62 
     63 TEST_F(EntryUpdatePerformerTest, UpdateEntry) {
     64   base::FilePath src_path(
     65       FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
     66   base::FilePath dest_path(
     67       FILE_PATH_LITERAL("drive/root/Directory 1/Sub Directory Folder"));
     68 
     69   ResourceEntry src_entry, dest_entry;
     70   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(src_path, &src_entry));
     71   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(dest_path, &dest_entry));
     72 
     73   // Update local entry.
     74   base::Time new_last_modified = base::Time::FromInternalValue(
     75       src_entry.file_info().last_modified()) + base::TimeDelta::FromSeconds(1);
     76   base::Time new_last_accessed = base::Time::FromInternalValue(
     77       src_entry.file_info().last_accessed()) + base::TimeDelta::FromSeconds(2);
     78 
     79   src_entry.set_parent_local_id(dest_entry.local_id());
     80   src_entry.set_title("Moved" + src_entry.title());
     81   src_entry.mutable_file_info()->set_last_modified(
     82       new_last_modified.ToInternalValue());
     83   src_entry.mutable_file_info()->set_last_accessed(
     84       new_last_accessed.ToInternalValue());
     85   src_entry.set_metadata_edit_state(ResourceEntry::DIRTY);
     86 
     87   FileError error = FILE_ERROR_FAILED;
     88   base::PostTaskAndReplyWithResult(
     89       blocking_task_runner(),
     90       FROM_HERE,
     91       base::Bind(&ResourceMetadata::RefreshEntry,
     92                  base::Unretained(metadata()),
     93                  src_entry),
     94       google_apis::test_util::CreateCopyResultCallback(&error));
     95   content::RunAllBlockingPoolTasksUntilIdle();
     96   EXPECT_EQ(FILE_ERROR_OK, error);
     97 
     98   // Perform server side update.
     99   error = FILE_ERROR_FAILED;
    100   performer_->UpdateEntry(
    101       src_entry.local_id(),
    102       ClientContext(USER_INITIATED),
    103       google_apis::test_util::CreateCopyResultCallback(&error));
    104   content::RunAllBlockingPoolTasksUntilIdle();
    105   EXPECT_EQ(FILE_ERROR_OK, error);
    106 
    107   // Verify the file is updated on the server.
    108   google_apis::GDataErrorCode gdata_error = google_apis::GDATA_OTHER_ERROR;
    109   scoped_ptr<google_apis::FileResource> gdata_entry;
    110   fake_service()->GetFileResource(
    111       src_entry.resource_id(),
    112       google_apis::test_util::CreateCopyResultCallback(&gdata_error,
    113                                                        &gdata_entry));
    114   content::RunAllBlockingPoolTasksUntilIdle();
    115   EXPECT_EQ(google_apis::HTTP_SUCCESS, gdata_error);
    116   ASSERT_TRUE(gdata_entry);
    117 
    118   EXPECT_EQ(src_entry.title(), gdata_entry->title());
    119   EXPECT_EQ(new_last_modified, gdata_entry->modified_date());
    120   EXPECT_EQ(new_last_accessed, gdata_entry->last_viewed_by_me_date());
    121 
    122   ASSERT_FALSE(gdata_entry->parents().empty());
    123   EXPECT_EQ(dest_entry.resource_id(), gdata_entry->parents()[0].file_id());
    124 }
    125 
    126 // Tests updating metadata of a file with a non-dirty cache file.
    127 TEST_F(EntryUpdatePerformerTest, UpdateEntry_WithNonDirtyCache) {
    128   base::FilePath src_path(
    129       FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
    130 
    131   // Download the file content to prepare a non-dirty cache file.
    132   file_system::DownloadOperation download_operation(
    133       blocking_task_runner(), delegate(), scheduler(), metadata(), cache(),
    134       temp_dir());
    135   FileError error = FILE_ERROR_FAILED;
    136   base::FilePath cache_file_path;
    137   scoped_ptr<ResourceEntry> src_entry;
    138   download_operation.EnsureFileDownloadedByPath(
    139       src_path,
    140       ClientContext(USER_INITIATED),
    141       GetFileContentInitializedCallback(),
    142       google_apis::GetContentCallback(),
    143       google_apis::test_util::CreateCopyResultCallback(
    144           &error, &cache_file_path, &src_entry));
    145   content::RunAllBlockingPoolTasksUntilIdle();
    146   EXPECT_EQ(FILE_ERROR_OK, error);
    147   ASSERT_TRUE(src_entry);
    148 
    149   // Update the entry locally.
    150   src_entry->set_title("Updated" + src_entry->title());
    151   src_entry->set_metadata_edit_state(ResourceEntry::DIRTY);
    152 
    153   error = FILE_ERROR_FAILED;
    154   base::PostTaskAndReplyWithResult(
    155       blocking_task_runner(),
    156       FROM_HERE,
    157       base::Bind(&ResourceMetadata::RefreshEntry,
    158                  base::Unretained(metadata()),
    159                  *src_entry),
    160       google_apis::test_util::CreateCopyResultCallback(&error));
    161   content::RunAllBlockingPoolTasksUntilIdle();
    162   EXPECT_EQ(FILE_ERROR_OK, error);
    163 
    164   // Perform server side update. This shouldn't fail. (crbug.com/358590)
    165   error = FILE_ERROR_FAILED;
    166   performer_->UpdateEntry(
    167       src_entry->local_id(),
    168       ClientContext(USER_INITIATED),
    169       google_apis::test_util::CreateCopyResultCallback(&error));
    170   content::RunAllBlockingPoolTasksUntilIdle();
    171   EXPECT_EQ(FILE_ERROR_OK, error);
    172 
    173   // Verify the file is updated on the server.
    174   google_apis::GDataErrorCode gdata_error = google_apis::GDATA_OTHER_ERROR;
    175   scoped_ptr<google_apis::FileResource> gdata_entry;
    176   fake_service()->GetFileResource(
    177       src_entry->resource_id(),
    178       google_apis::test_util::CreateCopyResultCallback(&gdata_error,
    179                                                        &gdata_entry));
    180   content::RunAllBlockingPoolTasksUntilIdle();
    181   EXPECT_EQ(google_apis::HTTP_SUCCESS, gdata_error);
    182   ASSERT_TRUE(gdata_entry);
    183   EXPECT_EQ(src_entry->title(), gdata_entry->title());
    184 }
    185 
    186 TEST_F(EntryUpdatePerformerTest, UpdateEntry_NotFound) {
    187   const std::string id = "this ID should result in NOT_FOUND";
    188   FileError error = FILE_ERROR_FAILED;
    189   performer_->UpdateEntry(
    190       id, ClientContext(USER_INITIATED),
    191       google_apis::test_util::CreateCopyResultCallback(&error));
    192   content::RunAllBlockingPoolTasksUntilIdle();
    193   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
    194 }
    195 
    196 TEST_F(EntryUpdatePerformerTest, UpdateEntry_ContentUpdate) {
    197   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
    198   const std::string kResourceId("2_file_resource_id");
    199 
    200   const std::string local_id = GetLocalId(kFilePath);
    201   EXPECT_FALSE(local_id.empty());
    202 
    203   const std::string kTestFileContent = "I'm being uploaded! Yay!";
    204   EXPECT_EQ(FILE_ERROR_OK, StoreAndMarkDirty(local_id, kTestFileContent));
    205 
    206   int64 original_changestamp =
    207       fake_service()->about_resource().largest_change_id();
    208 
    209   // The callback will be called upon completion of UpdateEntry().
    210   FileError error = FILE_ERROR_FAILED;
    211   performer_->UpdateEntry(
    212       local_id,
    213       ClientContext(USER_INITIATED),
    214       google_apis::test_util::CreateCopyResultCallback(&error));
    215   content::RunAllBlockingPoolTasksUntilIdle();
    216   EXPECT_EQ(FILE_ERROR_OK, error);
    217 
    218   // Check that the server has received an update.
    219   EXPECT_LT(original_changestamp,
    220             fake_service()->about_resource().largest_change_id());
    221 
    222   // Check that the file size is updated to that of the updated content.
    223   google_apis::GDataErrorCode gdata_error = google_apis::GDATA_OTHER_ERROR;
    224   scoped_ptr<google_apis::FileResource> server_entry;
    225   fake_service()->GetFileResource(
    226       kResourceId,
    227       google_apis::test_util::CreateCopyResultCallback(&gdata_error,
    228                                                        &server_entry));
    229   content::RunAllBlockingPoolTasksUntilIdle();
    230   EXPECT_EQ(google_apis::HTTP_SUCCESS, gdata_error);
    231   EXPECT_EQ(static_cast<int64>(kTestFileContent.size()),
    232             server_entry->file_size());
    233 
    234   // Make sure that the cache is no longer dirty.
    235   ResourceEntry entry;
    236   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    237   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
    238 }
    239 
    240 TEST_F(EntryUpdatePerformerTest, UpdateEntry_ContentUpdateMd5Check) {
    241   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
    242   const std::string kResourceId("2_file_resource_id");
    243 
    244   const std::string local_id = GetLocalId(kFilePath);
    245   EXPECT_FALSE(local_id.empty());
    246 
    247   const std::string kTestFileContent = "I'm being uploaded! Yay!";
    248   EXPECT_EQ(FILE_ERROR_OK, StoreAndMarkDirty(local_id, kTestFileContent));
    249 
    250   int64 original_changestamp =
    251       fake_service()->about_resource().largest_change_id();
    252 
    253   // The callback will be called upon completion of UpdateEntry().
    254   FileError error = FILE_ERROR_FAILED;
    255   performer_->UpdateEntry(
    256       local_id,
    257       ClientContext(USER_INITIATED),
    258       google_apis::test_util::CreateCopyResultCallback(&error));
    259   content::RunAllBlockingPoolTasksUntilIdle();
    260   EXPECT_EQ(FILE_ERROR_OK, error);
    261 
    262   // Check that the server has received an update.
    263   EXPECT_LT(original_changestamp,
    264             fake_service()->about_resource().largest_change_id());
    265 
    266   // Check that the file size is updated to that of the updated content.
    267   google_apis::GDataErrorCode gdata_error = google_apis::GDATA_OTHER_ERROR;
    268   scoped_ptr<google_apis::FileResource> server_entry;
    269   fake_service()->GetFileResource(
    270       kResourceId,
    271       google_apis::test_util::CreateCopyResultCallback(&gdata_error,
    272                                                        &server_entry));
    273   content::RunAllBlockingPoolTasksUntilIdle();
    274   EXPECT_EQ(google_apis::HTTP_SUCCESS, gdata_error);
    275   EXPECT_EQ(static_cast<int64>(kTestFileContent.size()),
    276             server_entry->file_size());
    277 
    278   // Make sure that the cache is no longer dirty.
    279   ResourceEntry entry;
    280   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    281   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
    282 
    283   // Again mark the cache file dirty.
    284   scoped_ptr<base::ScopedClosureRunner> file_closer;
    285   error = FILE_ERROR_FAILED;
    286   base::PostTaskAndReplyWithResult(
    287       blocking_task_runner(),
    288       FROM_HERE,
    289       base::Bind(&FileCache::OpenForWrite,
    290                  base::Unretained(cache()),
    291                  local_id,
    292                  &file_closer),
    293       google_apis::test_util::CreateCopyResultCallback(&error));
    294   content::RunAllBlockingPoolTasksUntilIdle();
    295   EXPECT_EQ(FILE_ERROR_OK, error);
    296   file_closer.reset();
    297 
    298   // And call UpdateEntry again.
    299   // In this case, although the file is marked as dirty, but the content
    300   // hasn't been changed. Thus, the actual uploading should be skipped.
    301   original_changestamp = fake_service()->about_resource().largest_change_id();
    302   error = FILE_ERROR_FAILED;
    303   performer_->UpdateEntry(
    304       local_id,
    305       ClientContext(USER_INITIATED),
    306       google_apis::test_util::CreateCopyResultCallback(&error));
    307   content::RunAllBlockingPoolTasksUntilIdle();
    308   EXPECT_EQ(FILE_ERROR_OK, error);
    309 
    310   EXPECT_EQ(original_changestamp,
    311             fake_service()->about_resource().largest_change_id());
    312 
    313   // Make sure that the cache is no longer dirty.
    314   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    315   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
    316 }
    317 
    318 TEST_F(EntryUpdatePerformerTest, UpdateEntry_OpenedForWrite) {
    319   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
    320   const std::string kResourceId("2_file_resource_id");
    321 
    322   const std::string local_id = GetLocalId(kFilePath);
    323   EXPECT_FALSE(local_id.empty());
    324 
    325   const std::string kTestFileContent = "I'm being uploaded! Yay!";
    326   EXPECT_EQ(FILE_ERROR_OK, StoreAndMarkDirty(local_id, kTestFileContent));
    327 
    328   // Emulate a situation where someone is writing to the file.
    329   scoped_ptr<base::ScopedClosureRunner> file_closer;
    330   FileError error = FILE_ERROR_FAILED;
    331   base::PostTaskAndReplyWithResult(
    332       blocking_task_runner(),
    333       FROM_HERE,
    334       base::Bind(&FileCache::OpenForWrite,
    335                  base::Unretained(cache()),
    336                  local_id,
    337                  &file_closer),
    338       google_apis::test_util::CreateCopyResultCallback(&error));
    339   content::RunAllBlockingPoolTasksUntilIdle();
    340   EXPECT_EQ(FILE_ERROR_OK, error);
    341 
    342   // Update. This should not clear the dirty bit.
    343   error = FILE_ERROR_FAILED;
    344   performer_->UpdateEntry(
    345       local_id,
    346       ClientContext(USER_INITIATED),
    347       google_apis::test_util::CreateCopyResultCallback(&error));
    348   content::RunAllBlockingPoolTasksUntilIdle();
    349   EXPECT_EQ(FILE_ERROR_OK, error);
    350 
    351   // Make sure that the cache is still dirty.
    352   ResourceEntry entry;
    353   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    354   EXPECT_TRUE(entry.file_specific_info().cache_state().is_dirty());
    355 
    356   // Close the file.
    357   file_closer.reset();
    358 
    359   // Update. This should clear the dirty bit.
    360   error = FILE_ERROR_FAILED;
    361   performer_->UpdateEntry(
    362       local_id,
    363       ClientContext(USER_INITIATED),
    364       google_apis::test_util::CreateCopyResultCallback(&error));
    365   content::RunAllBlockingPoolTasksUntilIdle();
    366   EXPECT_EQ(FILE_ERROR_OK, error);
    367 
    368   // Make sure that the cache is no longer dirty.
    369   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    370   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
    371 }
    372 
    373 TEST_F(EntryUpdatePerformerTest, UpdateEntry_UploadNewFile) {
    374   // Create a new file locally.
    375   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/New File.txt"));
    376 
    377   ResourceEntry parent;
    378   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath.DirName(), &parent));
    379 
    380   ResourceEntry entry;
    381   entry.set_parent_local_id(parent.local_id());
    382   entry.set_title(kFilePath.BaseName().AsUTF8Unsafe());
    383   entry.mutable_file_specific_info()->set_content_mime_type("text/plain");
    384   entry.set_metadata_edit_state(ResourceEntry::DIRTY);
    385 
    386   FileError error = FILE_ERROR_FAILED;
    387   std::string local_id;
    388   base::PostTaskAndReplyWithResult(
    389       blocking_task_runner(),
    390       FROM_HERE,
    391       base::Bind(&internal::ResourceMetadata::AddEntry,
    392                  base::Unretained(metadata()),
    393                  entry,
    394                  &local_id),
    395       google_apis::test_util::CreateCopyResultCallback(&error));
    396   content::RunAllBlockingPoolTasksUntilIdle();
    397   EXPECT_EQ(FILE_ERROR_OK, error);
    398 
    399   // Update. This should result in creating a new file on the server.
    400   error = FILE_ERROR_FAILED;
    401   performer_->UpdateEntry(
    402       local_id,
    403       ClientContext(USER_INITIATED),
    404       google_apis::test_util::CreateCopyResultCallback(&error));
    405   content::RunAllBlockingPoolTasksUntilIdle();
    406   EXPECT_EQ(FILE_ERROR_OK, error);
    407 
    408   // The entry got a resource ID.
    409   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    410   EXPECT_FALSE(entry.resource_id().empty());
    411   EXPECT_EQ(ResourceEntry::CLEAN, entry.metadata_edit_state());
    412 
    413   // Make sure that the cache is no longer dirty.
    414   EXPECT_FALSE(entry.file_specific_info().cache_state().is_dirty());
    415 
    416   // Make sure that we really created a file.
    417   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
    418   scoped_ptr<google_apis::FileResource> server_entry;
    419   fake_service()->GetFileResource(
    420       entry.resource_id(),
    421       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
    422   content::RunAllBlockingPoolTasksUntilIdle();
    423   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
    424   ASSERT_TRUE(server_entry);
    425   EXPECT_FALSE(server_entry->IsDirectory());
    426 }
    427 
    428 TEST_F(EntryUpdatePerformerTest, UpdateEntry_NewFileOpendForWrite) {
    429   // Create a new file locally.
    430   const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/New File.txt"));
    431 
    432   ResourceEntry parent;
    433   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath.DirName(), &parent));
    434 
    435   ResourceEntry entry;
    436   entry.set_parent_local_id(parent.local_id());
    437   entry.set_title(kFilePath.BaseName().AsUTF8Unsafe());
    438   entry.mutable_file_specific_info()->set_content_mime_type("text/plain");
    439   entry.set_metadata_edit_state(ResourceEntry::DIRTY);
    440 
    441   FileError error = FILE_ERROR_FAILED;
    442   std::string local_id;
    443   base::PostTaskAndReplyWithResult(
    444       blocking_task_runner(),
    445       FROM_HERE,
    446       base::Bind(&internal::ResourceMetadata::AddEntry,
    447                  base::Unretained(metadata()),
    448                  entry,
    449                  &local_id),
    450       google_apis::test_util::CreateCopyResultCallback(&error));
    451   content::RunAllBlockingPoolTasksUntilIdle();
    452   EXPECT_EQ(FILE_ERROR_OK, error);
    453 
    454   const std::string kTestFileContent = "This is a new file.";
    455   EXPECT_EQ(FILE_ERROR_OK, StoreAndMarkDirty(local_id, kTestFileContent));
    456 
    457   // Emulate a situation where someone is writing to the file.
    458   scoped_ptr<base::ScopedClosureRunner> file_closer;
    459   error = FILE_ERROR_FAILED;
    460   base::PostTaskAndReplyWithResult(
    461       blocking_task_runner(),
    462       FROM_HERE,
    463       base::Bind(&FileCache::OpenForWrite,
    464                  base::Unretained(cache()),
    465                  local_id,
    466                  &file_closer),
    467       google_apis::test_util::CreateCopyResultCallback(&error));
    468   content::RunAllBlockingPoolTasksUntilIdle();
    469   EXPECT_EQ(FILE_ERROR_OK, error);
    470 
    471   // Update, but no update is performed because the file is opened.
    472   error = FILE_ERROR_FAILED;
    473   performer_->UpdateEntry(
    474       local_id,
    475       ClientContext(USER_INITIATED),
    476       google_apis::test_util::CreateCopyResultCallback(&error));
    477   content::RunAllBlockingPoolTasksUntilIdle();
    478   EXPECT_EQ(FILE_ERROR_OK, error);
    479 
    480   // The entry hasn't got a resource ID yet.
    481   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    482   EXPECT_TRUE(entry.resource_id().empty());
    483 
    484   // Close the file.
    485   file_closer.reset();
    486 
    487   // Update. This should result in creating a new file on the server.
    488   error = FILE_ERROR_FAILED;
    489   performer_->UpdateEntry(
    490       local_id,
    491       ClientContext(USER_INITIATED),
    492       google_apis::test_util::CreateCopyResultCallback(&error));
    493   content::RunAllBlockingPoolTasksUntilIdle();
    494   EXPECT_EQ(FILE_ERROR_OK, error);
    495 
    496   // The entry got a resource ID.
    497   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kFilePath, &entry));
    498   EXPECT_FALSE(entry.resource_id().empty());
    499   EXPECT_EQ(ResourceEntry::CLEAN, entry.metadata_edit_state());
    500 }
    501 
    502 TEST_F(EntryUpdatePerformerTest, UpdateEntry_CreateDirectory) {
    503   // Create a new directory locally.
    504   const base::FilePath kPath(FILE_PATH_LITERAL("drive/root/New Directory"));
    505 
    506   ResourceEntry parent;
    507   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kPath.DirName(), &parent));
    508 
    509   ResourceEntry entry;
    510   entry.set_parent_local_id(parent.local_id());
    511   entry.set_title(kPath.BaseName().AsUTF8Unsafe());
    512   entry.mutable_file_info()->set_is_directory(true);
    513   entry.set_metadata_edit_state(ResourceEntry::DIRTY);
    514 
    515   FileError error = FILE_ERROR_FAILED;
    516   std::string local_id;
    517   base::PostTaskAndReplyWithResult(
    518       blocking_task_runner(),
    519       FROM_HERE,
    520       base::Bind(&internal::ResourceMetadata::AddEntry,
    521                  base::Unretained(metadata()),
    522                  entry,
    523                  &local_id),
    524       google_apis::test_util::CreateCopyResultCallback(&error));
    525   content::RunAllBlockingPoolTasksUntilIdle();
    526   EXPECT_EQ(FILE_ERROR_OK, error);
    527 
    528   // Update. This should result in creating a new directory on the server.
    529   error = FILE_ERROR_FAILED;
    530   performer_->UpdateEntry(
    531       local_id,
    532       ClientContext(USER_INITIATED),
    533       google_apis::test_util::CreateCopyResultCallback(&error));
    534   content::RunAllBlockingPoolTasksUntilIdle();
    535   EXPECT_EQ(FILE_ERROR_OK, error);
    536 
    537   // The entry got a resource ID.
    538   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(kPath, &entry));
    539   EXPECT_FALSE(entry.resource_id().empty());
    540   EXPECT_EQ(ResourceEntry::CLEAN, entry.metadata_edit_state());
    541 
    542   // Make sure that we really created a directory.
    543   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
    544   scoped_ptr<google_apis::FileResource> server_entry;
    545   fake_service()->GetFileResource(
    546       entry.resource_id(),
    547       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
    548   content::RunAllBlockingPoolTasksUntilIdle();
    549   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
    550   ASSERT_TRUE(server_entry);
    551   EXPECT_TRUE(server_entry->IsDirectory());
    552 }
    553 
    554 TEST_F(EntryUpdatePerformerTest, UpdateEntry_InsufficientPermission) {
    555   base::FilePath src_path(
    556       FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
    557 
    558   ResourceEntry src_entry;
    559   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(src_path, &src_entry));
    560 
    561   // Update local entry.
    562   ResourceEntry updated_entry(src_entry);
    563   updated_entry.set_title("Moved" + src_entry.title());
    564   updated_entry.set_metadata_edit_state(ResourceEntry::DIRTY);
    565 
    566   FileError error = FILE_ERROR_FAILED;
    567   base::PostTaskAndReplyWithResult(
    568       blocking_task_runner(),
    569       FROM_HERE,
    570       base::Bind(&ResourceMetadata::RefreshEntry,
    571                  base::Unretained(metadata()),
    572                  updated_entry),
    573       google_apis::test_util::CreateCopyResultCallback(&error));
    574   content::RunAllBlockingPoolTasksUntilIdle();
    575   EXPECT_EQ(FILE_ERROR_OK, error);
    576 
    577   // Set user permission to forbid server side update.
    578   EXPECT_EQ(google_apis::HTTP_SUCCESS, fake_service()->SetUserPermission(
    579       src_entry.resource_id(), google_apis::drive::PERMISSION_ROLE_READER));
    580 
    581   // Try to perform update.
    582   error = FILE_ERROR_FAILED;
    583   performer_->UpdateEntry(
    584       src_entry.local_id(),
    585       ClientContext(USER_INITIATED),
    586       google_apis::test_util::CreateCopyResultCallback(&error));
    587   content::RunAllBlockingPoolTasksUntilIdle();
    588   EXPECT_EQ(FILE_ERROR_OK, error);
    589 
    590   // This should result in reverting the local change.
    591   ResourceEntry result_entry;
    592   EXPECT_EQ(FILE_ERROR_OK,
    593             GetLocalResourceEntryById(src_entry.local_id(), &result_entry));
    594   EXPECT_EQ(src_entry.title(), result_entry.title());
    595 }
    596 
    597 }  // namespace internal
    598 }  // namespace drive
    599