Move common code into process_util.cc

base/shared_memory.h

 // Copyright (c) 2006-2008 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 BASE_SHARED_MEMORY_H_
 #define BASE_SHARED_MEMORY_H_
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
@@ skipping 22 matching lines @@
 typedef ino_t SharedMemoryId;
 // On POSIX, the lock is implemented as a lockf() on the mapped file,
 // so no additional member (or definition of SharedMemoryLock) is
 // needed.
 #endif
 
 // Platform abstraction for shared memory.  Provides a C++ wrapper
 // around the OS primitive for a memory mapped file.
 class SharedMemory {
  public:
-  // Create a new SharedMemory object.
   SharedMemory();
 
   // Create a new SharedMemory object from an existing, open
   // shared memory file.
   SharedMemory(SharedMemoryHandle handle, bool read_only);
 
   // Create a new SharedMemory object from an existing, open
   // shared memory file that was created by a remote process and not shared
   // to the current process.
   SharedMemory(SharedMemoryHandle handle, bool read_only,
-      base::ProcessHandle process);
+               ProcessHandle process);
 
-  // Destructor.  Will close any open files.
+  // Closes any open files.
   ~SharedMemory();
 
   // Return true iff the given handle is valid (i.e. not the distingished
   // invalid value; NULL for a HANDLE and -1 for a file descriptor)
   static bool IsHandleValid(const SharedMemoryHandle& handle);
 
-  // Return invalid handle (see comment above for exact definition).
+  // Returns invalid handle (see comment above for exact definition).
   static SharedMemoryHandle NULLHandle();
 
-  // Close a shared memory handle.
+  // Closes a shared memory handle.
   static void CloseHandle(const SharedMemoryHandle& handle);
 
   // Creates or opens a shared memory segment based on a name.
   // If read_only is true, opens the memory as read-only.
   // If open_existing is true, and the shared memory already exists,
   // opens the existing shared memory and ignores the size parameter.
   // If name is the empty string, use a unique name.
   // Returns true on success, false on failure.
   bool Create(const std::wstring& name, bool read_only, bool open_existing,
               uint32 size);
@@ skipping 22 matching lines @@
   // Note:  This size is only available to the creator of the
   // shared memory, and not to those that opened shared memory
   // created externally.
   // Returns 0 if not opened or unknown.
   uint32 max_size() const { return max_size_; }
 
   // Gets a pointer to the opened memory space if it has been
   // Mapped via Map().  Returns NULL if it is not mapped.
   void *memory() const { return memory_; }
 
-  // Get access to the underlying OS handle for this segment.
+  // Returns the underlying OS handle for this segment.
   // Use of this handle for anything other than an opaque
   // identifier is not portable.
   SharedMemoryHandle handle() const;
 
 #if defined(OS_POSIX)
-  // Return a unique identifier for this shared memory segment. Inode numbers
+  // Returns a unique identifier for this shared memory segment. Inode numbers
   // are technically only unique to a single filesystem. However, we always
   // allocate shared memory backing files from the same directory, so will end
   // up on the same filesystem.
   SharedMemoryId id() const { return inode_; }
 #endif
 
   // Closes the open shared memory segment.
   // It is safe to call Close repeatedly.
   void Close();
 
-  // Share the shared memory to another process.  Attempts
+  // Shares the shared memory to another process.  Attempts
   // to create a platform-specific new_handle which can be
   // used in a remote process to access the shared memory
   // file.  new_handle is an ouput parameter to receive
   // the handle for use in the remote process.
   // Returns true on success, false otherwise.
-  bool ShareToProcess(base::ProcessHandle process,
+  bool ShareToProcess(ProcessHandle process,
                       SharedMemoryHandle* new_handle) {
     return ShareToProcessCommon(process, new_handle, false);
   }
 
   // Logically equivalent to:
   //   bool ok = ShareToProcess(process, new_handle);
   //   Close();
   //   return ok;
   // Note that the memory is unmapped by calling this method, regardless of the
   // return value.
   bool GiveToProcess(ProcessHandle process,
                      SharedMemoryHandle* new_handle) {
     return ShareToProcessCommon(process, new_handle, true);
   }
 
-  // Lock the shared memory.
+  // Locks the shared memory.
   // This is a cross-process lock which may be recursively
   // locked by the same thread.
   // TODO(port):
   // WARNING: on POSIX the lock only works across processes, not
   // across threads.  2 threads in the same process can both grab the
   // lock at the same time.  There are several solutions for this
   // (futex, lockf+anon_semaphore) but none are both clean and common
   // across Mac and Linux.
   void Lock();
 
-  // Release the shared memory lock.
+  // Releases the shared memory lock.
   void Unlock();
 
  private:
 #if defined(OS_POSIX)
   bool CreateOrOpen(const std::wstring &name, int posix_flags, uint32 size);
   bool FilePathForMemoryName(const std::wstring& memname, FilePath* path);
   void LockOrUnlockCommon(int function);
 
 #endif
   bool ShareToProcessCommon(ProcessHandle process,
@@ skipping 31 matching lines @@
   }
 
  private:
   SharedMemory* shared_memory_;
   DISALLOW_EVIL_CONSTRUCTORS(SharedMemoryAutoLock);
 };
 
 }  // namespace base
 
 #endif  // BASE_SHARED_MEMORY_H_