Pepper: Move FileRef to the "new" resource proxy.

content/renderer/pepper/ppb_file_ref_impl.cc

Index: content/renderer/pepper/ppb_file_ref_impl.cc
diff --git a/content/renderer/pepper/ppb_file_ref_impl.cc b/content/renderer/pepper/ppb_file_ref_impl.cc
deleted file mode 100644
index 7044208c9be529f257c1a3cdbd86bcbc4982b8d4..0000000000000000000000000000000000000000
--- a/content/renderer/pepper/ppb_file_ref_impl.cc
+++ /dev/null
@@ -1,556 +0,0 @@
-// 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/ppb_file_ref_impl.h"
-
-#include "base/files/file_util_proxy.h"
-#include "base/platform_file.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "content/child/fileapi/file_system_dispatcher.h"
-#include "content/common/view_messages.h"
-#include "content/renderer/pepper/common.h"
-#include "content/renderer/pepper/pepper_file_system_host.h"
-#include "content/renderer/pepper/pepper_helper_impl.h"
-#include "content/renderer/pepper/plugin_module.h"
-#include "content/renderer/pepper/renderer_ppapi_host_impl.h"
-#include "content/renderer/render_thread_impl.h"
-#include "net/base/escape.h"
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/c/ppb_file_io.h"
-#include "ppapi/host/ppapi_host.h"
-#include "ppapi/shared_impl/file_type_conversion.h"
-#include "ppapi/shared_impl/time_conversion.h"
-#include "ppapi/shared_impl/var.h"
-#include "ppapi/thunk/enter.h"
-#include "ppapi/thunk/ppb_file_system_api.h"
-#include "url/gurl.h"
-#include "webkit/common/fileapi/directory_entry.h"
-#include "webkit/common/fileapi/file_system_util.h"
-
-using ppapi::HostResource;
-using ppapi::PPB_FileRef_CreateInfo;
-using ppapi::PPTimeToTime;
-using ppapi::StringVar;
-using ppapi::TrackedCallback;
-using ppapi::thunk::EnterResourceNoLock;
-using ppapi::thunk::PPB_FileRef_API;
-using ppapi::thunk::PPB_FileSystem_API;
-
-namespace content {
-
-namespace {
-
-bool IsValidLocalPath(const std::string& path) {
-  // The path must start with '/'
-  if (path.empty() || path[0] != '/')
-    return false;
-
-  // The path must contain valid UTF-8 characters.
-  if (!IsStringUTF8(path))
-    return false;
-
-#if defined(OS_WIN)
-  base::FilePath::StringType path_win(path.begin(), path.end());
-  base::FilePath file_path(path_win);
-#else
-  base::FilePath file_path(path);
-#endif
-  if (file_path.ReferencesParent())
-    return false;
-
-  return true;
-}
-
-void TrimTrailingSlash(std::string* path) {
-  // If this path ends with a slash, then normalize it away unless path is the
-  // root path.
-  if (path->size() > 1 && path->at(path->size() - 1) == '/')
-    path->erase(path->size() - 1, 1);
-}
-
-std::string GetNameForExternalFilePath(const base::FilePath& in_path) {
-  const base::FilePath::StringType& path = in_path.value();
-  size_t pos = path.rfind(base::FilePath::kSeparators[0]);
-  CHECK(pos != base::FilePath::StringType::npos);
-#if defined(OS_WIN)
-  return WideToUTF8(path.substr(pos + 1));
-#elif defined(OS_POSIX)
-  return path.substr(pos + 1);
-#else
-#error "Unsupported platform."
-#endif
-}
-
-std::string GetNameForVirtualFilePath(const std::string& path) {
-  if (path.size() == 1 && path[0] == '/')
-    return path;
-
-  // There should always be a leading slash at least!
-  size_t pos = path.rfind('/');
-  CHECK(pos != std::string::npos);
-  return path.substr(pos + 1);
-}
-
-void IgnoreCloseCallback(base::PlatformFileError error_code) {
-}
-
-void PlatformFileInfoToPPFileInfo(
-    const base::PlatformFileInfo& file_info,
-    PP_FileSystemType file_system_type,
-    PP_FileInfo* info) {
-  DCHECK(info);
-  ::ppapi::PlatformFileInfoToPepperFileInfo(file_info, file_system_type, info);
-}
-
-void GetFileInfoCallback(
-    scoped_refptr<base::TaskRunner> task_runner,
-    base::PlatformFile file,
-    linked_ptr<PP_FileInfo> info,
-    scoped_refptr<TrackedCallback> callback,
-    base::PlatformFileError error_code,
-    const base::PlatformFileInfo& file_info) {
-  base::FileUtilProxy::Close(
-      task_runner.get(), file, base::Bind(&IgnoreCloseCallback));
-
-  if (!TrackedCallback::IsPending(callback))
-    return;
-
-  int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
-  if (pp_error != PP_OK) {
-    callback->Run(pp_error);
-    return;
-  }
-
-  PlatformFileInfoToPPFileInfo(
-      file_info, PP_FILESYSTEMTYPE_EXTERNAL, info.get());
-
-  callback->Run(PP_OK);
-}
-
-void QueryCallback(scoped_refptr<base::TaskRunner> task_runner,
-                   linked_ptr<PP_FileInfo> info,
-                   scoped_refptr<TrackedCallback> callback,
-                   base::PlatformFileError error_code,
-                   base::PassPlatformFile passed_file) {
-  if (!TrackedCallback::IsPending(callback))
-    return;
-
-  int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
-  if (pp_error != PP_OK) {
-    callback->Run(pp_error);
-    return;
-  }
-  base::PlatformFile file = passed_file.ReleaseValue();
-
-  if (!base::FileUtilProxy::GetFileInfoFromPlatformFile(
-          task_runner.get(),
-          file,
-          base::Bind(
-              &GetFileInfoCallback, task_runner, file, info, callback))) {
-    base::FileUtilProxy::Close(
-        task_runner.get(), file, base::Bind(&IgnoreCloseCallback));
-    callback->Run(PP_ERROR_FAILED);
-  }
-}
-
-void DidReadMetadata(
-    scoped_refptr< ::ppapi::TrackedCallback> callback,
-    linked_ptr<PP_FileInfo> info,
-    PP_FileSystemType file_system_type,
-    const base::PlatformFileInfo& file_info) {
-  if (!TrackedCallback::IsPending(callback))
-    return;
-
-  PlatformFileInfoToPPFileInfo(file_info, file_system_type, info.get());
-  callback->Run(PP_OK);
-}
-
-void DidReadDirectory(
-    scoped_refptr< ::ppapi::TrackedCallback> callback,
-    PPB_FileRef_Impl* dir_ref,
-    linked_ptr<std::vector< ::ppapi::PPB_FileRef_CreateInfo> > dir_files,
-    linked_ptr<std::vector<PP_FileType> > dir_file_types,
-    const std::vector<fileapi::DirectoryEntry>& entries,
-    bool has_more) {
-  if (!TrackedCallback::IsPending(callback))
-    return;
-
-  // The current filesystem backend always returns false.
-  DCHECK(!has_more);
-
-  DCHECK(dir_ref);
-  DCHECK(dir_files.get());
-  DCHECK(dir_file_types.get());
-
-  std::string dir_path = dir_ref->GetCreateInfo().path;
-  if (dir_path.empty() || dir_path[dir_path.size() - 1] != '/')
-    dir_path += '/';
-
-  for (size_t i = 0; i < entries.size(); ++i) {
-    const fileapi::DirectoryEntry& entry = entries[i];
-    scoped_refptr<PPB_FileRef_Impl> file_ref(PPB_FileRef_Impl::CreateInternal(
-        dir_ref->pp_instance(),
-        dir_ref->file_system_resource(),
-        dir_path + fileapi::FilePathToString(base::FilePath(entry.name))));
-    dir_files->push_back(file_ref->GetCreateInfo());
-    dir_file_types->push_back(
-        entry.is_directory ? PP_FILETYPE_DIRECTORY : PP_FILETYPE_REGULAR);
-    // Add a ref count on behalf of the plugin side.
-    file_ref->GetReference();
-  }
-  CHECK_EQ(dir_files->size(), dir_file_types->size());
-
-  callback->Run(PP_OK);
-}
-
-void DidFinishFileOperation(
-    scoped_refptr< ::ppapi::TrackedCallback> callback,
-    base::PlatformFileError error_code) {
-  if (callback->completed())
-    return;
-  callback->Run(::ppapi::PlatformFileErrorToPepperError(error_code));
-}
-
-}  // namespace
-
-PPB_FileRef_Impl::PPB_FileRef_Impl(const PPB_FileRef_CreateInfo& info,
-                                   PP_Resource file_system)
-    : PPB_FileRef_Shared(::ppapi::OBJECT_IS_IMPL, info),
-      file_system_(file_system),
-      external_file_system_path_(),
-      routing_id_(MSG_ROUTING_NONE) {
-  if (RenderThreadImpl::current()) {  // NULL in tests.
-    routing_id_ = RenderThreadImpl::current()->GenerateRoutingID();
-    ChildThread::current()->AddRoute(routing_id_, this);
-  }
-}
-
-PPB_FileRef_Impl::PPB_FileRef_Impl(const PPB_FileRef_CreateInfo& info,
-                                   const base::FilePath& external_file_path)
-    : PPB_FileRef_Shared(::ppapi::OBJECT_IS_IMPL, info),
-      file_system_(),
-      external_file_system_path_(external_file_path),
-      routing_id_(MSG_ROUTING_NONE) {
-  if (RenderThreadImpl::current()) {  // NULL in tests.
-    routing_id_ = RenderThreadImpl::current()->GenerateRoutingID();
-    ChildThread::current()->AddRoute(routing_id_, this);
-  }
-}
-
-PPB_FileRef_Impl::~PPB_FileRef_Impl() {
-  if (RenderThreadImpl::current())
-    ChildThread::current()->RemoveRoute(routing_id_);
-}
-
-// static
-PPB_FileRef_Impl* PPB_FileRef_Impl::CreateInternal(PP_Instance instance,
-                                                   PP_Resource pp_file_system,
-                                                   const std::string& path) {
-  PepperFileSystemHost* fs_host = GetFileSystemHostInternal(
-      instance, pp_file_system);
-  if (!fs_host)
-    return 0;
-
-  PP_FileSystemType type = fs_host->GetType();
-  if (type != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
-      type != PP_FILESYSTEMTYPE_LOCALTEMPORARY &&
-      type != PP_FILESYSTEMTYPE_EXTERNAL &&
-      type != PP_FILESYSTEMTYPE_ISOLATED)
-    return 0;
-
-  PPB_FileRef_CreateInfo info;
-  info.resource = HostResource::MakeInstanceOnly(instance);
-  info.file_system_plugin_resource = pp_file_system;
-  info.file_system_type = type;
-
-  // Validate the path.
-  info.path = path;
-  if (!IsValidLocalPath(info.path))
-    return 0;
-  TrimTrailingSlash(&info.path);
-
-  info.name = GetNameForVirtualFilePath(info.path);
-
-  PPB_FileRef_Impl* file_ref = new PPB_FileRef_Impl(info, pp_file_system);
-
-  RendererPpapiHostImpl* renderer_host =
-      RendererPpapiHostImpl::GetForPPInstance(instance);
-  if (renderer_host && renderer_host->IsRunningInProcess())
-    file_ref->AddFileSystemRefCount();
-  return file_ref;
-}
-
-// static
-PPB_FileRef_Impl* PPB_FileRef_Impl::CreateExternal(
-    PP_Instance instance,
-    const base::FilePath& external_file_path,
-    const std::string& display_name) {
-  PPB_FileRef_CreateInfo info;
-  info.resource = HostResource::MakeInstanceOnly(instance);
-  info.file_system_plugin_resource = 0;
-  info.file_system_type = PP_FILESYSTEMTYPE_EXTERNAL;
-  if (display_name.empty())
-    info.name = GetNameForExternalFilePath(external_file_path);
-  else
-    info.name = display_name;
-
-  return new PPB_FileRef_Impl(info, external_file_path);
-}
-
-PP_Resource PPB_FileRef_Impl::GetParent() {
-  if (GetFileSystemType() == PP_FILESYSTEMTYPE_EXTERNAL)
-    return 0;
-
-  const std::string& virtual_path = GetCreateInfo().path;
-
-  // There should always be a leading slash at least!
-  size_t pos = virtual_path.rfind('/');
-  CHECK(pos != std::string::npos);
-
-  // If the path is "/foo", then we want to include the slash.
-  if (pos == 0)
-    pos++;
-  std::string parent_path = virtual_path.substr(0, pos);
-
-  scoped_refptr<PPB_FileRef_Impl> parent_ref(
-      CreateInternal(pp_instance(), file_system_, parent_path));
-  if (!parent_ref.get())
-    return 0;
-  return parent_ref->GetReference();
-}
-
-int32_t PPB_FileRef_Impl::MakeDirectory(
-    PP_Bool make_ancestors,
-    scoped_refptr<TrackedCallback> callback) {
-  if (!IsValidNonExternalFileSystem())
-    return PP_ERROR_NOACCESS;
-
-  FileSystemDispatcher* file_system_dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  file_system_dispatcher->CreateDirectory(
-      GetFileSystemURL(), false /* exclusive */, PP_ToBool(make_ancestors),
-      base::Bind(&DidFinishFileOperation, callback));
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t PPB_FileRef_Impl::Touch(PP_Time last_access_time,
-                                PP_Time last_modified_time,
-                                scoped_refptr<TrackedCallback> callback) {
-  if (!IsValidNonExternalFileSystem())
-    return PP_ERROR_NOACCESS;
-
-  FileSystemDispatcher* file_system_dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  file_system_dispatcher->TouchFile(
-      GetFileSystemURL(),
-      PPTimeToTime(last_access_time),
-      PPTimeToTime(last_modified_time),
-      base::Bind(&DidFinishFileOperation, callback));
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t PPB_FileRef_Impl::Delete(scoped_refptr<TrackedCallback> callback) {
-  if (!IsValidNonExternalFileSystem())
-    return PP_ERROR_NOACCESS;
-
-  FileSystemDispatcher* file_system_dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  file_system_dispatcher->Remove(
-      GetFileSystemURL(),
-      false /* recursive */,
-      base::Bind(&DidFinishFileOperation, callback));
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t PPB_FileRef_Impl::Rename(PP_Resource new_pp_file_ref,
-                                 scoped_refptr<TrackedCallback> callback) {
-  EnterResourceNoLock<PPB_FileRef_API> enter(new_pp_file_ref, true);
-  if (enter.failed())
-    return PP_ERROR_BADRESOURCE;
-  PPB_FileRef_Impl* new_file_ref =
-      static_cast<PPB_FileRef_Impl*>(enter.object());
-
-  if (!IsValidNonExternalFileSystem() ||
-      file_system_ != new_file_ref->file_system_)
-    return PP_ERROR_NOACCESS;
-
-  // TODO(viettrungluu): Also cancel when the new file ref is destroyed?
-  // http://crbug.com/67624
-  FileSystemDispatcher* file_system_dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  file_system_dispatcher->Move(
-      GetFileSystemURL(), new_file_ref->GetFileSystemURL(),
-      base::Bind(&DidFinishFileOperation, callback));
-  return PP_OK_COMPLETIONPENDING;
-}
-
-PP_Var PPB_FileRef_Impl::GetAbsolutePath() {
-  if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL)
-    return GetPath();
-  if (!external_path_var_.get()) {
-    external_path_var_ =
-        new StringVar(external_file_system_path_.AsUTF8Unsafe());
-  }
-  return external_path_var_->GetPPVar();
-}
-
-base::FilePath PPB_FileRef_Impl::GetSystemPath() const {
-  if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL) {
-    NOTREACHED();
-    return base::FilePath();
-  }
-  return external_file_system_path_;
-}
-
-GURL PPB_FileRef_Impl::GetFileSystemURL() const {
-  if (GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
-      GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALTEMPORARY &&
-      GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL &&
-      GetFileSystemType() != PP_FILESYSTEMTYPE_ISOLATED) {
-    NOTREACHED();
-    return GURL();
-  }
-
-  const std::string& virtual_path = GetCreateInfo().path;
-  CHECK(!virtual_path.empty());  // Should always be at least "/".
-
-  // Since |virtual_path_| starts with a '/', it looks like an absolute path.
-  // We need to trim off the '/' before calling Resolve, as FileSystem URLs
-  // start with a storage type identifier that looks like a path segment.
-
-  PepperFileSystemHost* host = GetFileSystemHost();
-  if (!host)
-    return GURL();
-
-  return GURL(host->GetRootUrl()).Resolve(net::EscapePath(
-      virtual_path.substr(1)));
-}
-
-bool PPB_FileRef_Impl::OnMessageReceived(const IPC::Message& msg) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PPB_FileRef_Impl, msg)
-    IPC_MESSAGE_HANDLER(ViewMsg_AsyncOpenPepperFile_ACK, OnAsyncFileOpened)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void PPB_FileRef_Impl::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;
-}
-
-bool PPB_FileRef_Impl::IsValidNonExternalFileSystem() const {
-  PepperFileSystemHost* host = GetFileSystemHost();
-  return HasValidFileSystem() && host &&
-      host->GetType() != PP_FILESYSTEMTYPE_EXTERNAL;
-}
-
-bool PPB_FileRef_Impl::HasValidFileSystem() const {
-  PepperFileSystemHost* host = GetFileSystemHost();
-  return host && host->IsOpened();
-}
-
-int32_t PPB_FileRef_Impl::Query(PP_FileInfo* info,
-                                scoped_refptr<TrackedCallback> callback) {
-  NOTREACHED();
-  return PP_ERROR_FAILED;
-}
-
-int32_t PPB_FileRef_Impl::QueryInHost(
-    linked_ptr<PP_FileInfo> info,
-    scoped_refptr<TrackedCallback> callback) {
-  if (!file_system_) {
-    // External file system
-    // We have to do something totally different for external file systems.
-
-    // TODO(teravest): Use the SequencedWorkerPool instead.
-    scoped_refptr<base::TaskRunner> task_runner =
-        RenderThreadImpl::current()->GetFileThreadMessageLoopProxy();
-
-    int message_id = pending_async_open_files_.Add(new AsyncOpenFileCallback(
-        base::Bind(&QueryCallback, task_runner, info, callback)));
-    RenderThreadImpl::current()->Send(new ViewHostMsg_AsyncOpenPepperFile(
-        routing_id_,
-        GetSystemPath(),
-        PP_FILEOPENFLAG_READ,
-        message_id));
-  } else {
-    // Non-external file system
-    if (!HasValidFileSystem())
-      return PP_ERROR_NOACCESS;
-
-    PP_FileSystemType file_system_type = GetFileSystemHost()->GetType();
-    FileSystemDispatcher* file_system_dispatcher =
-        ChildThread::current()->file_system_dispatcher();
-    file_system_dispatcher->ReadMetadata(
-        GetFileSystemURL(),
-        base::Bind(&DidReadMetadata, callback, info, file_system_type),
-        base::Bind(&DidFinishFileOperation, callback));
-  }
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t PPB_FileRef_Impl::ReadDirectoryEntries(
-    const PP_ArrayOutput& output,
-    scoped_refptr<TrackedCallback> callback) {
-  NOTREACHED();
-  return PP_ERROR_FAILED;
-}
-
-int32_t PPB_FileRef_Impl::ReadDirectoryEntriesInHost(
-    linked_ptr<std::vector< ::ppapi::PPB_FileRef_CreateInfo> > files,
-    linked_ptr<std::vector<PP_FileType> > file_types,
-    scoped_refptr<TrackedCallback> callback) {
-  if (!IsValidNonExternalFileSystem())
-    return PP_ERROR_NOACCESS;
-
-  // TODO(yzshen): Passing base::Unretained(this) to the callback could
-  // be dangerous.
-  FileSystemDispatcher* file_system_dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  file_system_dispatcher->ReadDirectory(
-      GetFileSystemURL(),
-      base::Bind(&DidReadDirectory,
-                 callback, base::Unretained(this), files, file_types),
-      base::Bind(&DidFinishFileOperation, callback));
-  return PP_OK_COMPLETIONPENDING;
-}
-
-PepperFileSystemHost* PPB_FileRef_Impl::GetFileSystemHost() const {
-  return GetFileSystemHostInternal(pp_instance(), file_system_);
-}
-
-PepperFileSystemHost* PPB_FileRef_Impl::GetFileSystemHostInternal(
-    PP_Instance instance, PP_Resource resource) {
-  const ppapi::host::PpapiHost* ppapi_host =
-      RendererPpapiHost::GetForPPInstance(instance)->GetPpapiHost();
-  if (!resource || !ppapi_host)
-    return NULL;
-  ppapi::host::ResourceHost* resource_host =
-      ppapi_host->GetResourceHost(resource);
-  if (resource_host && resource_host->IsFileSystemHost())
-    return static_cast<PepperFileSystemHost*>(resource_host);
-  return NULL;
-}
-
-}  // namespace content