A few more cleanups to the pepper code. Dispatch IPCs in the sockets implementations directly by ha…

content/renderer/pepper/pepper_file_io_host.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_file_io_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util_proxy.h"
 #include "content/child/child_thread.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/common/fileapi/file_system_messages.h"
+#include "content/common/view_messages.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_helper_impl.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/ppb_file_ref_impl.h"
 #include "content/renderer/pepper/quota_file_io.h"
-#include "content/renderer/pepper/resource_helper.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/file_type_conversion.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/thunk/enter.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 
@@ skipping 107 matching lines @@
 
 PepperFileIOHost::PepperFileIOHost(RendererPpapiHost* host,
                                    PP_Instance instance,
                                    PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       file_(base::kInvalidPlatformFileValue),
       file_system_type_(PP_FILESYSTEMTYPE_INVALID),
       quota_policy_(quota::kQuotaLimitTypeUnknown),
       is_running_in_process_(host->IsRunningInProcess()),
       open_flags_(0),
-      weak_factory_(this) {
+      weak_factory_(this),
+      routing_id_(RenderThreadImpl::current()->GenerateRoutingID()) {
+      ChildThread::current()->AddRoute(routing_id_, this);
 }
 
 PepperFileIOHost::~PepperFileIOHost() {
   OnHostMsgClose(NULL);
+  ChildThread::current()->RemoveRoute(routing_id_);
 }
 
 int32_t PepperFileIOHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   IPC_BEGIN_MESSAGE_MAP(PepperFileIOHost, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_Open,
                                       OnHostMsgOpen)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FileIO_Query,
                                         OnHostMsgQuery)
@@ skipping 14 matching lines @@
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_WillSetLength,
                                       OnHostMsgWillSetLength)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FileIO_GetOSFileDescriptor,
                                         OnHostMsgGetOSFileDescriptor)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FileIO_RequestOSFileHandle,
                                         OnHostMsgRequestOSFileHandle)
   IPC_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
+bool PepperFileIOHost::OnMessageReceived(const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PepperFileIOHost, msg)
+    IPC_MESSAGE_HANDLER(ViewMsg_AsyncOpenPepperFile_ACK, OnAsyncFileOpened)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PepperFileIOHost::OnAsyncFileOpened(
+    base::PlatformFileError error_code,
+    IPC::PlatformFileForTransit file_for_transit,
+    int message_id) {
+  AsyncOpenFileCallback* callback =
+      pending_async_open_files_.Lookup(message_id);
+  DCHECK(callback);
+  pending_async_open_files_.Remove(message_id);
+
+  base::PlatformFile file =
+      IPC::PlatformFileForTransitToPlatformFile(file_for_transit);
+  callback->Run(error_code, base::PassPlatformFile(&file));
+  // Make sure we won't leak file handle if the requester has died.
+  if (file != base::kInvalidPlatformFileValue) {
+    base::FileUtilProxy::Close(
+        RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(),
+        file,
+        base::FileUtilProxy::StatusCallback());
+  }
+  delete callback;
+}
+
 int32_t PepperFileIOHost::OnHostMsgOpen(
     ppapi::host::HostMessageContext* context,
     PP_Resource file_ref_resource,
     int32_t open_flags) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, false);
   if (rv != PP_OK)
     return rv;
 
   // TODO(tommycli): Eventually just pass the Pepper flags straight to the
@@ skipping 22 matching lines @@
   if (file_ref->HasValidFileSystem()) {
     file_system_url_ = file_ref->GetFileSystemURL();
 
     FileSystemDispatcher* file_system_dispatcher =
         ChildThread::current()->file_system_dispatcher();
     AsyncOpenFileSystemURLCallback callback = base::Bind(
         &PepperFileIOHost::ExecutePlatformOpenFileSystemURLCallback,
         weak_factory_.GetWeakPtr(),
         context->MakeReplyMessageContext());
     file_system_dispatcher->OpenFile(
-      file_system_url_, platform_file_flags,
-      base::Bind(&DidOpenFileSystemURL, callback),
-      base::Bind(&DidFailOpenFileSystemURL, callback));
+        file_system_url_, platform_file_flags,
+        base::Bind(&DidOpenFileSystemURL, callback),
+        base::Bind(&DidFailOpenFileSystemURL, callback));
   } else {
-    PepperHelperImpl* helper = static_cast<PepperPluginInstanceImpl*>(
-        PepperPluginInstance::Get(pp_instance()))->helper();
-    if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL || !helper)
+    if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL)
       return PP_ERROR_FAILED;
-    if (!helper->AsyncOpenFile(
-            file_ref->GetSystemPath(), open_flags,
-            base::Bind(&PepperFileIOHost::ExecutePlatformOpenFileCallback,
-                       weak_factory_.GetWeakPtr(),
-                       context->MakeReplyMessageContext())))
-      return PP_ERROR_FAILED;
+    int message_id = pending_async_open_files_.Add(new AsyncOpenFileCallback(
+        base::Bind(&PepperFileIOHost::ExecutePlatformOpenFileCallback,
+                    weak_factory_.GetWeakPtr(),
+                    context->MakeReplyMessageContext())));
+    RenderThreadImpl::current()->Send(new ViewHostMsg_AsyncOpenPepperFile(
+        routing_id_, file_ref->GetSystemPath(), open_flags, message_id));
   }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgQuery(
     ppapi::host::HostMessageContext* context) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
@@ skipping 356 matching lines @@
   // On the plugin side, the callback expects a parameter with different meaning
   // depends on whether is negative or not. It is the result here. We translate
   // for the callback.
   int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
   reply_context.params.set_result(ErrorOrByteNumber(pp_error, bytes_written));
   host()->SendReply(reply_context, PpapiPluginMsg_FileIO_GeneralReply());
   state_manager_.SetOperationFinished();
 }
 
 }  // namespace content