Make Isolated file system writable only if it is configured so

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 33 matching lines @@
   }
   toplevel_map_[filesystem_id] = toplevels;
   return filesystem_id;
 }
 
 // Revoke any registered drag context for the child_id.
 void IsolatedContext::RevokeIsolatedFileSystem(
     const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
   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 26 matching lines @@
   FilePath path = found->second;
   if (root_path)
     *root_path = path;
   for (size_t i = 2; i < components.size(); ++i) {
     path = path.Append(components[i]);
   }
   *platform_path = path;
   return true;
 }
 
-bool IsolatedContext::GetTopLevelPaths(std::string filesystem_id,
+bool IsolatedContext::GetTopLevelPaths(const std::string& filesystem_id,
                                        std::vector<FilePath>* paths) const {
   DCHECK(paths);
   base::AutoLock locker(lock_);
   IDToPathMap::const_iterator found = toplevel_map_.find(filesystem_id);
   if (found == toplevel_map_.end())
     return false;
   paths->clear();
   PathMap toplevels = found->second;
   for (PathMap::const_iterator iter = toplevels.begin();
        iter != toplevels.end(); ++iter) {
     // Each path map entry holds a map of a toplevel name to its full path.
     paths->push_back(iter->second);
   }
   return true;
 }
 
+bool IsolatedContext::SetWritable(const std::string& filesystem_id,
+                                  bool writable) {
+  base::AutoLock locker(lock_);
+  if (toplevel_map_.find(filesystem_id) == toplevel_map_.end())
+    return false;
+  if (writable)
+    writable_ids_.insert(filesystem_id);
+  else
+    writable_ids_.erase(filesystem_id);
+  return true;
+}
+
+bool IsolatedContext::IsWritable(const std::string& filesystem_id) const {
+  base::AutoLock locker(lock_);
+  return (writable_ids_.find(filesystem_id) != writable_ids_.end());
+}
+
 FilePath IsolatedContext::CreateVirtualPath(
     const std::string& filesystem_id, const FilePath& relative_path) const {
   FilePath full_path;
   full_path = full_path.AppendASCII(filesystem_id);
   if (relative_path.value() != FILE_PATH_LITERAL("/"))
     full_path = full_path.Append(relative_path);
   return full_path;
 }
 
 IsolatedContext::IsolatedContext() {
 }
 
 IsolatedContext::~IsolatedContext() {
 }
 
 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