Refactor Pnacl coordinator

ppapi/native_client/src/trusted/plugin/local_temp_file.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 "native_client/src/trusted/plugin/local_temp_file.h"
+
+#include "native_client/src/include/portability_io.h"
+#include "native_client/src/shared/platform/nacl_check.h"
+#include "native_client/src/trusted/plugin/plugin.h"
+#include "native_client/src/trusted/plugin/utility.h"
+
+#include "ppapi/c/ppb_file_io.h"
+#include "ppapi/cpp/file_io.h"
+#include "ppapi/cpp/file_ref.h"
+#include "ppapi/cpp/file_system.h"
+
+//////////////////////////////////////////////////////////////////////
+//  Local temporary file access.
+//////////////////////////////////////////////////////////////////////
+namespace plugin {
+
+namespace {
+nacl::string Random32CharHexString(struct NaClDescRng* rng) {
+  struct NaClDesc* desc = reinterpret_cast<struct NaClDesc*>(rng);
+  const struct NaClDescVtbl* vtbl =
+      reinterpret_cast<const struct NaClDescVtbl*>(desc->base.vtbl);
+
+  nacl::string hex_string;
+  const int32_t kTempFileNameWords = 4;
+  for (int32_t i = 0; i < kTempFileNameWords; ++i) {
+    int32_t num;
+    CHECK(sizeof num == vtbl->Read(desc,
+                                   reinterpret_cast<char*>(&num),
+                                   sizeof num));
+    char frag[16];
+    SNPRINTF(frag, sizeof frag, "%08x", num);
+    hex_string += nacl::string(frag);
+  }
+  return hex_string;
+}
+
+// Some constants for LocalTempFile::GetFD readability.
+const bool kReadOnly = false;
+const bool kWriteable = true;
+} // namespace
+
+uint32_t LocalTempFile::next_identifier = 0;
+
+LocalTempFile::LocalTempFile(Plugin* plugin,
+                             pp::FileSystem* file_system,
+                             const nacl::string &base_dir)
+    : plugin_(plugin),
+      file_system_(file_system),
+      base_dir_(base_dir) {
+  PLUGIN_PRINTF(("LocalTempFile::LocalTempFile (plugin=%p, "
+                 "file_system=%p)\n",
+                 static_cast<void*>(plugin), static_cast<void*>(file_system)));
+  Initialize();
+}
+
+LocalTempFile::LocalTempFile(Plugin* plugin,
+                             pp::FileSystem* file_system,
+                             const nacl::string &base_dir,
+                             const nacl::string &filename)
+    : plugin_(plugin),
+      file_system_(file_system),
+      base_dir_(base_dir),
+      filename_(base_dir + "/" + filename) {
+  PLUGIN_PRINTF(("LocalTempFile::LocalTempFile (plugin=%p, "
+                 "file_system=%p, filename=%s)\n",
+                 static_cast<void*>(plugin), static_cast<void*>(file_system),
+                 filename.c_str()));
+  file_ref_.reset(new pp::FileRef(*file_system_, filename_.c_str()));
+  Initialize();
+}
+
+void LocalTempFile::Initialize() {
+  callback_factory_.Initialize(this);
+  rng_desc_ = (struct NaClDescRng *) malloc(sizeof *rng_desc_);
+  CHECK(rng_desc_ != NULL);
+  CHECK(NaClDescRngCtor(rng_desc_));
+  file_io_trusted_ = static_cast<const PPB_FileIOTrusted*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE));
+  ++next_identifier;
+  SNPRINTF(reinterpret_cast<char *>(identifier_), sizeof identifier_,
+           "%"NACL_PRIu32, next_identifier);
+}
+
+LocalTempFile::~LocalTempFile() {
+  PLUGIN_PRINTF(("LocalTempFile::~LocalTempFile\n"));
+  NaClDescUnref(reinterpret_cast<NaClDesc*>(rng_desc_));
+}
+
+void LocalTempFile::OpenWrite(const pp::CompletionCallback& cb) {
+  done_callback_ = cb;
+  // If we don't already have a filename, generate one.
+  if (filename_ == "") {
+    // Get a random temp file name.
+    filename_ = base_dir_ + "/" + Random32CharHexString(rng_desc_);
+    // Remember the ref used to open for writing and reading.
+    file_ref_.reset(new pp::FileRef(*file_system_, filename_.c_str()));
+  }
+  PLUGIN_PRINTF(("LocalTempFile::OpenWrite: %s\n", filename_.c_str()));
+  // Open the writeable file.
+  write_io_.reset(new pp::FileIO(plugin_));
+  pp::CompletionCallback open_write_cb =
+      callback_factory_.NewCallback(&LocalTempFile::WriteFileDidOpen);
+  write_io_->Open(*file_ref_,
+                  PP_FILEOPENFLAG_WRITE |
+                  PP_FILEOPENFLAG_CREATE |
+                  PP_FILEOPENFLAG_EXCLUSIVE,
+                  open_write_cb);
+}
+
+int32_t LocalTempFile::GetFD(int32_t pp_error,
+                             const pp::Resource& resource,
+                             bool is_writable) {
+  PLUGIN_PRINTF(("LocalTempFile::GetFD (pp_error=%"NACL_PRId32
+                 ", is_writable=%d)\n", pp_error, is_writable));
+  if (pp_error != PP_OK) {
+    PLUGIN_PRINTF(("LocalTempFile::GetFD pp_error != PP_OK\n"));
+    return -1;
+  }
+  int32_t file_desc =
+      file_io_trusted_->GetOSFileDescriptor(resource.pp_resource());
+#if NACL_WINDOWS
+  // Convert the Windows HANDLE from Pepper to a POSIX file descriptor.
+  int32_t open_flags = ((is_writable ? _O_RDWR : _O_RDONLY) | _O_BINARY);
+  int32_t posix_desc = _open_osfhandle(file_desc, open_flags);
+  if (posix_desc == -1) {
+    // Close the Windows HANDLE if it can't be converted.
+    CloseHandle(reinterpret_cast<HANDLE>(file_desc));
+    PLUGIN_PRINTF(("LocalTempFile::GetFD _open_osfhandle failed.\n"));
+    return NACL_NO_FILE_DESC;
+  }
+  file_desc = posix_desc;
+#endif
+  int32_t file_desc_ok_to_close = DUP(file_desc);
+  if (file_desc_ok_to_close == NACL_NO_FILE_DESC) {
+    PLUGIN_PRINTF(("LocalTempFile::GetFD dup failed.\n"));
+    return -1;
+  }
+  return file_desc_ok_to_close;
+}
+
+void LocalTempFile::WriteFileDidOpen(int32_t pp_error) {
+  PLUGIN_PRINTF(("LocalTempFile::WriteFileDidOpen (pp_error=%"
+                 NACL_PRId32")\n", pp_error));
+  if (pp_error == PP_ERROR_FILEEXISTS) {
+    // Filenames clashed, retry.
+    filename_ = "";
+    OpenWrite(done_callback_);
+  }
+  // Run the client's completion callback.
+  pp::Core* core = pp::Module::Get()->core();
+  if (pp_error != PP_OK) {
+    core->CallOnMainThread(0, done_callback_, pp_error);
+    return;
+  }
+  // Remember the object temporary file descriptor.
+  int32_t fd = GetFD(pp_error, *write_io_, kWriteable);
+  if (fd < 0) {
+    core->CallOnMainThread(0, done_callback_, pp_error);
+    return;
+  }
+  // The descriptor for a writeable file needs to have quota management.
+  write_wrapper_.reset(
+      plugin_->wrapper_factory()->MakeFileDescQuota(fd, O_RDWR, identifier_));
+  core->CallOnMainThread(0, done_callback_, PP_OK);
+}
+
+void LocalTempFile::OpenRead(const pp::CompletionCallback& cb) {
+  PLUGIN_PRINTF(("LocalTempFile::OpenRead: %s\n", filename_.c_str()));
+  done_callback_ = cb;
+  // Open the read only file.
+  read_io_.reset(new pp::FileIO(plugin_));
+  pp::CompletionCallback open_read_cb =
+      callback_factory_.NewCallback(&LocalTempFile::ReadFileDidOpen);
+  read_io_->Open(*file_ref_, PP_FILEOPENFLAG_READ, open_read_cb);
+}
+
+void LocalTempFile::ReadFileDidOpen(int32_t pp_error) {
+  PLUGIN_PRINTF(("LocalTempFile::ReadFileDidOpen (pp_error=%"
+                 NACL_PRId32")\n", pp_error));
+  // Run the client's completion callback.
+  pp::Core* core = pp::Module::Get()->core();
+  if (pp_error != PP_OK) {
+    core->CallOnMainThread(0, done_callback_, pp_error);
+    return;
+  }
+  // Remember the object temporary file descriptor.
+  int32_t fd = GetFD(pp_error, *read_io_, kReadOnly);
+  if (fd < 0) {
+    core->CallOnMainThread(0, done_callback_, PP_ERROR_FAILED);
+    return;
+  }
+  read_wrapper_.reset(plugin_->wrapper_factory()->MakeFileDesc(fd, O_RDONLY));
+  core->CallOnMainThread(0, done_callback_, PP_OK);
+}
+
+void LocalTempFile::Close(const pp::CompletionCallback& cb) {
+  PLUGIN_PRINTF(("LocalTempFile::Close: %s\n", filename_.c_str()));
+  // Close the open DescWrappers and FileIOs.
+  if (write_io_.get() != NULL) {
+    write_io_->Close();
+  }
+  write_wrapper_.reset(NULL);
+  write_io_.reset(NULL);
+  if (read_io_.get() != NULL) {
+    read_io_->Close();
+  }
+  read_wrapper_.reset(NULL);
+  read_io_.reset(NULL);
+  // Run the client's completion callback.
+  pp::Core* core = pp::Module::Get()->core();
+  core->CallOnMainThread(0, cb, PP_OK);
+}
+
+void LocalTempFile::Delete(const pp::CompletionCallback& cb) {
+  PLUGIN_PRINTF(("LocalTempFile::Delete: %s\n", filename_.c_str()));
+  file_ref_->Delete(cb);
+}
+
+void LocalTempFile::Rename(const nacl::string& new_name,
+                           const pp::CompletionCallback& cb) {
+  // Rename the temporary file.
+  filename_ = base_dir_ + "/" + new_name;
+  PLUGIN_PRINTF(("LocalTempFile::Rename %s to %s\n",
+                 file_ref_->GetName().AsString().c_str(),
+                 filename_.c_str()));
+  // Remember the old ref until the rename is complete.
+  old_ref_.reset(file_ref_.release());
+  file_ref_.reset(new pp::FileRef(*file_system_, filename_.c_str()));
+  old_ref_->Rename(*file_ref_, cb);
+}
+
+void LocalTempFile::FinishRename() {
+  // Now we can release the old ref.
+  old_ref_.reset(NULL);
+}
+
+} // namespace plugin