Avoid sync IPCs for FileSystem API

chrome/renderer/content_settings_observer.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/renderer/content_settings_observer.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/constants.h"
+#include "third_party/WebKit/public/platform/WebPermissionCallbacks.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "webkit/child/weburlresponse_extradata_impl.h"
 
 using blink::WebDataSource;
 using blink::WebDocument;
 using blink::WebFrame;
 using blink::WebFrameClient;
+using blink::WebPermissionCallbacks;
 using blink::WebSecurityOrigin;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebView;
 using content::DocumentState;
 using content::NavigationState;
 using extensions::APIPermission;
 
 namespace {
 
@@ skipping 105 matching lines @@
     content::RenderFrame* render_frame,
     extensions::Dispatcher* extension_dispatcher)
     : content::RenderFrameObserver(render_frame),
       content::RenderFrameObserverTracker<ContentSettingsObserver>(
           render_frame),
       extension_dispatcher_(extension_dispatcher),
       allow_displaying_insecure_content_(false),
       allow_running_insecure_content_(false),
       content_setting_rules_(NULL),
       is_interstitial_page_(false),
-      npapi_plugins_blocked_(false) {
+      npapi_plugins_blocked_(false),
+      current_request_id_(0) {
   ClearBlockedContentSettings();
   render_frame->GetWebFrame()->setPermissionClient(this);
 }
 
 ContentSettingsObserver::~ContentSettingsObserver() {
 }
 
 void ContentSettingsObserver::SetContentSettingRules(
     const RendererContentSettingRules* content_setting_rules) {
   content_setting_rules_ = content_setting_rules;
@@ skipping 20 matching lines @@
 bool ContentSettingsObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAsInterstitial, OnSetAsInterstitial)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_NPAPINotSupported, OnNPAPINotSupported)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAllowDisplayingInsecureContent,
                         OnSetAllowDisplayingInsecureContent)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAllowRunningInsecureContent,
                         OnSetAllowRunningInsecureContent)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_ReloadFrame, OnReloadFrame);
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_RequestFileSystemAccessResponse,
+                        OnRequestFileSystemAccessResponse)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   if (handled)
     return true;
 
   // Don't swallow LoadBlockedPlugins messages, as they're sent to every
   // blocked plugin.
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_LoadBlockedPlugins, OnLoadBlockedPlugins)
   IPC_END_MESSAGE_MAP()
@@ skipping 47 matching lines @@
       frame->top()->document().securityOrigin().isUnique())
     return false;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowFileSystem(
       routing_id(), GURL(frame->document().securityOrigin().toString()),
       GURL(frame->top()->document().securityOrigin().toString()), &result));
   return result;
 }
 
+void ContentSettingsObserver::requestFileSystemAccess(
+    WebFrame* frame, const WebPermissionCallbacks& callbacks) {
+  ++current_request_id_;
+  std::pair<PermissionRequestMap::iterator, bool> insert_result =
+      permission_requests_.insert(
+          std::make_pair(current_request_id_, callbacks));
+
+  // Verify there are no duplicate insertions.
+  DCHECK(insert_result.second);
+
+  if (frame->document().securityOrigin().isUnique() ||
+      frame->top()->document().securityOrigin().isUnique()) {
+    insert_result.first->second.doDeny();
+    permission_requests_.erase(insert_result.first);

[kinuko, 2014/03/07 08:22:29]

I feel this could be checked before you insert the callbacks to the internal
map?  Also I don't feel using insert_result here is particularly useful while
it's losing some readability. Probably this could be written w/o typing lengthy
type names like:

if (...unique) {
  callbacks.doDeny();
  return;
}

bool inserted = requests_.insert(id, callbacks).second;
DCHECK(inserted);

Send(...);

+    return;
+  }
+
+  Send(new ChromeViewHostMsg_RequestFileSystemAccess(
+      routing_id(),
+      current_request_id_,
+      GURL(frame->document().securityOrigin().toString()),
+      GURL(frame->top()->document().securityOrigin().toString())));
+}
+
 bool ContentSettingsObserver::allowImage(WebFrame* frame,
                                          bool enabled_per_settings,
                                          const WebURL& image_url) {
   bool allow = enabled_per_settings;
   if (enabled_per_settings) {
     if (is_interstitial_page_)
       return true;
     if (IsWhitelistedForContentSettings(frame))
       return true;
 
@@ skipping 308 matching lines @@
   allow_running_insecure_content_ = allow;
   OnSetAllowDisplayingInsecureContent(allow);
 }
 
 void ContentSettingsObserver::OnReloadFrame() {
   DCHECK(!render_frame()->GetWebFrame()->parent()) <<
       "Should only be called on the main frame";
   render_frame()->GetWebFrame()->reload();
 }
 
+void ContentSettingsObserver::OnRequestFileSystemAccessResponse(int request_id,
+                                                                bool allowed) {
+  PermissionRequestMap::iterator it = permission_requests_.find(request_id);
+  if (it == permission_requests_.end())
+    return;
+
+  WebPermissionCallbacks callbacks = it->second;
+  permission_requests_.erase(it);
+
+  if (allowed) {
+    callbacks.doAllow();
+    return;
+  }
+  callbacks.doDeny();
+}
+
 void ContentSettingsObserver::ClearBlockedContentSettings() {
   for (size_t i = 0; i < arraysize(content_blocked_); ++i)
     content_blocked_[i] = false;
   cached_storage_permissions_.clear();
   cached_script_permissions_.clear();
 }
 
 const extensions::Extension* ContentSettingsObserver::GetExtension(
     const WebSecurityOrigin& origin) const {
   if (!EqualsASCII(origin.protocol(), extensions::kExtensionScheme))
@@ skipping 47 matching lines @@
 
   // If the scheme is file:, an empty file name indicates a directory listing,
   // which requires JavaScript to function properly.
   if (EqualsASCII(origin.protocol(), content::kFileScheme)) {
     return document_url.SchemeIs(content::kFileScheme) &&
            document_url.ExtractFileName().empty();
   }
 
   return false;
 }