Change MessagePumpForGpu and SharedMemory to ScopedHandle

base/metrics/persistent_memory_allocator_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 "base/metrics/persistent_memory_allocator.h"
 
 #include <memory>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 479 matching lines @@
   EXPECT_EQ(42U, allocator.Id());
   EXPECT_NE(0U, allocator.Allocate(24, 1));
   EXPECT_FALSE(allocator.IsFull());
   EXPECT_FALSE(allocator.IsCorrupt());
 }
 
 
 //----- SharedPersistentMemoryAllocator ----------------------------------------
 
 TEST(SharedPersistentMemoryAllocatorTest, CreationTest) {
-  SharedMemoryHandle shared_handle;
+  SharedMemoryHandle shared_handle_1;
+  SharedMemoryHandle shared_handle_2;
 
   PersistentMemoryAllocator::MemoryInfo meminfo1;
   Reference r123, r456, r789;
   {
     std::unique_ptr<SharedMemory> shmem1(new SharedMemory());
     ASSERT_TRUE(shmem1->CreateAndMapAnonymous(TEST_MEMORY_SIZE));
     SharedPersistentMemoryAllocator local(std::move(shmem1), TEST_ID, "",
                                           false);
     EXPECT_FALSE(local.IsReadonly());
     r123 = local.Allocate(123, 123);
     r456 = local.Allocate(456, 456);
     r789 = local.Allocate(789, 789);
     local.MakeIterable(r123);
     local.ChangeType(r456, 654, 456);
     local.MakeIterable(r789);
     local.GetMemoryInfo(&meminfo1);
     EXPECT_FALSE(local.IsFull());
     EXPECT_FALSE(local.IsCorrupt());
 
     ASSERT_TRUE(local.shared_memory()->ShareToProcess(
                     GetCurrentProcessHandle(),
-                    &shared_handle));
+                    &shared_handle_1));
+    ASSERT_TRUE(local.shared_memory()->ShareToProcess(
+                    GetCurrentProcessHandle(),
+                    &shared_handle_2));
   }
 
   // Read-only test.
-  std::unique_ptr<SharedMemory> shmem2(new SharedMemory(shared_handle,
+  std::unique_ptr<SharedMemory> shmem2(new SharedMemory(shared_handle_1,
                                                         /*readonly=*/true));
   ASSERT_TRUE(shmem2->Map(TEST_MEMORY_SIZE));
 
   SharedPersistentMemoryAllocator shalloc2(std::move(shmem2), 0, "", true);
   EXPECT_TRUE(shalloc2.IsReadonly());
   EXPECT_EQ(TEST_ID, shalloc2.Id());
   EXPECT_FALSE(shalloc2.IsFull());
   EXPECT_FALSE(shalloc2.IsCorrupt());
 
   PersistentMemoryAllocator::Iterator iter2(&shalloc2);
   uint32_t type;
   EXPECT_EQ(r123, iter2.GetNext(&type));
   EXPECT_EQ(r789, iter2.GetNext(&type));
   EXPECT_EQ(0U, iter2.GetNext(&type));
 
   EXPECT_EQ(123U, shalloc2.GetType(r123));
   EXPECT_EQ(654U, shalloc2.GetType(r456));
   EXPECT_EQ(789U, shalloc2.GetType(r789));
 
   PersistentMemoryAllocator::MemoryInfo meminfo2;
   shalloc2.GetMemoryInfo(&meminfo2);
   EXPECT_EQ(meminfo1.total, meminfo2.total);
   EXPECT_EQ(meminfo1.free, meminfo2.free);
 
   // Read/write test.
-  std::unique_ptr<SharedMemory> shmem3(new SharedMemory(shared_handle,
+  std::unique_ptr<SharedMemory> shmem3(new SharedMemory(shared_handle_2,

[stanisc, 2016/06/29 18:36:18]

Changed this to avoid double tracking of the same handle.

                                                         /*readonly=*/false));
   ASSERT_TRUE(shmem3->Map(TEST_MEMORY_SIZE));
 
   SharedPersistentMemoryAllocator shalloc3(std::move(shmem3), 0, "", false);
   EXPECT_FALSE(shalloc3.IsReadonly());
   EXPECT_EQ(TEST_ID, shalloc3.Id());
   EXPECT_FALSE(shalloc3.IsFull());
   EXPECT_FALSE(shalloc3.IsCorrupt());
 
   PersistentMemoryAllocator::Iterator iter3(&shalloc3);
@@ skipping 218 matching lines @@
       // For filesize >= minsize, the file must be acceptable. This
       // else clause (file-not-acceptable) should be reached only if
       // filesize < minsize.
       EXPECT_GT(minsize, filesize);
     }
   }
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace base