Add a path for a web page to request the enumeration of a directory. This, t...

content/browser/child_process_security_policy.cc

 // Copyright (c) 2011 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/child_process_security_policy.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/common/bindings_policy.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request.h"
 
 static const int kReadFilePermissions =
     base::PLATFORM_FILE_OPEN |
     base::PLATFORM_FILE_READ |
     base::PLATFORM_FILE_EXCLUSIVE_READ |
     base::PLATFORM_FILE_ASYNC;
 
+static const int kEnumerateDirectoryPermissions =
+    kReadFilePermissions |
+    base::PLATFORM_FILE_ENUMERATE;
+
 // The SecurityState class is used to maintain per-child process security state
 // information.
 class ChildProcessSecurityPolicy::SecurityState {
  public:
   SecurityState()
     : enabled_bindings_(0),
       can_read_raw_cookies_(false) { }
   ~SecurityState() {
     scheme_policy_.clear();
   }
@@ skipping 201 matching lines @@
     // grant it the capability to request URLs of that scheme.
     state->second->GrantScheme(url.scheme());
   }
 }
 
 void ChildProcessSecurityPolicy::GrantReadFile(int child_id,
                                                const FilePath& file) {
   GrantPermissionsForFile(child_id, file, kReadFilePermissions);
 }
 
+void ChildProcessSecurityPolicy::GrantReadDirectory(int child_id,
+                                                    const FilePath& directory) {
+  GrantPermissionsForFile(child_id, directory, kEnumerateDirectoryPermissions);
+}
+
 void ChildProcessSecurityPolicy::GrantPermissionsForFile(
     int child_id, const FilePath& file, int permissions) {
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantPermissionsForFile(file, permissions);
 }
@@ skipping 111 matching lines @@
     // allowed to request the URL.
     return state->second->CanRequestURL(url);
   }
 }
 
 bool ChildProcessSecurityPolicy::CanReadFile(int child_id,
                                              const FilePath& file) {
   return HasPermissionsForFile(child_id, file, kReadFilePermissions);
 }
 
+bool ChildProcessSecurityPolicy::CanReadDirectory(int child_id,
+                                                  const FilePath& directory) {
+  return HasPermissionsForFile(child_id,
+                               directory,
+                               kEnumerateDirectoryPermissions);
+}
+
 bool ChildProcessSecurityPolicy::HasPermissionsForFile(
     int child_id, const FilePath& file, int permissions) {
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->HasPermissionsForFile(file, permissions);
 }
@@ skipping 20 matching lines @@
 
 bool ChildProcessSecurityPolicy::CanReadRawCookies(int child_id) {
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->can_read_raw_cookies();
 }