Revert 144115 - Manage IsolatedContext with reference counts

webkit/fileapi/isolated_context.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 "webkit/fileapi/isolated_context.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 11 matching lines @@
 
 std::string IsolatedContext::RegisterIsolatedFileSystem(
     const std::set<FilePath>& files) {
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
   // Stores basename to fullpath map, as we store the basenames as
   // the filesystem's toplevel entries.
   PathMap toplevels;
   for (std::set<FilePath>::const_iterator iter = files.begin();
        iter != files.end(); ++iter) {
-    // The given path should not contain any '..' and must be an absolute path.
-    DCHECK(!iter->ReferencesParent() && iter->IsAbsolute());
+    // If the given path contains any '..' or is not an absolute path,
+    // return an empty (invalid) id.
+    if (iter->ReferencesParent() || !iter->IsAbsolute())
+      return std::string();
 
     // Register the basename -> fullpath map. (We only expose the basename
     // part to the user scripts)
     FilePath fullpath = iter->NormalizePathSeparators();
     FilePath basename = iter->BaseName();
     // TODO(kinuko): Append a suffix or something if we have multiple pathnames
     // with the same basename. For now we only register the first one.
     toplevels.insert(std::make_pair(basename, fullpath));
   }
   toplevel_map_[filesystem_id] = toplevels;
-
-  // Each file system is created with refcount == 0.
-  ref_counts_[filesystem_id] = 0;
-
   return filesystem_id;
 }
 
+// Revoke any registered drag context for the child_id.
 void IsolatedContext::RevokeIsolatedFileSystem(
     const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
-  RevokeWithoutLocking(filesystem_id);
-}
-
-void IsolatedContext::AddReference(const std::string& filesystem_id) {
-  base::AutoLock locker(lock_);
-  DCHECK(ref_counts_.find(filesystem_id) != ref_counts_.end());
-  ref_counts_[filesystem_id]++;
-}
-
-void IsolatedContext::RemoveReference(const std::string& filesystem_id) {
-  base::AutoLock locker(lock_);
-  // This could get called for non-existent filesystem if it has been
-  // already deleted by RevokeIsolatedFileSystem.
-  if (ref_counts_.find(filesystem_id) == ref_counts_.end())
-    return;
-  DCHECK(ref_counts_[filesystem_id] > 0);
-  if (--ref_counts_[filesystem_id] == 0)
-    RevokeWithoutLocking(filesystem_id);
+  toplevel_map_.erase(filesystem_id);
+  writable_ids_.erase(filesystem_id);
 }
 
 bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
                                         std::string* filesystem_id,
                                         FilePath* root_path,
                                         FilePath* platform_path) const {
   DCHECK(filesystem_id);
   DCHECK(platform_path);
 
   // This should not contain any '..' references.
@@ skipping 75 matching lines @@
     full_path = full_path.Append(relative_path);
   return full_path;
 }
 
 IsolatedContext::IsolatedContext() {
 }
 
 IsolatedContext::~IsolatedContext() {
 }
 
-void IsolatedContext::RevokeWithoutLocking(
-    const std::string& filesystem_id) {
-  toplevel_map_.erase(filesystem_id);
-  writable_ids_.erase(filesystem_id);
-  ref_counts_.erase(filesystem_id);
-}
-
 std::string IsolatedContext::GetNewFileSystemId() const {
   // Returns an arbitrary random string which must be unique in the map.
   uint32 random_data[4];
   std::string id;
   do {
     base::RandBytes(random_data, sizeof(random_data));
     id = base::HexEncode(random_data, sizeof(random_data));
   } while (toplevel_map_.find(id) != toplevel_map_.end());
   return id;
 }
 
 }  // namespace fileapi