Revert of discardable_memory: Using mojo IPC to replace Chrome IPC

components/discardable_memory/service/discardable_shared_memory_manager_unittest.cc

 // Copyright 2014 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 "components/discardable_memory/service/discardable_shared_memory_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 59 matching lines @@
   std::unique_ptr<TestDiscardableSharedMemoryManager> manager_;
 };
 
 TEST_F(DiscardableSharedMemoryManagerTest, AllocateForClient) {
   const int kDataSize = 1024;
   uint8_t data[kDataSize];
   memset(data, 0x80, kDataSize);
 
   base::SharedMemoryHandle shared_handle;
   manager_->AllocateLockedDiscardableSharedMemoryForClient(
-      kInvalidUniqueID, kDataSize, 0, &shared_handle);
+      base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 0,
+      &shared_handle);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle));
 
   TestDiscardableSharedMemory memory(shared_handle);
   bool rv = memory.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   memcpy(memory.memory(), data, kDataSize);
   memory.SetNow(base::Time::FromDoubleT(1));
   memory.Unlock(0, 0);
 
   ASSERT_EQ(base::DiscardableSharedMemory::SUCCESS, memory.Lock(0, 0));
   EXPECT_EQ(memcmp(data, memory.memory(), kDataSize), 0);
   memory.Unlock(0, 0);
 }
 
 TEST_F(DiscardableSharedMemoryManagerTest, Purge) {
   const int kDataSize = 1024;
 
   base::SharedMemoryHandle shared_handle1;
   manager_->AllocateLockedDiscardableSharedMemoryForClient(
-      kInvalidUniqueID, kDataSize, 1, &shared_handle1);
+      base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 1,
+      &shared_handle1);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle1));
 
   TestDiscardableSharedMemory memory1(shared_handle1);
   bool rv = memory1.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   base::SharedMemoryHandle shared_handle2;
   manager_->AllocateLockedDiscardableSharedMemoryForClient(
-      kInvalidUniqueID, kDataSize, 2, &shared_handle2);
+      base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 2,
+      &shared_handle2);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle2));
 
   TestDiscardableSharedMemory memory2(shared_handle2);
   rv = memory2.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   // Enough memory for both allocations.
   manager_->SetNow(base::Time::FromDoubleT(1));
   manager_->SetMemoryLimit(memory1.mapped_size() + memory2.mapped_size());
 
@@ skipping 34 matching lines @@
   EXPECT_EQ(base::DiscardableSharedMemory::FAILED, lock_rv);
   lock_rv = memory2.Lock(0, 0);
   EXPECT_EQ(base::DiscardableSharedMemory::SUCCESS, lock_rv);
 }
 
 TEST_F(DiscardableSharedMemoryManagerTest, EnforceMemoryPolicy) {
   const int kDataSize = 1024;
 
   base::SharedMemoryHandle shared_handle;
   manager_->AllocateLockedDiscardableSharedMemoryForClient(
-      kInvalidUniqueID, kDataSize, 0, &shared_handle);
+      base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 0,
+      &shared_handle);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle));
 
   TestDiscardableSharedMemory memory(shared_handle);
   bool rv = memory.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   // Not enough memory for one allocation.
   manager_->SetNow(base::Time::FromDoubleT(1));
   manager_->SetMemoryLimit(memory.mapped_size() - 1);
   // We need to enforce memory policy as our memory usage is currently above
@@ skipping 17 matching lines @@
 
   EXPECT_EQ(base::DiscardableSharedMemory::FAILED, memory.Lock(0, 0));
 }
 
 TEST_F(DiscardableSharedMemoryManagerTest,
        ReduceMemoryAfterSegmentHasBeenDeleted) {
   const int kDataSize = 1024;
 
   base::SharedMemoryHandle shared_handle1;
   manager_->AllocateLockedDiscardableSharedMemoryForClient(
-      kInvalidUniqueID, kDataSize, 1, &shared_handle1);
+      base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 1,
+      &shared_handle1);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle1));
 
   TestDiscardableSharedMemory memory1(shared_handle1);
   bool rv = memory1.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   base::SharedMemoryHandle shared_handle2;
   manager_->AllocateLockedDiscardableSharedMemoryForClient(
-      kInvalidUniqueID, kDataSize, 2, &shared_handle2);
+      base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 2,
+      &shared_handle2);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle2));
 
   TestDiscardableSharedMemory memory2(shared_handle2);
   rv = memory2.Map(kDataSize);
   ASSERT_TRUE(rv);
 
   // Unlock and delete segment 1.
   memory1.SetNow(base::Time::FromDoubleT(1));
   memory1.Unlock(0, 0);
   memory1.Unmap();
@@ skipping 33 matching lines @@
   DiscardableSharedMemoryManager* const manager_;
   const size_t limit_;
 };
 
 TEST_F(DiscardableSharedMemoryManagerScheduleEnforceMemoryPolicyTest,
        SetMemoryLimitOnSimpleThread) {
   const int kDataSize = 1024;
 
   base::SharedMemoryHandle shared_handle;
   manager_->AllocateLockedDiscardableSharedMemoryForClient(
-      kInvalidUniqueID, kDataSize, 0, &shared_handle);
+      base::GetCurrentProcessHandle(), kInvalidUniqueID, kDataSize, 0,
+      &shared_handle);
   ASSERT_TRUE(base::SharedMemory::IsHandleValid(shared_handle));
 
   // Set the memory limit to a value that will require EnforceMemoryPolicy()
   // to be schedule on a thread without a message loop.
   SetMemoryLimitRunner runner(manager_.get(), kDataSize - 1);
   base::DelegateSimpleThread thread(&runner, "memory_limit_setter");
   thread.Start();
   thread.Join();
 }
 
 }  // namespace
 }  // namespace discardable_memory