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 214 matching lines @@
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
 #include "chrome/browser/captive_portal/captive_portal_tab_helper.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/guest_view/guest_view_base.h"
 #include "chrome/browser/guest_view/guest_view_constants.h"
 #include "chrome/browser/guest_view/guest_view_manager.h"
 #include "chrome/browser/guest_view/web_view/web_view_guest.h"
+#include "chrome/browser/guest_view/web_view/web_view_permission_helper.h"
 #include "chrome/browser/guest_view/web_view/web_view_renderer_state.h"
 #include "chrome/browser/renderer_host/chrome_extension_message_filter.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #endif
 
 #if defined(ENABLE_SPELLCHECK)
 #include "chrome/browser/spellchecker/spellcheck_message_filter.h"
 #endif
 
 #if defined(ENABLE_SERVICE_DISCOVERY)
@@ skipping 396 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))
+      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));
+  WebViewPermissionHelper* web_view_permission_helper =
+      WebViewPermissionHelper::FromFrameID(render_process_id,
+                                           render_frame_id);
+  web_view_permission_helper->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