chrome/browser/sync_file_system/fake_remote_change_processor.cc

   1 // Copyright (c) 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/sync_file_system/fake_remote_change_processor.h"
   6
   7 #include "base/bind.h"
   8 #include "base/files/file_path.h"
   9 #include "base/location.h"
  10 #include "base/single_thread_task_runner.h"
  11 #include "base/thread_task_runner_handle.h"
  12 #include "chrome/browser/sync_file_system/file_change.h"
  13 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
  14 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
  15 #include "storage/browser/fileapi/file_system_url.h"
  16 #include "storage/common/fileapi/file_system_util.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace sync_file_system {
  20
  21 FakeRemoteChangeProcessor::FakeRemoteChangeProcessor() {
  22 }
  23
  24 FakeRemoteChangeProcessor::~FakeRemoteChangeProcessor() {
  25 }
  26
  27 void FakeRemoteChangeProcessor::PrepareForProcessRemoteChange(
  28     const storage::FileSystemURL& url,
  29     const PrepareChangeCallback& callback) {
  30   SyncFileMetadata local_metadata;
  31
  32   if (storage::VirtualPath::IsRootPath(url.path())) {
  33     // Origin root directory case.
  34     local_metadata = SyncFileMetadata(
  35         SYNC_FILE_TYPE_DIRECTORY, 0, base::Time::Now());
  36   }
  37
  38   URLToFileMetadata::iterator found_metadata = local_file_metadata_.find(url);
  39   if (found_metadata != local_file_metadata_.end())
  40     local_metadata = found_metadata->second;
  41
  42   // Override |local_metadata| by applied changes.
  43   URLToFileChangesMap::iterator found = applied_changes_.find(url);
  44   if (found != applied_changes_.end()) {
  45     DCHECK(!found->second.empty());
  46     const FileChange& applied_change = found->second.back();
  47     if (applied_change.IsAddOrUpdate()) {
  48       local_metadata = SyncFileMetadata(
  49           applied_change.file_type(),
  50           100 /* size */,
  51           base::Time::Now());
  52     }
  53   }
  54
  55   FileChangeList change_list;
  56   URLToFileChangeList::iterator found_list = local_changes_.find(url);
  57   if (found_list != local_changes_.end())
  58     change_list = found_list->second;
  59
  60   base::ThreadTaskRunnerHandle::Get()->PostTask(
  61       FROM_HERE,
  62       base::Bind(callback, SYNC_STATUS_OK,
  63                  local_metadata, change_list));
  64 }
  65
  66 void FakeRemoteChangeProcessor::ApplyRemoteChange(
  67     const FileChange& change,
  68     const base::FilePath& local_path,
  69     const storage::FileSystemURL& url,
  70     const SyncStatusCallback& callback) {
  71   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
  72   base::FilePath ancestor = storage::VirtualPath::DirName(url.path());
  73   while (true) {
  74     storage::FileSystemURL ancestor_url =
  75         CreateSyncableFileSystemURL(url.origin(), ancestor);
  76     if (!ancestor_url.is_valid())
  77       break;
  78
  79     URLToFileChangeList::iterator found_list =
  80         local_changes_.find(ancestor_url);
  81     if (found_list != local_changes_.end()) {
  82       const FileChange& local_change = found_list->second.back();
  83       if (local_change.IsAddOrUpdate() &&
  84           local_change.file_type() != SYNC_FILE_TYPE_DIRECTORY) {
  85         status = SYNC_FILE_ERROR_NOT_A_DIRECTORY;
  86         break;
  87       }
  88     }
  89
  90     base::FilePath ancestor_parent = storage::VirtualPath::DirName(ancestor);
  91     if (ancestor == ancestor_parent)
  92       break;
  93     ancestor = ancestor_parent;
  94   }
  95   if (status == SYNC_STATUS_UNKNOWN) {
  96     applied_changes_[url].push_back(change);
  97     status = SYNC_STATUS_OK;
  98   }
  99   base::ThreadTaskRunnerHandle::Get()->PostTask(
 100       FROM_HERE, base::Bind(callback, status));
 101 }
 102
 103 void FakeRemoteChangeProcessor::FinalizeRemoteSync(
 104     const storage::FileSystemURL& url,
 105     bool clear_local_changes,
 106     const base::Closure& completion_callback) {
 107   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, completion_callback);
 108 }
 109
 110 void FakeRemoteChangeProcessor::RecordFakeLocalChange(
 111     const storage::FileSystemURL& url,
 112     const FileChange& change,
 113     const SyncStatusCallback& callback) {
 114   local_changes_[url].Update(change);
 115   base::ThreadTaskRunnerHandle::Get()->PostTask(
 116       FROM_HERE, base::Bind(callback, SYNC_STATUS_OK));
 117 }
 118
 119 void FakeRemoteChangeProcessor::UpdateLocalFileMetadata(
 120     const storage::FileSystemURL& url,
 121     const FileChange& change) {
 122   if (change.IsAddOrUpdate()) {
 123     local_file_metadata_[url] = SyncFileMetadata(
 124         change.file_type(), 100 /* size */, base::Time::Now());
 125   } else {
 126     local_file_metadata_.erase(url);
 127   }
 128   local_changes_[url].Update(change);
 129 }
 130
 131 void FakeRemoteChangeProcessor::ClearLocalChanges(
 132     const storage::FileSystemURL& url) {
 133   local_changes_.erase(url);
 134 }
 135
 136 const FakeRemoteChangeProcessor::URLToFileChangesMap&
 137 FakeRemoteChangeProcessor::GetAppliedRemoteChanges() const {
 138   return applied_changes_;
 139 }
 140
 141 void FakeRemoteChangeProcessor::VerifyConsistency(
 142     const URLToFileChangesMap& expected_changes) {
 143   EXPECT_EQ(expected_changes.size(), applied_changes_.size());
 144   for (URLToFileChangesMap::const_iterator itr = applied_changes_.begin();
 145        itr != applied_changes_.end(); ++itr) {
 146     const storage::FileSystemURL& url = itr->first;
 147     URLToFileChangesMap::const_iterator found = expected_changes.find(url);
 148     if (found == expected_changes.end()) {
 149       EXPECT_TRUE(found != expected_changes.end())
 150           << "Change not expected for " << url.DebugString();
 151       continue;
 152     }
 153
 154     const std::vector<FileChange>& applied = itr->second;
 155     const std::vector<FileChange>& expected = found->second;
 156
 157     if (applied.empty() || expected.empty()) {
 158       EXPECT_TRUE(!applied.empty());
 159       EXPECT_TRUE(!expected.empty());
 160       continue;
 161     }
 162
 163     EXPECT_EQ(expected.size(), applied.size());
 164
 165     for (size_t i = 0; i < applied.size() && i < expected.size(); ++i) {
 166       EXPECT_EQ(expected[i], applied[i])
 167           << url.DebugString()
 168           << " expected:" << expected[i].DebugString()
 169           << " applied:" << applied[i].DebugString();
 170     }
 171   }
 172 }
 173
 174 }  // namespace sync_file_system