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 PnaclFileDescPair::GetFD readability.
+const bool kReadOnly = false;
+const bool kWriteable = true;
+} // namespace
+
+uint32_t LocalTempFile::next_identifier = 0;
+const nacl::string LocalTempFile::kPnaclTempDir = "/.pnacl";
+
+LocalTempFile::LocalTempFile(Plugin* plugin,
+                             pp::FileSystem* file_system)
+    : plugin_(plugin),
+      file_system_(file_system) {
+  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 &filename)
+    : plugin_(plugin),
+      file_system_(file_system),
+      filename_(kPnaclTempDir + "/" + filename) {

[jvoung - send to chromium..., 2012/05/15 23:51:05]

Maybe we could just have the constructor take an argument that is the base temp
dir here and in the other constructor too, so that this is no longer tied to
pnacl.

[Derek Schuff, 2012/05/16 16:47:46]

Done.

+  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_ = kPnaclTempDir + "/" + 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_ = kPnaclTempDir + "/" + 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