[Storage] Normalize storage partition path before garbage collection

content/browser/storage_partition_impl_map.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 "content/browser/storage_partition_impl_map.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
@@ skipping 248 matching lines @@
   // |valid_paths_to_keep|.
   std::vector<base::FilePath> paths_to_consider;
   paths_to_consider.push_back(root);
   while(!paths_to_consider.empty()) {
     base::FilePath path = paths_to_consider.back();
     paths_to_consider.pop_back();
     ObliterateOneDirectory(path, valid_paths_to_keep, &paths_to_consider);
   }
 }
 
+// Ensures each path in |active_paths| is a direct child of storage_root.
+void NormalizeActivePaths(const base::FilePath& storage_root,
+                          base::hash_set<base::FilePath>* active_paths) {
+  base::hash_set<base::FilePath> normalized_active_paths;
+
+  for (base::hash_set<base::FilePath>::iterator iter = active_paths->begin();
+       iter != active_paths->end(); ++iter) {
+    base::FilePath relative_path;
+    if (!storage_root.AppendRelativePath(*iter, &relative_path))
+      continue;
+
+    std::vector<base::FilePath::StringType> components;
+    relative_path.GetComponents(&components);
+
+    DCHECK(!relative_path.empty());
+    normalized_active_paths.insert(storage_root.Append(components.front()));
+  }
+
+  active_paths->swap(normalized_active_paths);
+}
+
 // Deletes all entries inside the |storage_root| that are not in the
 // |active_paths|.  Deletion is done in 2 steps:
 //
 //   (1) Moving all garbage collected paths into a trash directory.
 //   (2) Asynchronously deleting the trash directory.
 //
 // The deletion is asynchronous because after (1) completes, calling code can
 // safely continue to use the paths that had just been garbage collected
 // without fear of race conditions.
 //
 // This code also ignores failed moves rather than attempting a smarter retry.
 // Moves shouldn't fail here unless there is some out-of-band error (eg.,
 // FS corruption). Retry logic is dangerous in the general case because
 // there is not necessarily a guaranteed case where the logic may succeed.
 //
 // This function is still named BlockingGarbageCollect() because it does
 // execute a few filesystem operations synchronously.
 void BlockingGarbageCollect(
     const base::FilePath& storage_root,
     const scoped_refptr<base::TaskRunner>& file_access_runner,
     scoped_ptr<base::hash_set<base::FilePath> > active_paths) {
   CHECK(storage_root.IsAbsolute());
 
+  NormalizeActivePaths(storage_root, active_paths.get());
+
   base::FileEnumerator enumerator(storage_root, false, kAllFileTypes);
   base::FilePath trash_directory;
   if (!base::CreateTemporaryDirInDir(storage_root, kTrashDirname,
                                      &trash_directory)) {
     // Unable to continue without creating the trash directory so give up.
     return;
   }
   for (base::FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
     if (active_paths->find(path) == active_paths->end() &&
@@ skipping 259 matching lines @@
 
     // We do not call InitializeURLRequestContext() for media contexts because,
     // other than the HTTP cache, the media contexts share the same backing
     // objects as their associated "normal" request context.  Thus, the previous
     // call serves to initialize the media request context for this storage
     // partition as well.
   }
 }
 
 }  // namespace content