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 630 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 1149 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) {

[Xi Han, 2014/07/03 15:02:51]

With this implementation, we will guaranty the callback which sends a reply
message will only be run once. Since the shared worker only receives one
request, it is wrong to send a reply multiple times.

When with guests:
1. We will just ask the first the guest who connects to this shared worker
whether the request is allowed or denied. Because we don't now exactly which
guest sends the request, and it is weird that if multiple guests share one
shared worker but set different permissions to the same worker. So we always ask
the first guest in the list to make a decision.
2. updates all the frames connecting to this shared worker.

Without guests:
1. updates all the frames connecting to this shared worker.

+    bool is_web_view_guest =
+        WebViewRendererState::GetInstance()->IsGuest(i->first);
+    if (is_web_view_guest) {
+      BrowserThread::PostTask(
+          BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&WebViewGuest::RequestFileSystemAccessPermission,

[Fady Samuel, 2014/07/08 14:42:46]

RequestFileSystemPermissionFromIOThread

[Xi Han, 2014/07/08 21:28:24]

I declare a static function in
ChromeContentBrowserClient::FileSystemAccessedOnUIThread to do the thread hop,
and remove WebViewGuest::RequestFileSystemAccessPermission will be removed.

+                     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
+
+}
+
+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 950 matching lines @@
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace chrome