Get rid of all pid references from base::SharedMemoryHandle.

base::SharedMemory used to support synchronous transport of handles into other
processes using base::SharedMemory::ShareToProcess. This required
base::SharedMemoryHandle to also track whether the OS resource belonged to the
current process. ShareToProcess has been removed, so all the pid tracking is no
longer necessary.

BUG=716206
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.win:win10_chromium_x64_rel_ng
TBR=wfh@chromium.org

Review-Url: https://codereview.chromium.org/2849243002
Cr-Commit-Position: refs/heads/master@{#469012}

base/memory/shared_memory_handle.h

@@ -83,10 +83,8 @@ class BASE_EXPORT SharedMemoryHandle {
   explicit SharedMemoryHandle(mach_vm_size_t size);
 
   // Makes a Mach-based SharedMemoryHandle from |memory_object|, a named entry
-  // in the task with process id |pid|. The memory region has size |size|.
-  SharedMemoryHandle(mach_port_t memory_object,
-                     mach_vm_size_t size,
-                     base::ProcessId pid);
+  // in the current task. The memory region has size |size|.
+  SharedMemoryHandle(mach_port_t memory_object, mach_vm_size_t size);
 
   // Exposed so that the SharedMemoryHandle can be transported between
   // processes.
@@ -102,17 +100,9 @@ class BASE_EXPORT SharedMemoryHandle {
   // mapped memory.
   bool MapAt(off_t offset, size_t bytes, void** memory, bool read_only);
 #elif defined(OS_WIN)
-  SharedMemoryHandle(HANDLE h, base::ProcessId pid);
-
-  // Whether |pid_| is the same as the current process's id.
-  bool BelongsToCurrentProcess() const;
-
-  // Whether handle_ needs to be duplicated into the destination process when
-  // an instance of this class is passed over a Chrome IPC channel.
-  bool NeedsBrokering() const;
+  SharedMemoryHandle(HANDLE h);
 
   HANDLE GetHandle() const;
-  base::ProcessId GetPID() const;
 #else
   // This constructor is deprecated, as it fails to propagate the GUID, which
   // will be added in the near future.
@@ -156,10 +146,6 @@ class BASE_EXPORT SharedMemoryHandle {
       // relevant if |memory_object_| is not |MACH_PORT_NULL|.
       mach_vm_size_t size_;
 
-      // The pid of the process in which |memory_object_| is usable. Only
-      // relevant if |memory_object_| is not |MACH_PORT_NULL|.
-      base::ProcessId pid_;
-
       // Whether passing this object as a parameter to an IPC message passes
       // ownership of |memory_object_| to the IPC stack. This is meant to mimic
       // the behavior of the |auto_close| parameter of FileDescriptor.
@@ -170,10 +156,6 @@ class BASE_EXPORT SharedMemoryHandle {
 #elif defined(OS_WIN)
   HANDLE handle_;
 
-  // The process in which |handle_| is valid and can be used. If |handle_| is
-  // invalid, this will be kNullProcessId.
-  base::ProcessId pid_;
-
   // Whether passing this object as a parameter to an IPC message passes
   // ownership of |handle_| to the IPC stack. This is meant to mimic the
   // behavior of the |auto_close| parameter of FileDescriptor. This member only

base/memory/shared_memory_handle_mac.cc

@@ -39,17 +39,14 @@ SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size) {
 
   memory_object_ = named_right;
   size_ = size;
-  pid_ = GetCurrentProcId();
   ownership_passes_to_ipc_ = false;
 }
 
 SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object,
-                                       mach_vm_size_t size,
-                                       base::ProcessId pid)
+                                       mach_vm_size_t size)
     : type_(MACH),
       memory_object_(memory_object),
       size_(size),
-      pid_(pid),
       ownership_passes_to_ipc_(false) {}
 
 SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle) {
@@ -78,7 +75,7 @@ SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
     }
     case MACH: {
       if (!IsValid())
-        return SharedMemoryHandle(MACH_PORT_NULL, 0, 0);
+        return SharedMemoryHandle();
 
       // Increment the ref count.
       kern_return_t kr = mach_port_mod_refs(mach_task_self(), memory_object_,
@@ -137,7 +134,6 @@ bool SharedMemoryHandle::MapAt(off_t offset,
                      MAP_SHARED, file_descriptor_.fd, offset);
       return *memory != MAP_FAILED;
     case SharedMemoryHandle::MACH:
-      DCHECK_EQ(pid_, GetCurrentProcId());
       kern_return_t kr = mach_vm_map(
           mach_task_self(),
           reinterpret_cast<mach_vm_address_t*>(memory),    // Output parameter
@@ -190,7 +186,6 @@ void SharedMemoryHandle::CopyRelevantData(const SharedMemoryHandle& handle) {
     case MACH:
       memory_object_ = handle.memory_object_;
       size_ = handle.size_;
-      pid_ = handle.pid_;
       ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_;
       break;
   }

base/memory/shared_memory_handle_win.cc

@@ -9,14 +9,13 @@
 namespace base {
 
 SharedMemoryHandle::SharedMemoryHandle()
-    : handle_(nullptr), pid_(kNullProcessId), ownership_passes_to_ipc_(false) {}
+    : handle_(nullptr), ownership_passes_to_ipc_(false) {}
 
-SharedMemoryHandle::SharedMemoryHandle(HANDLE h, base::ProcessId pid)
-    : handle_(h), pid_(pid), ownership_passes_to_ipc_(false) {}
+SharedMemoryHandle::SharedMemoryHandle(HANDLE h)
+    : handle_(h), ownership_passes_to_ipc_(false) {}
 
 SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle)
     : handle_(handle.handle_),
-      pid_(handle.pid_),
       ownership_passes_to_ipc_(handle.ownership_passes_to_ipc_) {}
 
 SharedMemoryHandle& SharedMemoryHandle::operator=(
@@ -25,14 +24,12 @@ SharedMemoryHandle& SharedMemoryHandle::operator=(
     return *this;
 
   handle_ = handle.handle_;
-  pid_ = handle.pid_;
   ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_;
   return *this;
 }
 
 void SharedMemoryHandle::Close() const {
   DCHECK(handle_ != nullptr);
-  DCHECK(BelongsToCurrentProcess());
   ::CloseHandle(handle_);
 }
 
@@ -41,7 +38,6 @@ bool SharedMemoryHandle::IsValid() const {
 }
 
 SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
-  DCHECK(BelongsToCurrentProcess());
   HANDLE duped_handle;
   ProcessHandle process = GetCurrentProcess();
   BOOL success = ::DuplicateHandle(process, handle_, process, &duped_handle, 0,
@@ -49,27 +45,15 @@ SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
   if (!success)
     return SharedMemoryHandle();
 
-  base::SharedMemoryHandle handle(duped_handle, GetCurrentProcId());
+  base::SharedMemoryHandle handle(duped_handle);
   handle.SetOwnershipPassesToIPC(true);
   return handle;
 }
 
-bool SharedMemoryHandle::BelongsToCurrentProcess() const {
-  return pid_ == base::GetCurrentProcId();
-}
-
-bool SharedMemoryHandle::NeedsBrokering() const {
-  return BelongsToCurrentProcess();
-}
-
 HANDLE SharedMemoryHandle::GetHandle() const {
   return handle_;
 }
 
-base::ProcessId SharedMemoryHandle::GetPID() const {
-  return pid_;
-}
-
 void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) {
   ownership_passes_to_ipc_ = ownership_passes;
 }

base/memory/shared_memory_mac.cc

@@ -74,7 +74,7 @@ bool MakeMachSharedMemoryHandleReadOnly(SharedMemoryHandle* new_handle,
   if (kr != KERN_SUCCESS)
     return false;
 
-  *new_handle = SharedMemoryHandle(named_right, size, base::GetCurrentProcId());
+  *new_handle = SharedMemoryHandle(named_right, size);
   return true;
 }
 

base/memory/shared_memory_mac_unittest.cc

@@ -247,8 +247,7 @@ MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryClient) {
   // 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,
-                         GetCurrentProcId());
+                         SharedMemoryMacMultiProcessTest::s_memory_size);
   SharedMemory shared_memory(shm, false);
   shared_memory.Map(SharedMemoryMacMultiProcessTest::s_memory_size);
   const char* start = static_cast<const char*>(shared_memory.memory());
@@ -287,8 +286,7 @@ MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryWithOffsetClient) {
   // 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,
-                         GetCurrentProcId());
+                         SharedMemoryMacMultiProcessTest::s_memory_size);
   SharedMemory shared_memory(shm, false);
   size_t page_size = SysInfo::VMAllocationGranularity();
   shared_memory.MapAt(page_size, 2 * page_size);

base/memory/shared_memory_unittest.cc

@@ -605,7 +605,7 @@ TEST(SharedMemoryTest, UnsafeImageSection) {
   EXPECT_EQ(nullptr, shared_memory_open.memory());
 
   SharedMemory shared_memory_handle_local(
-      SharedMemoryHandle(section_handle.Take(), ::GetCurrentProcessId()), true);
+      SharedMemoryHandle(section_handle.Take()), true);
   EXPECT_FALSE(shared_memory_handle_local.Map(1));
   EXPECT_EQ(nullptr, shared_memory_handle_local.memory());
 
@@ -620,7 +620,7 @@ TEST(SharedMemoryTest, UnsafeImageSection) {
       ::GetCurrentProcess(), shared_memory_handle_dummy.handle().GetHandle(),
       ::GetCurrentProcess(), &handle_no_query, FILE_MAP_READ, FALSE, 0));
   SharedMemory shared_memory_handle_no_query(
-      SharedMemoryHandle(handle_no_query, ::GetCurrentProcessId()), true);
+      SharedMemoryHandle(handle_no_query), true);
   EXPECT_FALSE(shared_memory_handle_no_query.Map(1));
   EXPECT_EQ(nullptr, shared_memory_handle_no_query.memory());
 }

base/memory/shared_memory_win.cc

@@ -156,7 +156,6 @@ SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
       memory_(NULL),
       read_only_(read_only),
       requested_size_(0) {
-  DCHECK(!handle.IsValid() || handle.BelongsToCurrentProcess());
   mapped_file_.Set(handle.GetHandle());
 }
 
@@ -334,8 +333,7 @@ SharedMemoryHandle SharedMemory::GetReadOnlyHandle() {
                          FILE_MAP_READ | SECTION_QUERY, FALSE, 0)) {
     return SharedMemoryHandle();
   }
-  SharedMemoryHandle handle =
-      SharedMemoryHandle(result, base::GetProcId(process));
+  SharedMemoryHandle handle = SharedMemoryHandle(result);
   handle.SetOwnershipPassesToIPC(true);
   return handle;
 }
@@ -345,11 +343,11 @@ void SharedMemory::Close() {
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
-  return SharedMemoryHandle(mapped_file_.Get(), base::GetCurrentProcId());
+  return SharedMemoryHandle(mapped_file_.Get());
 }
 
 SharedMemoryHandle SharedMemory::TakeHandle() {
-  SharedMemoryHandle handle(mapped_file_.Take(), base::GetCurrentProcId());
+  SharedMemoryHandle handle(mapped_file_.Take());
   handle.SetOwnershipPassesToIPC(true);
   memory_ = nullptr;
   mapped_size_ = 0;

base/metrics/field_trial.cc

@@ -1137,7 +1137,7 @@ bool FieldTrialList::CreateTrialsFromHandleSwitch(
     const std::string& handle_switch) {
   int field_trial_handle = std::stoi(handle_switch);
   HANDLE handle = reinterpret_cast<HANDLE>(field_trial_handle);
-  SharedMemoryHandle shm_handle(handle, GetCurrentProcId());
+  SharedMemoryHandle shm_handle(handle);
   return FieldTrialList::CreateTrialsFromSharedMemoryHandle(shm_handle);
 }
 #endif

ipc/ipc_message_utils.cc

@@ -709,8 +709,7 @@ bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
     return false;
 
   *r = base::SharedMemoryHandle(mach_port_mac.get_mach_port(),
-                                static_cast<size_t>(size),
-                                base::GetCurrentProcId());
+                                static_cast<size_t>(size));
   return true;
 }
 
@@ -723,60 +722,49 @@ void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
 #elif defined(OS_WIN)
 void ParamTraits<base::SharedMemoryHandle>::GetSize(base::PickleSizer* s,
                                                     const param_type& p) {
-  GetParamSize(s, p.NeedsBrokering());
-  if (p.NeedsBrokering()) {
+  GetParamSize(s, p.IsValid());
+  if (p.IsValid())
     GetParamSize(s, p.GetHandle());
-  } else {
-    GetParamSize(s, HandleToLong(p.GetHandle()));
-  }
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
                                                   const param_type& p) {
-  m->WriteBool(p.NeedsBrokering());
+  const bool valid = p.IsValid();
+  WriteParam(m, valid);
 
-  if (p.NeedsBrokering()) {
-    HandleWin handle_win(p.GetHandle(), HandleWin::DUPLICATE);
-    ParamTraits<HandleWin>::Write(m, handle_win);
+  if (!valid)
+    return;
 
-    // If the caller intended to pass ownership to the IPC stack, release a
-    // reference.
-    if (p.OwnershipPassesToIPC() && p.BelongsToCurrentProcess())
-      p.Close();
-  } else {
-    m->WriteInt(HandleToLong(p.GetHandle()));
-  }
+  HandleWin handle_win(p.GetHandle(), HandleWin::DUPLICATE);
+  ParamTraits<HandleWin>::Write(m, handle_win);
+
+  // If the caller intended to pass ownership to the IPC stack, release a
+  // reference.
+  if (p.OwnershipPassesToIPC())
+    p.Close();
 }
 
 bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
                                                  base::PickleIterator* iter,
                                                  param_type* r) {
-  bool needs_brokering;
-  if (!iter->ReadBool(&needs_brokering))
-    return false;
+  *r = base::SharedMemoryHandle();
 
-  if (needs_brokering) {
-    HandleWin handle_win;
-    if (!ParamTraits<HandleWin>::Read(m, iter, &handle_win))
-      return false;
-    *r = base::SharedMemoryHandle(handle_win.get_handle(),
-                                  base::GetCurrentProcId());
+  bool valid;
+  if (!ReadParam(m, iter, &valid))
+    return false;
+  if (!valid)
     return true;
-  }
 
-  int handle_int;
-  if (!iter->ReadInt(&handle_int))
+  HandleWin handle_win;
+  if (!ParamTraits<HandleWin>::Read(m, iter, &handle_win))
     return false;
-  HANDLE handle = LongToHandle(handle_int);
-  *r = base::SharedMemoryHandle(handle, base::GetCurrentProcId());
+  *r = base::SharedMemoryHandle(handle_win.get_handle());
   return true;
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
                                                 std::string* l) {
   LogParam(p.GetHandle(), l);
-  l->append(" needs brokering: ");
-  LogParam(p.NeedsBrokering(), l);
 }
 #elif defined(OS_POSIX)
 void ParamTraits<base::SharedMemoryHandle>::GetSize(base::PickleSizer* sizer,

mojo/edk/embedder/platform_shared_buffer.cc

@@ -234,12 +234,10 @@ bool PlatformSharedBuffer::InitFromPlatformHandle(
   DCHECK(!shared_memory_);
 
 #if defined(OS_WIN)
-  base::SharedMemoryHandle handle(platform_handle.release().handle,
-                                  base::GetCurrentProcId());
+  base::SharedMemoryHandle handle(platform_handle.release().handle);
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   base::SharedMemoryHandle handle;
-  handle = base::SharedMemoryHandle(platform_handle.release().port, num_bytes_,
-                                    base::GetCurrentProcId());
+  handle = base::SharedMemoryHandle(platform_handle.release().port, num_bytes_);
 #else
   base::SharedMemoryHandle handle(
       base::FileDescriptor(platform_handle.release().handle, false));
@@ -258,10 +256,8 @@ bool PlatformSharedBuffer::InitFromPlatformHandlePair(
 #else  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
-  base::SharedMemoryHandle handle(rw_platform_handle.release().handle,
-                                  base::GetCurrentProcId());
-  base::SharedMemoryHandle ro_handle(ro_platform_handle.release().handle,
-                                     base::GetCurrentProcId());
+  base::SharedMemoryHandle handle(rw_platform_handle.release().handle);
+  base::SharedMemoryHandle ro_handle(ro_platform_handle.release().handle);
 #else  // defined(OS_WIN)
   base::SharedMemoryHandle handle(
       base::FileDescriptor(rw_platform_handle.release().handle, false));

mojo/edk/system/platform_wrapper_unittest.cc

@@ -164,8 +164,7 @@ DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReadPlatformSharedBuffer, PlatformWrapperTest,
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   ASSERT_EQ(MOJO_PLATFORM_HANDLE_TYPE_MACH_PORT, os_buffer.type);
   base::SharedMemoryHandle memory_handle(
-      static_cast<mach_port_t>(os_buffer.value), size,
-      base::GetCurrentProcId());
+      static_cast<mach_port_t>(os_buffer.value), size);
 #elif defined(OS_POSIX)
   ASSERT_EQ(MOJO_PLATFORM_HANDLE_TYPE_FILE_DESCRIPTOR, os_buffer.type);
   base::SharedMemoryHandle memory_handle(
@@ -173,7 +172,7 @@ DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReadPlatformSharedBuffer, PlatformWrapperTest,
 #elif defined(OS_WIN)
   ASSERT_EQ(MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE, os_buffer.type);
   base::SharedMemoryHandle memory_handle(
-      reinterpret_cast<HANDLE>(os_buffer.value), base::GetCurrentProcId());
+      reinterpret_cast<HANDLE>(os_buffer.value));
 #endif
 
   base::SharedMemory memory(memory_handle, read_only);

mojo/public/cpp/system/platform_handle.cc

@@ -117,17 +117,15 @@ MojoResult UnwrapSharedMemoryHandle(ScopedSharedBufferHandle handle,
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   CHECK_EQ(platform_handle.type, MOJO_PLATFORM_HANDLE_TYPE_MACH_PORT);
   *memory_handle = base::SharedMemoryHandle(
-      static_cast<mach_port_t>(platform_handle.value), num_bytes,
-      base::GetCurrentProcId());
+      static_cast<mach_port_t>(platform_handle.value), num_bytes);
 #elif defined(OS_POSIX)
   CHECK_EQ(platform_handle.type, MOJO_PLATFORM_HANDLE_TYPE_FILE_DESCRIPTOR);
   *memory_handle = base::SharedMemoryHandle(
       base::FileDescriptor(static_cast<int>(platform_handle.value), false));
 #elif defined(OS_WIN)
   CHECK_EQ(platform_handle.type, MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE);
-  *memory_handle = base::SharedMemoryHandle(
-      reinterpret_cast<HANDLE>(platform_handle.value),
-      base::GetCurrentProcId());
+  *memory_handle =
+      base::SharedMemoryHandle(reinterpret_cast<HANDLE>(platform_handle.value));
 #endif
 
   return MOJO_RESULT_OK;

sandbox/win/src/process_mitigations_win32k_dispatcher.cc

@@ -28,7 +28,7 @@ base::SharedMemoryHandle GetSharedMemoryHandle(const ClientInfo& client_info,
                          &result_handle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
     result_handle = nullptr;
   }
-  return base::SharedMemoryHandle(result_handle, ::GetCurrentProcessId());
+  return base::SharedMemoryHandle(result_handle);
 }
 
 }  // namespace

sandbox/win/tests/common/controller.cc

@@ -315,8 +315,7 @@ int DispatchCall(int argc, wchar_t **argv) {
     base::StringToUint(argv[4], reinterpret_cast<unsigned int*>(&raw_handle));
     if (raw_handle == nullptr)
       return SBOX_TEST_INVALID_PARAMETER;
-    base::SharedMemoryHandle shared_handle(raw_handle,
-                                           base::GetCurrentProcId());
+    base::SharedMemoryHandle shared_handle(raw_handle);
     base::SharedMemory read_only_view(shared_handle, true);
     if (!read_only_view.Map(0))
       return SBOX_TEST_INVALID_PARAMETER;

ui/gfx/mojo/buffer_types_struct_traits.cc

@@ -129,8 +129,7 @@ bool StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
       if (unwrap_result != MOJO_RESULT_OK)
         return false;
 #if defined(OS_WIN)
-      out->handle =
-          base::SharedMemoryHandle(platform_file, base::GetCurrentProcId());
+      out->handle = base::SharedMemoryHandle(platform_file);
 #else
       out->handle =
           base::SharedMemoryHandle(base::FileDescriptor(platform_file, true));