Chrome side of having the WebKit FileSystem API use WebPermissionClient for checking if using fil...

content/browser/worker_host/worker_process_host.cc

 // Copyright (c) 2011 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 "content/browser/worker_host/worker_process_host.h"
 
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 183 matching lines @@
           base::PLATFORM_FILE_CREATE_ALWAYS |
           base::PLATFORM_FILE_READ |
           base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_EXCLUSIVE_READ |
           base::PLATFORM_FILE_EXCLUSIVE_WRITE |
           base::PLATFORM_FILE_ASYNC |
           base::PLATFORM_FILE_TRUNCATE |
           base::PLATFORM_FILE_WRITE_ATTRIBUTES);
   }
 
+  // Call the embedder first so that their IPC filters have priority.
+  content::GetContentClient()->browser()->WorkerProcessHostCreated(this);
   CreateMessageFilters(render_process_id);
 
-  content::GetContentClient()->browser()->WorkerProcessHostCreated(this);
-
   return true;
 }
 
 void WorkerProcessHost::CreateMessageFilters(int render_process_id) {
   DCHECK(resource_context_);
   net::URLRequestContext* request_context =
       resource_context_->request_context();
 
   ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
       id(), WORKER_PROCESS, resource_context_,
       new URLRequestContextSelector(request_context),
       resource_dispatcher_host_);
   AddFilter(resource_message_filter);
 
   worker_message_filter_ = new WorkerMessageFilter(
       render_process_id,
       resource_context_,
       resource_dispatcher_host_,
       NewCallbackWithReturnValue(
           WorkerService::GetInstance(), &WorkerService::next_worker_route_id));
   AddFilter(worker_message_filter_);
   AddFilter(new AppCacheDispatcherHost(resource_context_, id()));
   AddFilter(new FileSystemDispatcherHost(
-      request_context,
-      resource_context_->host_content_settings_map(),
-      resource_context_->file_system_context()));
+      request_context, resource_context_->file_system_context()));
   AddFilter(new FileUtilitiesMessageFilter(id()));
   AddFilter(
       new BlobMessageFilter(id(), resource_context_->blob_storage_context()));
   AddFilter(new MimeRegistryMessageFilter());
   AddFilter(new DatabaseMessageFilter(
       resource_context_->database_tracker()));
 
   SocketStreamDispatcherHost* socket_stream_dispatcher_host =
       new SocketStreamDispatcherHost(
           new URLRequestContextSelector(request_context));
@@ skipping 42 matching lines @@
 
 void WorkerProcessHost::OnProcessLaunched() {
 }
 
 bool WorkerProcessHost::OnMessageReceived(const IPC::Message& message) {
   bool msg_is_ok = true;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(WorkerProcessHost, message, msg_is_ok)
     IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextClosed,
                         OnWorkerContextClosed)
+    IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowDatabase, OnAllowDatabase)
+    IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowFileSystem, OnAllowFileSystem)
     IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP_EX()
 
   if (!msg_is_ok) {
     NOTREACHED();
     UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_WPH"));
     base::KillProcess(handle(), ResultCodes::KILLED_BAD_MESSAGE, false);
   }
 
   if (handled)
@@ skipping 25 matching lines @@
     if (i->worker_route_id() == worker_route_id) {
       // Set the closed flag - this will stop any further messages from
       // being sent to the worker (messages can still be sent from the worker,
       // for exception reporting, etc).
       i->set_closed(true);
       break;
     }
   }
 }
 
+void WorkerProcessHost::OnAllowDatabase(int worker_route_id,
+                                        const GURL& url,
+                                        const string16& name,
+                                        const string16& display_name,
+                                        unsigned long estimated_size,
+                                        bool* result) {
+  *result = true;
+}
+
+void WorkerProcessHost::OnAllowFileSystem(int worker_route_id,
+                                          const GURL& url,
+                                          bool* result) {
+  *result = true;
+}
+
 void WorkerProcessHost::RelayMessage(
     const IPC::Message& message,
     WorkerMessageFilter* filter,
     int route_id) {
   if (message.type() == WorkerMsg_PostMessage::ID) {
     // We want to send the receiver a routing id for the new channel, so
     // crack the message first.
     string16 msg;
     std::vector<int> sent_message_port_ids;
     std::vector<int> new_routing_ids;
@@ skipping 250 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }