Add a GUID to base::SharedMemoryHandle.

base/memory/shared_memory_mac_unittest.cc

 // Copyright 2015 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 <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <servers/bootstrap.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
+#include "base/unguessable_token.h"
 #include "testing/multiprocess_func_list.h"
 
 namespace base {
 
 namespace {
 
 // Gets the current and maximum protection levels of the memory region.
 // Returns whether the operation was successful.
 // |current| and |max| are output variables only populated on success.
 bool GetProtections(void* address, size_t size, int* current, int* max) {
@@ skipping 15 matching lines @@
     return false;
   }
 
   *current = basic_info.protection;
   *max = basic_info.max_protection;
   return true;
 }
 
 // Creates a new SharedMemory with the given |size|, filled with 'a'.
 std::unique_ptr<SharedMemory> CreateSharedMemory(int size) {
-  SharedMemoryHandle shm(size);
+  SharedMemoryHandle shm(size, UnguessableToken::Create());
   if (!shm.IsValid()) {
     LOG(ERROR) << "Failed to make SharedMemoryHandle";
     return nullptr;
   }
   std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
   shared_memory->Map(size);
   memset(shared_memory->memory(), 'a', size);
   return shared_memory;
 }
 
@@ skipping 171 matching lines @@
   ASSERT_TRUE(spawn_child_.process.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
 MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryClient) {
   mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
   // The next mach port should be for a memory object.
   mach_port_t memory_object = ReceiveMachPort(client_port.get());
   SharedMemoryHandle shm(memory_object,
-                         SharedMemoryMacMultiProcessTest::s_memory_size);
+                         SharedMemoryMacMultiProcessTest::s_memory_size,
+                         UnguessableToken::Create());
   SharedMemory shared_memory(shm, false);
   shared_memory.Map(SharedMemoryMacMultiProcessTest::s_memory_size);
   const char* start = static_cast<const char*>(shared_memory.memory());
   for (int i = 0; i < SharedMemoryMacMultiProcessTest::s_memory_size; ++i) {
     DCHECK_EQ(start[i], 'a');
   }
   return 0;
 }
 
 // Tests that mapping shared memory with an offset works correctly.
 TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemoryWithOffset) {
   SetUpChild("MachBasedSharedMemoryWithOffsetClient");
 
-  SharedMemoryHandle shm(s_memory_size);
+  SharedMemoryHandle shm(s_memory_size, UnguessableToken::Create());
   ASSERT_TRUE(shm.IsValid());
   SharedMemory shared_memory(shm, false);
   shared_memory.Map(s_memory_size);
 
   size_t page_size = SysInfo::VMAllocationGranularity();
   char* start = static_cast<char*>(shared_memory.memory());
   memset(start, 'a', page_size);
   memset(start + page_size, 'b', page_size);
   memset(start + 2 * page_size, 'c', page_size);
 
   // Send the underlying memory object to the client process.
   SendMachPort(
       client_port_.get(), shm.GetMemoryObject(), MACH_MSG_TYPE_COPY_SEND);
   int rv = -1;
   ASSERT_TRUE(spawn_child_.process.WaitForExitWithTimeout(
       TestTimeouts::action_timeout(), &rv));
   EXPECT_EQ(0, rv);
 }
 
 MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryWithOffsetClient) {
   mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
   // The next mach port should be for a memory object.
   mach_port_t memory_object = ReceiveMachPort(client_port.get());
   SharedMemoryHandle shm(memory_object,
-                         SharedMemoryMacMultiProcessTest::s_memory_size);
+                         SharedMemoryMacMultiProcessTest::s_memory_size,
+                         UnguessableToken::Create());
   SharedMemory shared_memory(shm, false);
   size_t page_size = SysInfo::VMAllocationGranularity();
   shared_memory.MapAt(page_size, 2 * page_size);
   const char* start = static_cast<const char*>(shared_memory.memory());
   for (size_t i = 0; i < page_size; ++i) {
     DCHECK_EQ(start[i], 'b');
   }
   for (size_t i = page_size; i < 2 * page_size; ++i) {
     DCHECK_EQ(start[i], 'c');
   }
   return 0;
 }
 
 // Tests that duplication and closing has the right effect on Mach reference
 // counts.
 TEST_F(SharedMemoryMacMultiProcessTest, MachDuplicateAndClose) {
   mach_msg_type_number_t active_name_count = GetActiveNameCount();
 
   // Making a new SharedMemoryHandle increments the name count.
-  SharedMemoryHandle shm(s_memory_size);
+  SharedMemoryHandle shm(s_memory_size, UnguessableToken::Create());
   ASSERT_TRUE(shm.IsValid());
   EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
 
   // Duplicating the SharedMemoryHandle increments the ref count, but doesn't
   // make a new name.
   shm.Duplicate();
   EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
 
   // Closing the SharedMemoryHandle decrements the ref count. The first time has
   // no effect.
@@ skipping 18 matching lines @@
   EXPECT_EQ(active_name_count, GetActiveNameCount());
 }
 
 // Tests that passing a SharedMemoryHandle to a SharedMemory object also passes
 // ownership, and that destroying the SharedMemory closes the SharedMemoryHandle
 // as well.
 TEST_F(SharedMemoryMacMultiProcessTest, MachSharedMemoryTakesOwnership) {
   mach_msg_type_number_t active_name_count = GetActiveNameCount();
 
   // Making a new SharedMemoryHandle increments the name count.
-  SharedMemoryHandle shm(s_memory_size);
+  SharedMemoryHandle shm(s_memory_size, UnguessableToken::Create());
   ASSERT_TRUE(shm.IsValid());
   EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
 
   // Name count doesn't change when mapping the memory.
   std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
   shared_memory->Map(s_memory_size);
   EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
 
   // Destroying the SharedMemory object frees the resource.
   shared_memory.reset();
@@ skipping 42 matching lines @@
   int current_prot, max_prot;
   ASSERT_TRUE(GetProtections(shared_memory->memory(),
                              shared_memory->mapped_size(), &current_prot,
                              &max_prot));
   ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, current_prot);
   ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, max_prot);
 
   // Make a new memory object.
   SharedMemoryHandle shm2 = shared_memory->GetReadOnlyHandle();
   ASSERT_TRUE(shm2.IsValid());
+  EXPECT_EQ(shared_memory->handle().GetGUID(), shm2.GetGUID());
 
   // Mapping with |readonly| set to |false| should fail.
   SharedMemory shared_memory2(shm2, false);
   shared_memory2.Map(s_memory_size);
   ASSERT_EQ(nullptr, shared_memory2.memory());
 
   // Now trying mapping with |readonly| set to |true|.
   SharedMemory shared_memory3(shm2.Duplicate(), true);
   shared_memory3.Map(s_memory_size);
   ASSERT_NE(nullptr, shared_memory3.memory());
@@ skipping 23 matching lines @@
 
     // Intentionally map with |readonly| set to |false|.
     SharedMemory shared_memory2(shm2, false);
     shared_memory2.Map(s_memory_size);
   }
 
   EXPECT_EQ(active_name_count, GetActiveNameCount());
 }
 
 }  //  namespace base