path: root/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_directory_entry.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/array_writer.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 {

namespace {

void ReleaseEntries(const std::vector<PP_DirectoryEntry>& entries) {
  ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker();
  for (std::vector<PP_DirectoryEntry>::const_iterator it = entries.begin();
       it != entries.end(); ++it)
    tracker->ReleaseResource(it->file_ref);
}

}  // namespace

class FileRef : public PPB_FileRef_Shared {
 public:
  explicit FileRef(const PPB_FileRef_CreateInfo& info);
  virtual ~FileRef();

  // Resource overrides.
  virtual void LastPluginRefWasDeleted() OVERRIDE;

  // PPB_FileRef_API implementation (not provided by PPB_FileRef_Shared).
  virtual PP_Resource GetParent() OVERRIDE;
  virtual int32_t MakeDirectory(
      PP_Bool make_ancestors,
      scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual int32_t Touch(PP_Time last_access_time,
                        PP_Time last_modified_time,
                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual int32_t Delete(scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual int32_t Rename(PP_Resource new_file_ref,
                         scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual int32_t Query(PP_FileInfo* info,
                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual int32_t ReadDirectoryEntries(
      const PP_ArrayOutput& output,
      scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual int32_t QueryInHost(
      linked_ptr<PP_FileInfo> info,
      scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual int32_t ReadDirectoryEntriesInHost(
      linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files,
      linked_ptr<std::vector<PP_FileType> > file_types,
      scoped_refptr<TrackedCallback> callback) OVERRIDE;
  virtual PP_Var GetAbsolutePath() OVERRIDE;

  // Executes the pending callback with the given ID. See pending_callbacks_.
  void ExecuteCallback(uint32_t callback_id, int32_t result);
  int32_t SetFileInfo(uint32_t callback_id, const PP_FileInfo& info);
  int32_t SetReadDirectoryEntriesOutput(
      uint32_t callback_id,
      const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos,
      const std::vector<PP_FileType>& file_types);

 private:
  PluginDispatcher* GetDispatcher() const {
    return PluginDispatcher::GetForResource(this);
  }

  // Adds a callback to the list and returns its ID.
  uint32_t SendCallback(scoped_refptr<TrackedCallback> callback);

  // This class can have any number of out-standing requests with completion
  // callbacks, in contrast to most resources which have one possible pending
  // callback pending (like a Flush callback).
  //
  // To keep track of them, assign integer IDs to the callbacks, which is how
  // the callback will be identified when it's passed to the host and then
  // back here. Use unsigned so that overflow is well-defined.
  uint32_t next_callback_id_;
  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_;

  // Used to keep PP_ArrayOutput instances that are written before callbacks
  // are invoked. The id of a pending array output will match that of the
  // corresponding callback.
  typedef std::map<uint32_t, PP_ArrayOutput>
      PendingReadDirectoryEntriesOutputMap;
  PendingReadDirectoryEntriesOutputMap pending_read_entries_outputs_;

  // 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),
      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());
  DCHECK(pending_read_entries_outputs_.empty());
}

void FileRef::LastPluginRefWasDeleted() {
  // The callback tracker will abort our callbacks for us.
  pending_callbacks_.clear();
  pending_file_infos_.clear();
  pending_read_entries_outputs_.clear();
}

PP_Resource FileRef::GetParent() {
  PPB_FileRef_CreateInfo create_info;
  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_GetParent(
      API_ID_PPB_FILE_REF, host_resource(), &create_info));
  return PPB_FileRef_Proxy::DeserializeFileRef(create_info);
}

int32_t FileRef::MakeDirectory(PP_Bool make_ancestors,
                               scoped_refptr<TrackedCallback> callback) {
  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_MakeDirectory(
      API_ID_PPB_FILE_REF, host_resource(), make_ancestors,
      SendCallback(callback)));
  return PP_OK_COMPLETIONPENDING;
}

int32_t FileRef::Touch(PP_Time last_access_time,
                       PP_Time last_modified_time,
                       scoped_refptr<TrackedCallback> callback) {
  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Touch(
      API_ID_PPB_FILE_REF, host_resource(), last_access_time,
      last_modified_time, SendCallback(callback)));
  return PP_OK_COMPLETIONPENDING;
}

int32_t FileRef::Delete(scoped_refptr<TrackedCallback> callback) {
  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Delete(
      API_ID_PPB_FILE_REF, host_resource(), SendCallback(callback)));
  return PP_OK_COMPLETIONPENDING;
}

int32_t FileRef::Rename(PP_Resource new_file_ref,
                        scoped_refptr<TrackedCallback> callback) {
  Resource* new_file_ref_object =
      PpapiGlobals::Get()->GetResourceTracker()->GetResource(new_file_ref);
  if (!new_file_ref_object ||
      new_file_ref_object->host_resource().instance() != pp_instance())
    return PP_ERROR_BADRESOURCE;

  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Rename(
      API_ID_PPB_FILE_REF, host_resource(),
      new_file_ref_object->host_resource(), SendCallback(callback)));
  return PP_OK_COMPLETIONPENDING;
}

int32_t FileRef::Query(PP_FileInfo* info,
                       scoped_refptr<TrackedCallback> callback) {
  // Store the pending file info id.
  uint32_t id = SendCallback(callback);
  pending_file_infos_[id] = info;
  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Query(
      API_ID_PPB_FILE_REF, host_resource(), id));
  return PP_OK_COMPLETIONPENDING;
}

int32_t FileRef::ReadDirectoryEntries(
    const PP_ArrayOutput& output,
    scoped_refptr<TrackedCallback> callback) {
  // Store the pending read entries output id.
  uint32_t id = SendCallback(callback);
  pending_read_entries_outputs_[id] = output;
  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_ReadDirectoryEntries(
      API_ID_PPB_FILE_REF, host_resource(), id));
  return PP_OK_COMPLETIONPENDING;
}

int32_t FileRef::QueryInHost(
    linked_ptr<PP_FileInfo> info,
    scoped_refptr<TrackedCallback> callback) {
  NOTREACHED();
  return PP_ERROR_FAILED;
}

int32_t FileRef::ReadDirectoryEntriesInHost(
    linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files,
    linked_ptr<std::vector<PP_FileType> > file_types,
    scoped_refptr<TrackedCallback> callback) {
  NOTREACHED();
  return PP_ERROR_FAILED;
}

PP_Var FileRef::GetAbsolutePath() {
  ReceiveSerializedVarReturnValue result;
  GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_GetAbsolutePath(
      API_ID_PPB_FILE_REF, host_resource(), &result));
  return result.Return(GetDispatcher());
}

void FileRef::ExecuteCallback(uint32_t callback_id, int32_t result) {
  PendingCallbackMap::iterator found = pending_callbacks_.find(callback_id);
  if (found == pending_callbacks_.end()) {
    // This will happen when the plugin deletes its resource with a pending
    // callback. The callback will be locally issued with an ABORTED call while
    // the operation may still be pending in the renderer.
    return;
  }

  // Executing the callback may mutate the callback list.
  scoped_refptr<TrackedCallback> callback = found->second;
  pending_callbacks_.erase(found);
  callback->Run(result);
}

int32_t FileRef::SetFileInfo(uint32_t callback_id, const PP_FileInfo& info) {
  PendingFileInfoMap::iterator found = pending_file_infos_.find(callback_id);
  if (found == pending_file_infos_.end())
    return PP_ERROR_FAILED;
  PP_FileInfo* target_info = found->second;
  *target_info = info;
  pending_file_infos_.erase(found);
  return PP_OK;
}

int32_t FileRef::SetReadDirectoryEntriesOutput(
    uint32_t callback_id,
    const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos,
    const std::vector<PP_FileType>& file_types) {
  PendingReadDirectoryEntriesOutputMap::iterator found =
      pending_read_entries_outputs_.find(callback_id);
  if (found == pending_read_entries_outputs_.end())
    return PP_ERROR_FAILED;

  PP_ArrayOutput output = found->second;
  pending_read_entries_outputs_.erase(found);

  std::vector<PP_DirectoryEntry> entries;
  for (size_t i = 0; i < infos.size(); ++i) {
    PP_DirectoryEntry entry;
    entry.file_ref = PPB_FileRef_Proxy::DeserializeFileRef(infos[i]);
    entry.file_type = file_types[i];
    entries.push_back(entry);
  }

  ArrayWriter writer(output);
  if (!writer.is_valid()) {
    ReleaseEntries(entries);
    return PP_ERROR_BADARGUMENT;
  }

  writer.StoreVector(entries);
  return PP_OK;
}

uint32_t FileRef::SendCallback(scoped_refptr<TrackedCallback> callback) {
  // In extreme cases the IDs may wrap around, so avoid duplicates.
  while (pending_callbacks_.count(next_callback_id_))
    ++next_callback_id_;

  pending_callbacks_[next_callback_id_] = callback;
  return next_callback_id_++;
}

PPB_FileRef_Proxy::PPB_FileRef_Proxy(Dispatcher* dispatcher)
    : InterfaceProxy(dispatcher),
      callback_factory_(this) {
}

PPB_FileRef_Proxy::~PPB_FileRef_Proxy() {
}

// static
PP_Resource PPB_FileRef_Proxy::CreateProxyResource(PP_Instance instance,
                                                   PP_Resource file_system,
                                                   const char* path) {
  PPB_FileRef_CreateInfo create_info;
  PluginDispatcher::GetForInstance(instance)->Send(
      new PpapiHostMsg_PPBFileRef_Create(
          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,
                        OnMsgMakeDirectory)
    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Touch, OnMsgTouch)
    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Delete, OnMsgDelete)
    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Rename, OnMsgRename)
    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Query, OnMsgQuery)
    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_ReadDirectoryEntries,
                        OnMsgReadDirectoryEntries)
    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_GetAbsolutePath,
                        OnMsgGetAbsolutePath)
#endif  // !defined(OS_NACL)

    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileRef_CallbackComplete,
                        OnMsgCallbackComplete)
    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileRef_QueryCallbackComplete,
                        OnMsgQueryCallbackComplete)
    IPC_MESSAGE_HANDLER(
        PpapiMsg_PPBFileRef_ReadDirectoryEntriesCallbackComplete,
        OnMsgReadDirectoryEntriesCallbackComplete)
    IPC_MESSAGE_UNHANDLED(handled = false)
  IPC_END_MESSAGE_MAP()
  return handled;
}

// static
void PPB_FileRef_Proxy::SerializeFileRef(PP_Resource file_ref,
                                         PPB_FileRef_CreateInfo* result) {
  EnterResourceNoLock<PPB_FileRef_API> enter(file_ref, false);
  if (enter.succeeded())
    *result = enter.object()->GetCreateInfo();
}

// 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(PP_Instance pp_instance,
                                    PP_Resource file_system,
                                    const std::string& path,
                                    PPB_FileRef_CreateInfo* result) {
  thunk::EnterResourceCreation enter(pp_instance);
  if (enter.failed())
    return;

  PP_Resource resource = enter.functions()->CreateFileRef(
      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);
}

void PPB_FileRef_Proxy::OnMsgMakeDirectory(const HostResource& host_resource,
                                           PP_Bool make_ancestors,
                                           uint32_t callback_id) {
  EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
      host_resource, callback_factory_,
      &PPB_FileRef_Proxy::OnCallbackCompleteInHost, host_resource, callback_id);
  if (enter.succeeded()) {
    enter.SetResult(enter.object()->MakeDirectory(make_ancestors,
                                                  enter.callback()));
  }
}

void PPB_FileRef_Proxy::OnMsgTouch(const HostResource& host_resource,
                                   PP_Time last_access,
                                   PP_Time last_modified,
                                   uint32_t callback_id) {
  EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
      host_resource, callback_factory_,
      &PPB_FileRef_Proxy::OnCallbackCompleteInHost, host_resource, callback_id);
  if (enter.succeeded()) {
    enter.SetResult(enter.object()->Touch(last_access, last_modified,
                                          enter.callback()));
  }
}

void PPB_FileRef_Proxy::OnMsgDelete(const HostResource& host_resource,
                                    uint32_t callback_id) {
  EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
      host_resource, callback_factory_,
      &PPB_FileRef_Proxy::OnCallbackCompleteInHost, host_resource, callback_id);
  if (enter.succeeded())
    enter.SetResult(enter.object()->Delete(enter.callback()));
}

void PPB_FileRef_Proxy::OnMsgRename(const HostResource& file_ref,
                                    const HostResource& new_file_ref,
                                    uint32_t callback_id) {
  EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
      file_ref, callback_factory_,
      &PPB_FileRef_Proxy::OnCallbackCompleteInHost, file_ref, callback_id);
  if (enter.succeeded()) {
    enter.SetResult(enter.object()->Rename(new_file_ref.host_resource(),
                                           enter.callback()));
  }
}

void PPB_FileRef_Proxy::OnMsgQuery(const HostResource& file_ref,
                                   uint32_t callback_id) {
  linked_ptr<PP_FileInfo> info(new PP_FileInfo());
  EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
      file_ref, callback_factory_,
      &PPB_FileRef_Proxy::OnQueryCallbackCompleteInHost, file_ref,
      info, callback_id);
  if (enter.succeeded())
    enter.SetResult(enter.object()->QueryInHost(info, enter.callback()));
}

void PPB_FileRef_Proxy::OnMsgGetAbsolutePath(const HostResource& host_resource,
                                             SerializedVarReturnValue result) {
  EnterHostFromHostResource<PPB_FileRef_API> enter(host_resource);
  if (enter.succeeded())
    result.Return(dispatcher(), enter.object()->GetAbsolutePath());
}

void PPB_FileRef_Proxy::OnMsgReadDirectoryEntries(const HostResource& file_ref,
                                         uint32_t callback_id) {
  linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files(
      new std::vector<ppapi::PPB_FileRef_CreateInfo>());
  linked_ptr<std::vector<PP_FileType> > file_types(
      new std::vector<PP_FileType>());
  HostCallbackParams params(file_ref, callback_id);
  EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter(
      file_ref, callback_factory_,
      &PPB_FileRef_Proxy::OnReadDirectoryEntriesCallbackCompleteInHost,
      params, files, file_types);
  if (enter.succeeded()) {
    enter.SetResult(enter.object()->ReadDirectoryEntriesInHost(
        files, file_types, enter.callback()));
  }
}

#endif  // !defined(OS_NACL)

void PPB_FileRef_Proxy::OnMsgCallbackComplete(
    const HostResource& host_resource,
    uint32_t callback_id,
    int32_t result) {
  // Forward the callback info to the plugin resource.
  EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource);
  if (enter.succeeded())
    static_cast<FileRef*>(enter.object())->ExecuteCallback(callback_id, result);
}

void PPB_FileRef_Proxy::OnMsgQueryCallbackComplete(
    const HostResource& host_resource,
    const PP_FileInfo& info,
    uint32_t callback_id,
    int32_t result) {
  EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource);
  if (!enter.succeeded())
    return;

  if (result == PP_OK) {
    result = static_cast<FileRef*>(enter.object())->SetFileInfo(
        callback_id, info);
  }
  static_cast<FileRef*>(enter.object())->ExecuteCallback(callback_id, result);
}

void PPB_FileRef_Proxy::OnMsgReadDirectoryEntriesCallbackComplete(
    const HostResource& host_resource,
    const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos,
    const std::vector<PP_FileType>& file_types,
    uint32_t callback_id,
    int32_t result) {
  CHECK_EQ(infos.size(), file_types.size());

  EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource);
  if (!enter.succeeded())
    return;

  if (result == PP_OK) {
    result =
        static_cast<FileRef*>(enter.object())->SetReadDirectoryEntriesOutput(
            callback_id, infos, file_types);
  }
  static_cast<FileRef*>(enter.object())->ExecuteCallback(
      callback_id, result);
}

#if !defined(OS_NACL)
void PPB_FileRef_Proxy::OnCallbackCompleteInHost(
    int32_t result,
    const HostResource& host_resource,
    uint32_t callback_id) {
  // Execute OnMsgCallbackComplete in the plugin process.
  Send(new PpapiMsg_PPBFileRef_CallbackComplete(
      API_ID_PPB_FILE_REF, host_resource, callback_id, result));
}

void PPB_FileRef_Proxy::OnQueryCallbackCompleteInHost(
    int32_t result,
    const HostResource& host_resource,
    linked_ptr<PP_FileInfo> info,
    uint32_t callback_id) {
  Send(new PpapiMsg_PPBFileRef_QueryCallbackComplete(
      API_ID_PPB_FILE_REF, host_resource, *info, callback_id, result));
}

void PPB_FileRef_Proxy::OnReadDirectoryEntriesCallbackCompleteInHost(
    int32_t result,
    HostCallbackParams params,
    linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files,
    linked_ptr<std::vector<PP_FileType> > file_types) {
  Send(new PpapiMsg_PPBFileRef_ReadDirectoryEntriesCallbackComplete(
      API_ID_PPB_FILE_REF, params.host_resource,
      *files, *file_types, params.callback_id, result));
}

#endif  // !defined(OS_NACL)

}  // namespace proxy
}  // namespace ppapi