Make SharedMemoryHandle a class on Mac.

base/memory/shared_memory_unittest.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 "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/kill.h"
 #include "base/rand_util.h"
@@ skipping 342 matching lines @@
   // segment read/write.  I think the test here is stronger than we actually
   // care about, but there's a remote possibility that sending a file over a
   // pipe would transform it into read/write.
   SharedMemoryHandle handle = readonly_shmem.handle();
 
 #if defined(OS_ANDROID)
   // The "read-only" handle is still writable on Android:
   // http://crbug.com/320865
   (void)handle;
 #elif defined(OS_POSIX)
-  EXPECT_EQ(O_RDONLY, fcntl(handle.fd, F_GETFL) & O_ACCMODE)
+  int handle_fd = SharedMemory::GetFdFromSharedMemoryHandle(handle);
+  EXPECT_EQ(O_RDONLY, fcntl(handle_fd, F_GETFL) & O_ACCMODE)
       << "The descriptor itself should be read-only.";
 
   errno = 0;
-  void* writable = mmap(
-      NULL, contents.size(), PROT_READ | PROT_WRITE, MAP_SHARED, handle.fd, 0);
+  void* writable = mmap(NULL, contents.size(), PROT_READ | PROT_WRITE,
+                        MAP_SHARED, handle_fd, 0);
   int mmap_errno = errno;
   EXPECT_EQ(MAP_FAILED, writable)
       << "It shouldn't be possible to re-mmap the descriptor writable.";
   EXPECT_EQ(EACCES, mmap_errno) << strerror(mmap_errno);
   if (writable != MAP_FAILED)
     EXPECT_EQ(0, munmap(writable, readonly_shmem.mapped_size()));
 
 #elif defined(OS_WIN)
   EXPECT_EQ(NULL, MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, 0))
       << "Shouldn't be able to map memory writable.";
@@ skipping 133 matching lines @@
   const uint32 kTestSize = 1 << 8;
 
   SharedMemory shared_memory;
   SharedMemoryCreateOptions options;
   options.size = kTestSize;
   // Set a file mode creation mask that gives all permissions.
   ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
 
   EXPECT_TRUE(shared_memory.Create(options));
 
-  int shm_fd = shared_memory.handle().fd;
+  int shm_fd =
+      SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
   struct stat shm_stat;
   EXPECT_EQ(0, fstat(shm_fd, &shm_stat));
   // Neither the group, nor others should be able to read the shared memory
   // file.
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
 }
 
 // Create a shared memory object, check its permissions.
 TEST(SharedMemoryTest, FilePermissionsNamed) {
   const uint32 kTestSize = 1 << 8;
 
   SharedMemory shared_memory;
   SharedMemoryCreateOptions options;
   options.size = kTestSize;
   std::string shared_mem_name = "shared_perm_test-" + IntToString(getpid()) +
       "-" + Uint64ToString(RandUint64());
   options.name_deprecated = &shared_mem_name;
   // Set a file mode creation mask that gives all permissions.
   ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
 
   EXPECT_TRUE(shared_memory.Create(options));
   // Clean-up the backing file name immediately, we don't need it.
   EXPECT_TRUE(shared_memory.Delete(shared_mem_name));
 
-  int shm_fd = shared_memory.handle().fd;
+  int shm_fd =
+      SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
   struct stat shm_stat;
   EXPECT_EQ(0, fstat(shm_fd, &shm_stat));
   // Neither the group, nor others should have been able to open the shared
   // memory file while its name existed.
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
 }
 #endif  // !defined(OS_ANDROID)
 
 #endif  // defined(OS_POSIX)
@@ skipping 88 matching lines @@
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 
 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
 
 }  // namespace base