Add chrome.fileSystem.GetVolumeList().

chrome/common/extensions/api/file_system.idl

 // 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.
 
 // Use the <code>chrome.fileSystem</code> API to create, read, navigate,
 // and write to the user's local file system. With this API, Chrome Apps can
 // read and write to a user-selected location. For example, a text editor app
 // can use the API to read and write local documents. All failures are notified
 // via chrome.runtime.lastError.
 namespace fileSystem {
@@ skipping 65 matching lines @@
     // unset or contains no valid entries, this will always be reset to true.
     boolean? acceptsAllTypes;
 
     // Whether to accept multiple files. This is only supported for openFile and
     // openWritableFile. The callback to chooseEntry will be called with a list
     // of entries if this is set to true. Otherwise it will be called with a
     // single Entry.
     boolean? acceptsMultiple;
   };
 
-  dictionary RequestFileSystemOptions {
+  [nodoc] dictionary RequestFileSystemOptions {
     // The ID of the requested volume.
     DOMString volumeId;
 
     // Whether the requested file system should be writeable, or read-only.
     // By default read-only.
     boolean? writable;
   };
 
-// Change to an entry within a tracked directory.
+  // Represents a mounted volume, which can be accessed via <code>chrome.
+  // fileSystem.requestFileSystem</code>.
+  [nodoc] dictionary Volume {
+    DOMString volumeId;
+    boolean writable;
+  };
+
+  // Change to an entry within a tracked directory.
   [nodoc] dictionary ChildChange {
     [instanceOf=Entry] object entry;
     ChildChangeType type;
   };
 
   // Event notifying about a change in a file or a directory, including its
   // contents.
   [nodoc] dictionary EntryChangedEvent {
     // Tracked entry.
     [instanceOf=Entry] object target;
@@ skipping 11 matching lines @@
   callback GetDisplayPathCallback = void (DOMString displayPath);
   callback EntryCallback = void ([instanceOf=Entry] object entry);
   callback EntriesCallback = void (
       [instanceOf=Entry] optional object entry,
       [instanceOf=FileEntry] optional object[] fileEntries);
   callback IsWritableCallback = void (boolean isWritable);
   callback IsRestorableCallback = void (boolean isRestorable);
   [nodoc] callback GetObservedEntriesCallback = void (
       [instanceOf=Entry] object[] entries);
   [nodoc] callback RequestFileSystemCallback = void(
-      [instanceOf=FileSystem] optional object fileSystem);
+      [instanceOf=FileSystem] object fileSystem);
+  [nodoc] callback GetVolumeListCallback = void(Volume[] volumes);
 
   interface Functions {
     // Get the display path of an Entry object. The display path is based on
     // the full path of the file or directory on the local file system, but may
     // be made more readable for display purposes.
     static void getDisplayPath([instanceOf=Entry] object entry,
                                GetDisplayPathCallback callback);
 
     // Get a writable Entry from another Entry. This call will fail with a
     // runtime error if the application does not have the 'write' permission
@@ skipping 30 matching lines @@
     // Requests access to a file system for a volume represented by <code>
     // options.volumeId</code>. If <code>options.writable</code> is set to true,
     // then the file system will be writable. Otherwise, it will be read-only.
     // The <code>writable</code> option requires the <code>
     // "fileSystem": {"write"}</code> permission in the manifest. Available to
     // kiosk apps running in kiosk session only. For manual-launch kiosk mode, a
     // confirmation dialog will be shown on top of the active app window.
     [nodoc] static void requestFileSystem(RequestFileSystemOptions options,
                                           RequestFileSystemCallback callback);
 
+    // Returns a list of volumes available for <code>requestFileSystem()</code>.
+    // The <code>"fileSystem": {"requestFileSystem"}</code> manifest permission
+    // is required. Available to kiosk apps running in the kiosk session only.
+    [nodoc] static void getVolumeList(GetVolumeListCallback callback);
+
     // Observes a directory entry. Emits an event if the tracked directory is
     // changed (including the list of files on it), or removed. If <code>
     // recursive</code> is set to true, then also all accessible subdirectories
     // will be tracked. Observers are automatically removed once the extension
     // is closed or suspended, unless <code>entry</code> is retained using
     // <code>chrome.fileSystem.retainEntry</code>.
     //
     // In such case of retained entries, the observer stays active across
     // restarts until <code>unobserveEntry</code> is explicitly called. Note,
     // that once the <code>entry</code> is not retained anymore, the observer
@@ skipping 12 matching lines @@
   };
 
   interface Events {
     // Called when an observed entry is changed.
     [nodoc] static void onEntryChanged(EntryChangedEvent event);
 
     // Called when an observed entry is removed.
     [nodoc] static void onEntryRemoved(EntryRemovedEvent event);
   };
 };