In ChildProcessSecurityPolicy, rename to |url| to |filesystem_url|

content/browser/child_process_security_policy_impl.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/child_process_security_policy_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 773 matching lines @@
       result = ChildProcessHasPermissionsForFile(iter->second,
                                                  file,
                                                  permissions);
     }
   }
   return result;
 }
 
 bool ChildProcessSecurityPolicyImpl::HasPermissionsForFileSystemFile(
     int child_id,
-    const storage::FileSystemURL& url,
+    const storage::FileSystemURL& filesystem_url,
     int permissions) {
-  if (!url.is_valid())
+  if (!filesystem_url.is_valid())
     return false;
 
-  // If |url.origin()| is not committable in this process, then this page
+  // If |filesystem_url.origin()| is not committable in this process, then this
+  // page

[Charlie Reis, 2016/10/04 23:25:58]

nit: Fix line wrap.

[ncarter (slow), 2016/10/06 18:11:24]

Done.

   // should not be able to place content in that origin via the filesystem
   // API either.
-  bool can_commit_origin = CanCommitURL(child_id, url.origin());
+  bool can_commit_origin = CanCommitURL(child_id, filesystem_url.origin());
   UMA_HISTOGRAM_BOOLEAN("ChildProcessSecurityPolicy.FileSystemCanCommitOrigin",
                         can_commit_origin);
   if (!can_commit_origin)
     return false;
 
-  if (url.path().ReferencesParent())
+  if (filesystem_url.path().ReferencesParent())
     return false;
 
   // Any write access is disallowed on the root path.
-  if (storage::VirtualPath::IsRootPath(url.path()) &&
+  if (storage::VirtualPath::IsRootPath(filesystem_url.path()) &&
       (permissions & ~READ_FILE_GRANT)) {
     return false;
   }
 
-  if (url.mount_type() == storage::kFileSystemTypeIsolated) {
+  if (filesystem_url.mount_type() == storage::kFileSystemTypeIsolated) {
     // When Isolated filesystems is overlayed on top of another filesystem,
     // its per-filesystem permission overrides the underlying filesystem
     // permissions).
     return HasPermissionsForFileSystem(
-        child_id, url.mount_filesystem_id(), permissions);
+        child_id, filesystem_url.mount_filesystem_id(), permissions);
   }
 
   FileSystemPermissionPolicyMap::iterator found =
-      file_system_policy_map_.find(url.type());
+      file_system_policy_map_.find(filesystem_url.type());
   if (found == file_system_policy_map_.end())
     return false;
 
   if ((found->second & storage::FILE_PERMISSION_READ_ONLY) &&
       permissions & ~READ_FILE_GRANT) {
     return false;
   }
 
   if (found->second & storage::FILE_PERMISSION_USE_FILE_PERMISSION)
-    return HasPermissionsForFile(child_id, url.path(), permissions);
+    return HasPermissionsForFile(child_id, filesystem_url.path(), permissions);
 
   if (found->second & storage::FILE_PERMISSION_SANDBOX)
     return true;
 
   return false;
 }
 
 bool ChildProcessSecurityPolicyImpl::CanReadFileSystemFile(
     int child_id,
-    const storage::FileSystemURL& url) {
-  return HasPermissionsForFileSystemFile(child_id, url, READ_FILE_GRANT);
+    const storage::FileSystemURL& filesystem_url) {
+  return HasPermissionsForFileSystemFile(child_id, filesystem_url,
+                                         READ_FILE_GRANT);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanWriteFileSystemFile(
     int child_id,
-    const storage::FileSystemURL& url) {
-  return HasPermissionsForFileSystemFile(child_id, url, WRITE_FILE_GRANT);
+    const storage::FileSystemURL& filesystem_url) {
+  return HasPermissionsForFileSystemFile(child_id, filesystem_url,
+                                         WRITE_FILE_GRANT);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanCreateFileSystemFile(
     int child_id,
-    const storage::FileSystemURL& url) {
-  return HasPermissionsForFileSystemFile(child_id, url, CREATE_NEW_FILE_GRANT);
+    const storage::FileSystemURL& filesystem_url) {
+  return HasPermissionsForFileSystemFile(child_id, filesystem_url,
+                                         CREATE_NEW_FILE_GRANT);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanCreateReadWriteFileSystemFile(
     int child_id,
-    const storage::FileSystemURL& url) {
-  return HasPermissionsForFileSystemFile(child_id, url,
+    const storage::FileSystemURL& filesystem_url) {
+  return HasPermissionsForFileSystemFile(child_id, filesystem_url,
                                          CREATE_READ_WRITE_FILE_GRANT);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanCopyIntoFileSystemFile(
     int child_id,
-    const storage::FileSystemURL& url) {
-  return HasPermissionsForFileSystemFile(child_id, url, COPY_INTO_FILE_GRANT);
+    const storage::FileSystemURL& filesystem_url) {
+  return HasPermissionsForFileSystemFile(child_id, filesystem_url,
+                                         COPY_INTO_FILE_GRANT);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanDeleteFileSystemFile(
     int child_id,
-    const storage::FileSystemURL& url) {
-  return HasPermissionsForFileSystemFile(child_id, url, DELETE_FILE_GRANT);
+    const storage::FileSystemURL& filesystem_url) {
+  return HasPermissionsForFileSystemFile(child_id, filesystem_url,
+                                         DELETE_FILE_GRANT);
 }
 
 bool ChildProcessSecurityPolicyImpl::HasWebUIBindings(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->has_web_ui_bindings();
@@ skipping 83 matching lines @@
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->can_send_midi_sysex();
 }
 
 }  // namespace content