Plumb file system permission into WebviewGuest.

chrome/browser/guest_view/web_view/web_view_guest.h

 // Copyright 2014 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.
 
 #ifndef CHROME_BROWSER_GUEST_VIEW_WEB_VIEW_WEB_VIEW_GUEST_H_
 #define CHROME_BROWSER_GUEST_VIEW_WEB_VIEW_WEB_VIEW_GUEST_H_
 
 #include <vector>
 
 #include "base/observer_list.h"
@@ skipping 178 matching lines @@
       WebViewPermissionType permission_type,
       const base::DictionaryValue& request_info,
       const PermissionResponseCallback& callback,
       bool allowed_by_default);
 
   // Requests Geolocation Permission from the embedder.
   void RequestGeolocationPermission(int bridge_id,
                                     const GURL& requesting_frame,
                                     bool user_gesture,
                                     const base::Callback<void(bool)>& callback);
-
-  void OnWebViewGeolocationPermissionResponse(
-      int bridge_id,
-      bool user_gesture,
-      const base::Callback<void(bool)>& callback,
-      bool allow,
-      const std::string& user_input);
-
   void CancelGeolocationPermissionRequest(int bridge_id);
 
-  void OnWebViewMediaPermissionResponse(
-      const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback,
-      bool allow,
-      const std::string& user_input);
-
-  void OnWebViewDownloadPermissionResponse(
-      const base::Callback<void(bool)>& callback,
-      bool allow,
-      const std::string& user_input);
-
-  void OnWebViewPointerLockPermissionResponse(
-      const base::Callback<void(bool)>& callback,
-      bool allow,
-      const std::string& user_input);
-
-  void OnWebViewNewWindowResponse(int new_window_instance_id,
-                                  bool allow,
-                                  const std::string& user_input);
+  void RequestFileSystemPermission(const GURL& url,
+                                   bool allowed_by_default,
+                                   const base::Callback<void(bool)>& callback);
 
   enum PermissionResponseAction {
     DENY,
     ALLOW,
     DEFAULT
   };
 
   enum SetPermissionResult {
     SET_PERMISSION_INVALID,
     SET_PERMISSION_ALLOWED,
@@ skipping 22 matching lines @@
   // Partition data that are newer than |removal_since| will be removed.
   // |removal_mask| corresponds to bitmask in StoragePartition::RemoveDataMask.
   bool ClearData(const base::Time remove_since,
                  uint32 removal_mask,
                  const base::Closure& callback);
 
   extensions::ScriptExecutor* script_executor() {
     return script_executor_.get();
   }
 
+  // Called when file system access is requested by the guest content using the
+  // asynchronous HTML5 file system API. The request is plumbed through the
+  // <webview> permission request API. The request will be:
+  // - Allowed if the embedder explicitly allowed it.
+  // - Denied if the embedder explicitly denied.
+  // - Determined by the guest's content settings if the embedder does not
+  // perform an explicit action.
+  // If access was blocked due to the page's content settings,
+  // |blocked_by_policy| should be true, and this function should invoke
+  // OnContentBlocked.
+  static void FileSystemAccessedAsync(int render_process_id,
+                                      int render_frame_id,
+                                      int request_id,
+                                      const GURL& url,
+                                      bool blocked_by_policy);
+
+  // Called when file system access is requested by the guest content using the
+  // synchronous HTML5 file system API in a worker thread or shared worker. The
+  // request is plumbed through the <webview> permission request API. The
+  // request will be:
+  // - Allowed if the embedder explicitly allowed it.
+  // - Denied if the embedder explicitly denied.
+  // - Determined by the guest's content settings if the embedder does not
+  // perform an explicit action.
+  // If access was blocked due to the page's content settings,
+  // |blocked_by_policy| should be true, and this function should invoke
+  // OnContentBlocked.
+  static void FileSystemAccessedSync(int render_process_id,
+                                     int render_frame_id,
+                                     const GURL& url,
+                                     bool blocked_by_policy,
+                                     IPC::Message* reply_msg);
+
  private:
   virtual ~WebViewGuest();
 
   // A map to store the callback for a request keyed by the request's id.
   struct PermissionResponseInfo {
     PermissionResponseCallback callback;
     WebViewPermissionType permission_type;
     bool allowed_by_default;
     PermissionResponseInfo();
     PermissionResponseInfo(const PermissionResponseCallback& callback,
                            WebViewPermissionType permission_type,
                            bool allowed_by_default);
     ~PermissionResponseInfo();
   };
 
   static void RecordUserInitiatedUMA(const PermissionResponseInfo& info,
                                      bool allow);
 
   // Returns the top level items (ignoring submenus) as Value.
   static scoped_ptr<base::ListValue> MenuModelToValue(
       const ui::SimpleMenuModel& menu_model);
 
+  void OnWebViewGeolocationPermissionResponse(
+      int bridge_id,
+      bool user_gesture,
+      const base::Callback<void(bool)>& callback,
+      bool allow,
+      const std::string& user_input);
+
+  void OnWebViewFileSystemPermissionResponse(
+      const base::Callback<void(bool)>& callback,
+      bool allow,
+      const std::string& user_input);
+
+  void OnWebViewMediaPermissionResponse(
+      const content::MediaStreamRequest& request,
+      const content::MediaResponseCallback& callback,
+      bool allow,
+      const std::string& user_input);
+
+  void OnWebViewDownloadPermissionResponse(
+      const base::Callback<void(bool)>& callback,
+      bool allow,
+      const std::string& user_input);
+
+  void OnWebViewPointerLockPermissionResponse(
+      const base::Callback<void(bool)>& callback,
+      bool allow,
+      const std::string& user_input);
+
+  void OnWebViewNewWindowResponse(int new_window_instance_id,
+                                  bool allow,
+                                  const std::string& user_input);
+
+  static void FileSystemAccessedAsyncResponse(int render_process_id,
+                                              int render_frame_id,
+                                              int request_id,
+                                              const GURL& url,
+                                              bool allowed);
+
+  static void FileSystemAccessedSyncResponse(int render_process_id,
+                                             int render_frame_id,
+                                             const GURL& url,
+                                             IPC::Message* reply_msg,
+                                             bool allowed);
+
   // WebContentsObserver implementation.
   virtual void DidCommitProvisionalLoadForFrame(
       int64 frame_id,
       const base::string16& frame_unique_name,
       bool is_main_frame,
       const GURL& url,
       content::PageTransition transition_type,
       content::RenderViewHost* render_view_host) OVERRIDE;
   virtual void DidFailProvisionalLoad(
       int64 frame_id,
@@ skipping 147 matching lines @@
         name(name) {}
   };
 
   typedef std::map<WebViewGuest*, NewWindowInfo> PendingWindowMap;
   PendingWindowMap pending_new_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(WebViewGuest);
 };
 
 #endif  // CHROME_BROWSER_GUEST_VIEW_WEB_VIEW_WEB_VIEW_GUEST_H_