Reland: Create hard links in file migration if necessary.

components/drive/file_cache.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/drive/file_cache.h"
 
+#include <unistd.h>
+
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 657 matching lines @@
     const std::string& id = GetIdFromPath(new_path);
     new_path = GetCacheFilePath(util::CanonicalizeResourceId(id));
     if (new_path != current && !base::Move(current, new_path))
       return false;
   }
   return true;
 }
 
 // static
 bool FileCache::MigrateCacheFiles(const base::FilePath& from,
-                                  const base::FilePath& to,
+                                  const base::FilePath& to_files,
+                                  const base::FilePath& to_links,
                                   ResourceMetadataStorage* metadata_storage) {
   scoped_ptr<ResourceMetadataStorage::Iterator> it =
       metadata_storage->GetIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
     const ResourceEntry& entry = it->GetValue();
     if (!entry.file_specific_info().cache_state().is_present()) {
       continue;
     }
 
+    // Ignore missing cache file case since it never succeeds.
+    // TODO(yawano): handle this case at metadata validation in FileCache.
     const base::FilePath move_from = GetPathForId(from, entry.local_id());
     if (!base::PathExists(move_from)) {
       continue;
     }
 
-    const base::FilePath move_to = GetPathForId(to, entry.local_id());
+    // Create hard link to cache file if it's pinned or dirty. cryptohome will
+    // not delete a cache file if there is a hard link to it.
+    const FileCacheEntry& file_cache_entry =
+        entry.file_specific_info().cache_state();
+    if (file_cache_entry.is_pinned() || file_cache_entry.is_dirty()) {
+      const base::FilePath link_path = GetPathForId(to_links, entry.local_id());
+      int link_result = link(move_from.AsUTF8Unsafe().c_str(),
+                             link_path.AsUTF8Unsafe().c_str());
+      if (link_result != 0 && errno != EEXIST) {
+        return false;
+      }
+    }
+
+    // Move cache file.
+    const base::FilePath move_to = GetPathForId(to_files, entry.local_id());
     if (!base::Move(move_from, move_to)) {
       return false;
     }
-
-    // TODO(yawano): create hard link if entry is marked as pinned or dirty.
   }
 
   return true;
 }
 
 void FileCache::CloseForWrite(const std::string& id) {
   AssertOnSequencedWorkerPool();
 
   std::map<std::string, int>::iterator it = write_opened_files_.find(id);
   if (it == write_opened_files_.end())
@@ skipping 23 matching lines @@
 
 bool FileCache::IsEvictable(const std::string& id, const ResourceEntry& entry) {
   return entry.file_specific_info().has_cache_state() &&
          !entry.file_specific_info().cache_state().is_pinned() &&
          !entry.file_specific_info().cache_state().is_dirty() &&
          !mounted_files_.count(id);
 }
 
 }  // namespace internal
 }  // namespace drive