[NaCl SDK] Add some more logging to nacl_io.

native_client_sdk/src/libraries/nacl_io/html5fs/html5_fs_node.cc

 // Copyright 2013 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 "nacl_io/html5fs/html5_fs_node.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <ppapi/c/pp_completion_callback.h>
 #include <ppapi/c/pp_directory_entry.h>
@@ skipping 58 matching lines @@
   return ppapi_flags;
 }
 
 }  // namespace
 
 Error Html5FsNode::FSync() {
   // Cannot call Flush on a directory; simply do nothing.
   if (IsaDir())
     return 0;
 
-  int32_t result = filesystem_->ppapi()->GetFileIoInterface()->Flush(
-      fileio_resource_, PP_BlockUntilComplete());
+  int32_t result =
+      file_io_iface_->Flush(fileio_resource_, PP_BlockUntilComplete());
   if (result != PP_OK)
     return PPErrorToErrno(result);
   return 0;
 }
 
 Error Html5FsNode::GetDents(size_t offs,
                             struct dirent* pdir,
                             size_t size,
                             int* out_bytes) {
   *out_bytes = 0;
 
   // If this is not a directory, fail
   if (!IsaDir())
     return ENOTDIR;
 
   // TODO(binji): Better handling of ino numbers.
   const ino_t kCurDirIno = -1;
   const ino_t kParentDirIno = -2;
   GetDentsHelper helper(kCurDirIno, kParentDirIno);
 
   OutputBuffer output_buf = {NULL, 0};
   PP_ArrayOutput output = {&GetOutputBuffer, &output_buf};
-  int32_t result =
-      filesystem_->ppapi()->GetFileRefInterface()->ReadDirectoryEntries(
-          fileref_resource_, output, PP_BlockUntilComplete());
+  int32_t result = file_ref_iface_->ReadDirectoryEntries(
+      fileref_resource_, output, PP_BlockUntilComplete());
   if (result != PP_OK)
     return PPErrorToErrno(result);
 
   PP_DirectoryEntry* entries = static_cast<PP_DirectoryEntry*>(output_buf.data);
 
   for (int i = 0; i < output_buf.element_count; ++i) {
-    PP_Var file_name_var = filesystem_->ppapi()->GetFileRefInterface()->GetName(
-        entries[i].file_ref);
+    PP_Var file_name_var = file_ref_iface_->GetName(entries[i].file_ref);
 
     // Release the file reference.
     filesystem_->ppapi()->ReleaseResource(entries[i].file_ref);
 
     if (file_name_var.type != PP_VARTYPE_STRING)
       continue;
 
     uint32_t file_name_length;
-    const char* file_name = filesystem_->ppapi()->GetVarInterface()->VarToUtf8(
-        file_name_var, &file_name_length);
+    const char* file_name =
+        var_iface_->VarToUtf8(file_name_var, &file_name_length);
 
     if (file_name) {
       file_name_length =
           std::min(static_cast<size_t>(file_name_length),
                    MEMBER_SIZE(dirent, d_name) - 1);  // -1 for NULL.
 
       // TODO(binji): Better handling of ino numbers.
       helper.AddDirent(1, file_name, file_name_length);
     }
 
-    filesystem_->ppapi()->GetVarInterface()->Release(file_name_var);
+    var_iface_->Release(file_name_var);
   }
 
   // Release the output buffer.
   free(output_buf.data);
 
   return helper.GetDents(offs, pdir, size, out_bytes);
 }
 
 Error Html5FsNode::GetStat(struct stat* stat) {
   AUTO_LOCK(node_lock_);
 
   PP_FileInfo info;
-  int32_t result = filesystem_->ppapi()->GetFileRefInterface()->Query(
-      fileref_resource_, &info, PP_BlockUntilComplete());
+  int32_t result =
+      file_ref_iface_->Query(fileref_resource_, &info, PP_BlockUntilComplete());
   if (result != PP_OK)
     return PPErrorToErrno(result);
 
   // Fill in known info here.
   memcpy(stat, &stat_, sizeof(stat_));
 
   // Fill in the additional info from ppapi.
   switch (info.type) {
     case PP_FILETYPE_REGULAR:
       stat->st_mode |= S_IFREG;
@@ skipping 15 matching lines @@
 
 Error Html5FsNode::Read(const HandleAttr& attr,
                         void* buf,
                         size_t count,
                         int* out_bytes) {
   *out_bytes = 0;
 
   if (IsaDir())
     return EISDIR;
 
-  int32_t result = filesystem_->ppapi()->GetFileIoInterface()->Read(
-      fileio_resource_,
-      attr.offs,
-      static_cast<char*>(buf),
-      static_cast<int32_t>(count),
-      PP_BlockUntilComplete());
+  int32_t result = file_io_iface_->Read(fileio_resource_,
+                                        attr.offs,
+                                        static_cast<char*>(buf),
+                                        static_cast<int32_t>(count),
+                                        PP_BlockUntilComplete());
   if (result < 0)
     return PPErrorToErrno(result);
 
   *out_bytes = result;
   return 0;
 }
 
 Error Html5FsNode::FTruncate(off_t size) {
   if (IsaDir())
     return EISDIR;
 
-  int32_t result = filesystem_->ppapi()->GetFileIoInterface()->SetLength(
+  int32_t result = file_io_iface_->SetLength(
       fileio_resource_, size, PP_BlockUntilComplete());
   if (result != PP_OK)
     return PPErrorToErrno(result);
   return 0;
 }
 
 Error Html5FsNode::Write(const HandleAttr& attr,
                          const void* buf,
                          size_t count,
                          int* out_bytes) {
   *out_bytes = 0;
 
   if (IsaDir())
     return EISDIR;
 
-  int32_t result = filesystem_->ppapi()->GetFileIoInterface()->Write(
-      fileio_resource_,
-      attr.offs,
-      static_cast<const char*>(buf),
-      static_cast<int32_t>(count),
-      PP_BlockUntilComplete());
+  int32_t result = file_io_iface_->Write(fileio_resource_,
+                                         attr.offs,
+                                         static_cast<const char*>(buf),
+                                         static_cast<int32_t>(count),
+                                         PP_BlockUntilComplete());
   if (result < 0)
     return PPErrorToErrno(result);
 
   *out_bytes = result;
   return 0;
 }
 
 int Html5FsNode::GetType() {
   return fileio_resource_ ? S_IFREG : S_IFDIR;
 }
 
 Error Html5FsNode::GetSize(off_t* out_size) {
   *out_size = 0;
 
   if (IsaDir())
     return 0;
 
   AUTO_LOCK(node_lock_);
 
   PP_FileInfo info;
-  int32_t result = filesystem_->ppapi()->GetFileIoInterface()->Query(
-      fileio_resource_, &info, PP_BlockUntilComplete());
+  int32_t result =
+      file_io_iface_->Query(fileio_resource_, &info, PP_BlockUntilComplete());
   if (result != PP_OK)
     return PPErrorToErrno(result);
 
   *out_size = info.size;
   return 0;
 }
 
 Html5FsNode::Html5FsNode(Filesystem* filesystem, PP_Resource fileref_resource)
     : Node(filesystem),
       fileref_resource_(fileref_resource),
       fileio_resource_(0) {
 }
 
 Error Html5FsNode::Init(int open_flags) {
   Error error = Node::Init(open_flags);
   if (error)
     return error;
 
+  file_io_iface_ = filesystem_->ppapi()->GetFileIoInterface();
+  file_ref_iface_ = filesystem_->ppapi()->GetFileRefInterface();
+  var_iface_ = filesystem_->ppapi()->GetVarInterface();
+
+  if (!(file_io_iface_ && file_ref_iface_ && var_iface_)) {
+    LOG_ERROR("Got NULL interface(s): %s%s%s",
+              file_ref_iface_ ? "" : "FileRef",
+              file_io_iface_ ? "" : "FileIo ",
+              var_iface_ ? "" : "Var ");
+    return EIO;
+  }
+
   // First query the FileRef to see if it is a file or directory.
   PP_FileInfo file_info;
-  int32_t query_result = filesystem_->ppapi()->GetFileRefInterface()->Query(
+  int32_t query_result = file_ref_iface_->Query(
       fileref_resource_, &file_info, PP_BlockUntilComplete());
   // If this is a directory, do not get a FileIO.
   if (query_result == PP_OK && file_info.type == PP_FILETYPE_DIRECTORY)
     return 0;
 
-  FileIoInterface* file_io = filesystem_->ppapi()->GetFileIoInterface();
-  fileio_resource_ = file_io->Create(filesystem_->ppapi()->GetInstance());
-  if (!fileio_resource_)
-    return ENOSYS;
+  fileio_resource_ =
+      file_io_iface_->Create(filesystem_->ppapi()->GetInstance());
+  if (!fileio_resource_) {
+    LOG_ERROR("Couldn't create FileIo resource.");
+    return EIO;
+  }
 
-  int32_t open_result = file_io->Open(fileio_resource_,
-                                      fileref_resource_,
-                                      OpenFlagsToPPAPIOpenFlags(open_flags),
-                                      PP_BlockUntilComplete());
+  int32_t open_result =
+      file_io_iface_->Open(fileio_resource_,
+                           fileref_resource_,
+                           OpenFlagsToPPAPIOpenFlags(open_flags),
+                           PP_BlockUntilComplete());
   if (open_result != PP_OK)
     return PPErrorToErrno(open_result);
   return 0;
 }
 
 void Html5FsNode::Destroy() {
   FSync();
 
   if (fileio_resource_) {
-    filesystem_->ppapi()->GetFileIoInterface()->Close(fileio_resource_);
+    file_io_iface_->Close(fileio_resource_);
     filesystem_->ppapi()->ReleaseResource(fileio_resource_);
   }
 
   filesystem_->ppapi()->ReleaseResource(fileref_resource_);
   fileio_resource_ = 0;
   fileref_resource_ = 0;
   Node::Destroy();
 }
 
 }  // namespace nacl_io