Bitmap transport

base/shared_memory_posix.cc

 // 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.
 
 #include "base/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/platform_thread.h"
 #include "base/string_util.h"
 
 namespace base {
 
 namespace {
 // Paranoia. Semaphores and shared memory segments should live in different
 // namespaces, but who knows what's out there.
 const char kSemaphoreSuffix[] = "-sem";
 }
 
 SharedMemory::SharedMemory()
     : mapped_file_(-1),
+      inode_(0),
       memory_(NULL),
       read_only_(false),
       max_size_(0) {
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
     : mapped_file_(handle.fd),
+      inode_(0),
       memory_(NULL),
       read_only_(read_only),
       max_size_(0) {
+  struct stat st;
+  if (fstat(handle.fd, &st) == 0) {
+    // If fstat fails, then the file descriptor is invalid and we'll learn this
+    // fact when Map() fails.
+    inode_ = st.st_ino;
+  }
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
                            ProcessHandle process)
     : mapped_file_(handle.fd),
       memory_(NULL),
       read_only_(read_only),
       max_size_(0) {
   // We don't handle this case yet (note the ignored parameter); let's die if
   // someone comes calling.
@@ skipping 153 matching lines @@
       // possibly shrink.
       if ((ftruncate(fileno(fp), size) != 0) ||
           (fflush(fp) != 0)) {
         return false;
       }
     }
   }
 
   mapped_file_ = dup(fileno(fp));
   DCHECK(mapped_file_ >= 0);
+
+  struct stat st;
+  if (fstat(mapped_file_, &st))
+    NOTREACHED();
+  inode_ = st.st_ino;
+
   return true;
 }
 
 bool SharedMemory::Map(size_t bytes) {
   if (mapped_file_ == -1)
     return false;
 
   memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
                  MAP_SHARED, mapped_file_, 0);
 
@@ skipping 66 matching lines @@
 
 void SharedMemory::Unlock() {
   LockOrUnlockCommon(F_ULOCK);
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
   return FileDescriptor(mapped_file_, false);
 }
 
 }  // namespace base