Implementation of shared worker code path for WebView file system permission.

chrome/browser/chrome_content_browser_client.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 "chrome/browser/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 628 matching lines @@
   return ratio * (kMaxFSM - kMinFSM) + kMinFSM;
 }
 
 #endif  // defined(OS_ANDROID)
 
 }  // namespace
 
 namespace chrome {
 
 ChromeContentBrowserClient::ChromeContentBrowserClient()
-    : prerender_tracker_(NULL) {
+    : prerender_tracker_(NULL),
+      weak_factory_(this) {
 #if defined(ENABLE_PLUGINS)
   for (size_t i = 0; i < arraysize(kPredefinedAllowedDevChannelOrigins); ++i)
     allowed_dev_channel_origins_.insert(kPredefinedAllowedDevChannelOrigins[i]);
   for (size_t i = 0; i < arraysize(kPredefinedAllowedFileHandleOrigins); ++i)
     allowed_file_handle_origins_.insert(kPredefinedAllowedFileHandleOrigins[i]);
   for (size_t i = 0; i < arraysize(kPredefinedAllowedSocketOrigins); ++i)
     allowed_socket_origins_.insert(kPredefinedAllowedSocketOrigins[i]);
 #endif
 
   permissions_policy_delegate_.reset(
@@ skipping 1150 matching lines @@
   for (i = render_frames.begin(); i != render_frames.end(); ++i) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&TabSpecificContentSettings::WebDatabaseAccessed,
                    i->first, i->second, url, name, display_name, !allow));
   }
 
   return allow;
 }
 
-bool ChromeContentBrowserClient::AllowWorkerFileSystem(
+void ChromeContentBrowserClient::AllowWorkerFileSystem(
     const GURL& url,
     content::ResourceContext* context,
-    const std::vector<std::pair<int, int> >& render_frames) {
+    const std::vector<std::pair<int, int> >& render_frames,
+    base::Callback<void(bool)> callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   CookieSettings* cookie_settings = io_data->GetCookieSettings();
   bool allow = cookie_settings->IsSettingCookieAllowed(url, url);
 
+#if defined(ENABLE_EXTENSIONS)
+  // Record access to file system for potential display in UI.
+  std::vector<std::pair<int, int> >::const_iterator i;
+  for (i = render_frames.begin(); i != render_frames.end(); ++i) {
+    bool is_web_view_guest =
+        WebViewRendererState::GetInstance()->IsGuest(i->first);

[Fady Samuel, 2014/07/08 21:49:11]

This code doesn't make sense to me. If there are two webviews in the same
process, then we don't need to make the decision again. If there are multiple
processes, then we need to make multiple permission requests.

I would suggest iterating over the vector, creating a map:

process ID => vector of routing ID.

Then for each key in the map, request permission of a webview.

[Xi Han, 2014/07/09 15:28:33]

Done.

+    if (is_web_view_guest) {
+      BrowserThread::PostTask(
+          BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&ChromeContentBrowserClient::
+                     RequestFileSystemPermissionOnUIThread,
+                     i->first,
+                     i->second,
+                     url,
+                     allow,
+                     base::Bind(&ChromeContentBrowserClient::FileSystemAccessed,
+                                weak_factory_.GetWeakPtr(),
+                                url,
+                                render_frames,
+                                callback)));
+      break;
+    }
+  }
+#else
+  FileSystemAccessed(url, render_frames, callback, allow);
+#endif
+}
+
+#if defined(ENABLE_EXTENSIONS)
+void ChromeContentBrowserClient::RequestFileSystemPermissionOnUIThread(
+    int render_process_id,
+    int render_frame_id,
+    const GURL& url,
+    bool allowed_by_default,
+    const base::Callback<void(bool)>& callback) {
+  DCHECK(BrowserThread:: CurrentlyOn(BrowserThread::UI));
+  WebViewGuest* guest = WebViewGuest::FromFrameID(render_process_id,
+                                                  render_frame_id);
+  guest->RequestFileSystemPermission(url, allowed_by_default, callback);
+}
+#endif
+
+void ChromeContentBrowserClient::FileSystemAccessed(
+    const GURL& url,
+    const std::vector<std::pair<int, int> >& render_frames,
+    base::Callback<void(bool)> callback,
+    bool allow) {
   // Record access to file system for potential display in UI.
   std::vector<std::pair<int, int> >::const_iterator i;
   for (i = render_frames.begin(); i != render_frames.end(); ++i) {
     BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
+        BrowserThread::UI,
+        FROM_HERE,
         base::Bind(&TabSpecificContentSettings::FileSystemAccessed,
-                   i->first, i->second, url, !allow));
+                   i->first,
+                   i->second,
+                   url,
+                   !allow));
   }
-
-  return allow;
+  callback.Run(allow);
 }
 
 bool ChromeContentBrowserClient::AllowWorkerIndexedDB(
     const GURL& url,
     const base::string16& name,
     content::ResourceContext* context,
     const std::vector<std::pair<int, int> >& render_frames) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   CookieSettings* cookie_settings = io_data->GetCookieSettings();
@@ skipping 952 matching lines @@
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace chrome