Pepper Message Filters: Port to use explicit permission grants in ChildProcessSecurityPolicy.

content/renderer/pepper/pepper_plugin_delegate_impl.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 "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
@@ skipping 63 matching lines @@
 #include "media/video/capture/video_capture_proxy.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/url_loader_resource.h"
 #include "ppapi/shared_impl/api_id.h"
 #include "ppapi/shared_impl/file_path.h"
+#include "ppapi/shared_impl/file_type_conversion.h"
 #include "ppapi/shared_impl/platform_file.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/socket_option_data.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_tcp_server_socket_private_api.h"
@@ skipping 800 matching lines @@
   if (!plugin_module)
     return;
 
   PepperBrokerImpl* broker =
       static_cast<PepperBrokerImpl*>(plugin_module->GetBroker());
   broker->OnBrokerPermissionResult(client.get(), result);
 }
 
 bool PepperPluginDelegateImpl::AsyncOpenFile(
     const base::FilePath& path,
-    int flags,
+    int pp_open_flags,
     const AsyncOpenFileCallback& callback) {
   int message_id = pending_async_open_files_.Add(
       new AsyncOpenFileCallback(callback));
-  IPC::Message* msg = new ViewHostMsg_AsyncOpenFile(
-      render_view_->routing_id(), path, flags, message_id);
+  IPC::Message* msg = new ViewHostMsg_AsyncOpenPepperFile(
+      render_view_->routing_id(), path, pp_open_flags, message_id);
   return render_view_->Send(msg);
 }
 
 void PepperPluginDelegateImpl::OnAsyncFileOpened(
     base::PlatformFileError error_code,
     base::PlatformFile file,
     int message_id) {
   AsyncOpenFileCallback* callback =
       pending_async_open_files_.Lookup(message_id);
   DCHECK(callback);
@@ skipping 135 matching lines @@
     const ReadDirectoryCallback& success_callback,
     const StatusCallback& error_callback) {
   FileSystemDispatcher* file_system_dispatcher =
       ChildThread::current()->file_system_dispatcher();
   file_system_dispatcher->ReadDirectory(
       directory_path, success_callback, error_callback);
 }
 
 void PepperPluginDelegateImpl::AsyncOpenFileSystemURL(
     const GURL& path,
-    int flags,
+    int pp_open_flags,
     const AsyncOpenFileSystemURLCallback& callback) {
+  // TODO(tommycli): Eventually just pass the Pepper flags straight to the
+  // FileSystemDispatcher so it can handle doing the security check.
+  int platform_file_flags = 0;
+  if (!ppapi::PepperFileOpenFlagsToPlatformFileFlags(
+          pp_open_flags, &platform_file_flags)) {
+    DidFailOpenFileSystemURL(callback, base::PLATFORM_FILE_ERROR_FAILED);
+    return;
+  }
+
   FileSystemDispatcher* file_system_dispatcher =
       ChildThread::current()->file_system_dispatcher();
   file_system_dispatcher->OpenFile(
-      path, flags,
+      path, platform_file_flags,
       base::Bind(&DidOpenFileSystemURL, callback),
       base::Bind(&DidFailOpenFileSystemURL, callback));
 }
 
 void PepperPluginDelegateImpl::SyncGetFileSystemPlatformPath(
     const GURL& url, base::FilePath* platform_path) {
   RenderThreadImpl::current()->Send(new FileSystemHostMsg_SyncGetPlatformPath(
       url, platform_path));
 }
 
@@ skipping 556 matching lines @@
       should_close_source);
 }
 
 bool PepperPluginDelegateImpl::IsRunningInProcess(PP_Instance instance) const {
   RendererPpapiHostImpl* host =
       RendererPpapiHostImpl::GetForPPInstance(instance);
   return host && host->IsRunningInProcess();
 }
 
 }  // namespace content