[NaCl SDK] Map active fds to absolute paths.

native_client_sdk/src/libraries/nacl_io/kernel_object.h

 // 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.
 
 #ifndef LIBRARIES_NACL_IO_KERNEL_OBJECT_H_
 #define LIBRARIES_NACL_IO_KERNEL_OBJECT_H_
 
 #include <pthread.h>
 
 #include <map>
@@ skipping 12 matching lines @@
 namespace nacl_io {
 
 // KernelObject provides basic functionality for threadsafe access to kernel
 // objects such as the CWD, mount points, file descriptors and file handles.
 // All Kernel locks are private to ensure the lock order.
 //
 // All calls are assumed to be a relative path.
 class KernelObject {
  public:
   struct Descriptor_t {
-    Descriptor_t() : flags(0) {}
-    explicit Descriptor_t(const ScopedKernelHandle& h) : handle(h), flags(0) {}
+    Descriptor_t() : flags(0), path() {}

[binji, 2014/01/08 17:25:43]

nit: path() is unnecessary, the default constructor will be used without it.

+    explicit Descriptor_t(const ScopedKernelHandle& h, const std::string& path_)
+      : handle(h), flags(0), path(path_) {}

[Sam Clegg, 2014/01/08 18:23:24]

The _ suffix is used for member variables in the style guide so
its a little confusing to use it for an argument here.

 
     ScopedKernelHandle handle;
     int flags;
+    std::string path;
   };
   typedef std::vector<Descriptor_t> HandleMap_t;
   typedef std::map<std::string, ScopedFilesystem> FsMap_t;
 
   KernelObject();
   virtual ~KernelObject();
 
   // Attach the given Filesystem object at the specified path.
   Error AttachFsAtPath(const ScopedFilesystem& fs, const std::string& path);
 
@@ skipping 10 matching lines @@
   // Find the filesystem and node for the given path, acquiring/creating it as
   // specified by the |oflags|.
   // Assumes |out_fs| and |out_node| are non-NULL.
   Error AcquireFsAndNode(const std::string& path,
                          int oflags,
                          ScopedFilesystem* out_fs,
                          ScopedNode* out_node);
 
   // Get FD-specific flags (currently only FD_CLOEXEC is supported).
   Error GetFDFlags(int fd, int* out_flags);
+  // Get path at which FD was opened, if available.
+  std::string GetFDPath(int fd);

[binji, 2014/01/08 17:25:43]

remove GetFDPath

   // Set FD-specific flags (currently only FD_CLOEXEC is supported).
   Error SetFDFlags(int fd, int flags);
 
   // Convert from FD to KernelHandle, and acquire the handle.
   // Assumes |out_handle| is non-NULL.
   Error AcquireHandle(int fd, ScopedKernelHandle* out_handle);
+  Error AcquireHandleAndPath(int fd, ScopedKernelHandle *out_handle,
+                             std::string& path);

[binji, 2014/01/08 17:25:43]

Our style guide says that out parameters must be pointers. Reference parameters
should always be const.

 
   // Allocate a new fd and assign the handle to it, while
   // ref counting the handle and associated filesystem.
   // Assumes |handle| is non-NULL;
-  int AllocateFD(const ScopedKernelHandle& handle);
+  int AllocateFD(const ScopedKernelHandle& handle,
+                 const std::string& path = std::string());

[Sam Clegg, 2014/01/08 18:23:24]

No spaces around the "=" sign for default params.

 
   // Assumes |handle| is non-NULL;
-  void FreeAndReassignFD(int fd, const ScopedKernelHandle& handle);
+  void FreeAndReassignFD(int fd, const ScopedKernelHandle& handle,
+                         const std::string& path);
   void FreeFD(int fd);
 
   // Returns or sets CWD
   std::string GetCWD();
   Error SetCWD(const std::string& path);
 
   // Returns parts of the absolute path for the given relative path
   Path GetAbsParts(const std::string& path);
 
  private:
@@ skipping 10 matching lines @@
 
   // Lock to protect cwd_.
   sdk_util::SimpleLock cwd_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(KernelObject);
 };
 
 }  // namespace nacl_io
 
 #endif  // LIBRARIES_NACL_IO_KERNEL_OBJECT_H_