Refactor FileSystem

ppapi/proxy/ppb_file_ref_proxy.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 "ppapi/proxy/ppb_file_ref_proxy.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_file_ref.h"
 #include "ppapi/c/private/ppb_file_ref_private.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/ppb_file_ref_shared.h"
+#include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_FileRef_API;
 using ppapi::thunk::ResourceCreationAPI;
 
 namespace ppapi {
 namespace proxy {
@@ skipping 44 matching lines @@
   typedef std::map<uint32_t,
                    scoped_refptr<TrackedCallback> > PendingCallbackMap;
   PendingCallbackMap pending_callbacks_;
 
   // Used to keep pointers to PP_FileInfo instances that are written before
   // callbacks are invoked. The id of a pending file info will match that of
   // the corresponding callback.
   typedef std::map<uint32_t, PP_FileInfo*> PendingFileInfoMap;
   PendingFileInfoMap pending_file_infos_;
 
+  // Holds a reference on plugin side when running out of process, so that
+  // FileSystem won't die before FileRef.  See PPB_FileRef_Impl for
+  // corresponding code for in-process mode.  Note that this workaround will
+  // be no longer needed after FileRef refactoring.
+  ScopedPPResource file_system_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileRef);
 };
 
 FileRef::FileRef(const PPB_FileRef_CreateInfo& info)
     : PPB_FileRef_Shared(OBJECT_IS_PROXY, info),
-      next_callback_id_(0u) {
+      next_callback_id_(0u),
+      file_system_(info.file_system_plugin_resource) {
 }
 
 FileRef::~FileRef() {
   // The callbacks map should have been cleared by LastPluginRefWasDeleted.
   DCHECK(pending_callbacks_.empty());
   DCHECK(pending_file_infos_.empty());
 }
 
 void FileRef::LastPluginRefWasDeleted() {
   // The callback tracker will abort our callbacks for us.
@@ skipping 97 matching lines @@
 
 PPB_FileRef_Proxy::PPB_FileRef_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_FileRef_Proxy::~PPB_FileRef_Proxy() {
 }
 
 // static
-PP_Resource PPB_FileRef_Proxy::CreateProxyResource(PP_Resource file_system,
+PP_Resource PPB_FileRef_Proxy::CreateProxyResource(PP_Instance instance,
+                                                   PP_Resource file_system,
                                                    const char* path) {
-  Resource* file_system_object =
-      PpapiGlobals::Get()->GetResourceTracker()->GetResource(file_system);
-  if (!file_system_object)
-    return 0;
-
   PPB_FileRef_CreateInfo create_info;
-  PluginDispatcher::GetForResource(file_system_object)->Send(
+  PluginDispatcher::GetForInstance(instance)->Send(
       new PpapiHostMsg_PPBFileRef_Create(
-          API_ID_PPB_FILE_REF, file_system_object->host_resource(),
-          path, &create_info));
+          API_ID_PPB_FILE_REF, instance, file_system, path, &create_info));
   return PPB_FileRef_Proxy::DeserializeFileRef(create_info);
 }
 
 bool PPB_FileRef_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_FileRef_Proxy, msg)
 #if !defined(OS_NACL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Create, OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_GetParent, OnMsgGetParent)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_MakeDirectory,
@@ skipping 25 matching lines @@
 
 // static
 PP_Resource PPB_FileRef_Proxy::DeserializeFileRef(
     const PPB_FileRef_CreateInfo& serialized) {
   if (serialized.resource.is_null())
     return 0;  // Resource invalid.
   return (new FileRef(serialized))->GetReference();
 }
 
 #if !defined(OS_NACL)
-void PPB_FileRef_Proxy::OnMsgCreate(const HostResource& file_system,
+void PPB_FileRef_Proxy::OnMsgCreate(PP_Instance pp_instance,
+                                    PP_Resource file_system,
                                     const std::string& path,
                                     PPB_FileRef_CreateInfo* result) {
-  thunk::EnterResourceCreation enter(file_system.instance());
+  thunk::EnterResourceCreation enter(pp_instance);
   if (enter.failed())
     return;
+
   PP_Resource resource = enter.functions()->CreateFileRef(
-      file_system.host_resource(), path.c_str());
+      pp_instance, file_system, path.c_str());
   if (!resource)
     return;  // CreateInfo default constructor initializes to 0.
   SerializeFileRef(resource, result);
 }
 
 void PPB_FileRef_Proxy::OnMsgGetParent(const HostResource& host_resource,
                                        PPB_FileRef_CreateInfo* result) {
   EnterHostFromHostResource<PPB_FileRef_API> enter(host_resource);
   if (enter.succeeded())
     SerializeFileRef(enter.object()->GetParent(), result);
@@ skipping 102 matching lines @@
     const HostResource& host_resource,
     base::internal::OwnedWrapper<PP_FileInfo> info,
     uint32_t callback_id) {
   Send(new PpapiMsg_PPBFileRef_QueryCallbackComplete(
       API_ID_PPB_FILE_REF, host_resource, *info.get(), callback_id, result));
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace proxy
 }  // namespace ppapi