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 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)
+  GuestPermissionRequestHelper(url, render_frames, callback, allow);
+#else
+  FileSystemAccessed(url, render_frames, callback, allow);
+#endif
+}
+
+#if defined(ENABLE_EXTENSIONS)
+void ChromeContentBrowserClient::GuestPermissionRequestHelper(
+    const GURL& url,
+    const std::vector<std::pair<int, int> >& render_frames,
+    base::Callback<void(bool)> callback,
+    bool allow) {
+  DCHECK(BrowserThread:: CurrentlyOn(BrowserThread::IO));
+  std::vector<std::pair<int, int> >::const_iterator i;
+  std::map<int, int> process_map;
+  std::map<int, int>::const_iterator it;
+  bool has_web_view_guest = false;
+  // Record access to file system for potential display in UI.
+  for (i = render_frames.begin(); i != render_frames.end(); ++i) {
+    if (process_map.find(i->first) != process_map.end())
+      continue;
+
+    process_map.insert(std::pair<int, int>(i->first, i->second));
+
+    if (WebViewRendererState::GetInstance()->IsGuest(i->first)) {

[Fady Samuel, 2014/07/09 21:08:32]

Remove block.

+      has_web_view_guest = true;
+    }
+  }
+
+  if (!has_web_view_guest) {
+    FileSystemAccessed(url, render_frames, callback, allow);
+    return;
+  }
+  DCHECK(process_map.size() == 1);
+  it = process_map.begin();
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&ChromeContentBrowserClient::
+                  RequestFileSystemPermissionOnUIThread,
+                  it->first,
+                  it->second,
+                  url,
+                  allow,
+                  base::Bind(&ChromeContentBrowserClient::FileSystemAccessed,
+                            weak_factory_.GetWeakPtr(),
+                            url,
+                            render_frames,
+                            callback)));
+}
+
+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));
   }
-
-  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 955 matching lines @@
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace chrome