Move discardable memory to //components from //content

components/discardable_memory/common/discardable_shared_memory_manager.cc

Index: components/discardable_memory/common/discardable_shared_memory_manager.cc
diff --git a/content/common/host_discardable_shared_memory_manager.cc b/components/discardable_memory/common/discardable_shared_memory_manager.cc
similarity index 86%
rename from content/common/host_discardable_shared_memory_manager.cc
rename to components/discardable_memory/common/discardable_shared_memory_manager.cc
index e349fca4171c1a32a1daf1ef22f50913e1d7c89f..a50d193fcc8b89cba0d9ecc7790f4e0575bc9b79 100644
--- a/content/common/host_discardable_shared_memory_manager.cc
+++ b/components/discardable_memory/common/discardable_shared_memory_manager.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/common/host_discardable_shared_memory_manager.h"
+#include "components/discardable_memory/common/discardable_shared_memory_manager.h"
 
 #include <algorithm>
 #include <utility>
@@ -27,9 +27,7 @@
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
-#include "content/common/child_process_host_impl.h"
-#include "content/common/discardable_shared_memory_heap.h"
-#include "content/public/common/child_process_host.h"
+#include "components/discardable_memory/common/discardable_shared_memory_heap.h"
 
 #if defined(OS_LINUX)
 #include "base/files/file_path.h"
@@ -37,9 +35,16 @@
 #include "base/metrics/histogram_macros.h"
 #endif
 
-namespace content {
+namespace discardable_memory {
 namespace {
 
+const int kInvalidUniqueClientID = -1;
+
+uint64_t ClientIdToClientTracingId(int client_id) {
+  // TODO(penghuang): Using a meaningful tracing id.
+  return client_id;
+}
+
 class DiscardableMemoryImpl : public base::DiscardableMemory {
  public:
   DiscardableMemoryImpl(
@@ -146,7 +151,7 @@ int64_t GetDefaultMemoryLimit() {
                   base::SysInfo::AmountOfPhysicalMemory() / 4);
 }
 
-base::LazyInstance<HostDiscardableSharedMemoryManager>
+base::LazyInstance<DiscardableSharedMemoryManager>
     g_discardable_shared_memory_manager = LAZY_INSTANCE_INITIALIZER;
 
 const int kEnforceMemoryPolicyDelayMs = 1000;
@@ -156,19 +161,18 @@ base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id;
 
 }  // namespace
 
-HostDiscardableSharedMemoryManager::MemorySegment::MemorySegment(
+DiscardableSharedMemoryManager::MemorySegment::MemorySegment(
     std::unique_ptr<base::DiscardableSharedMemory> memory)
     : memory_(std::move(memory)) {}
 
-HostDiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {
-}
+DiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {}
 
-HostDiscardableSharedMemoryManager::HostDiscardableSharedMemoryManager()
+DiscardableSharedMemoryManager::DiscardableSharedMemoryManager()
     : default_memory_limit_(GetDefaultMemoryLimit()),
       memory_limit_(default_memory_limit_),
       bytes_allocated_(0),
       memory_pressure_listener_(new base::MemoryPressureListener(
-          base::Bind(&HostDiscardableSharedMemoryManager::OnMemoryPressure,
+          base::Bind(&DiscardableSharedMemoryManager::OnMemoryPressure,
                      base::Unretained(this)))),
       // Current thread might not have a task runner in tests.
       enforce_memory_policy_task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ -176,27 +180,25 @@ HostDiscardableSharedMemoryManager::HostDiscardableSharedMemoryManager()
       weak_ptr_factory_(this) {
   DCHECK_NE(memory_limit_, 0u);
   enforce_memory_policy_callback_ =
-      base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
+      base::Bind(&DiscardableSharedMemoryManager::EnforceMemoryPolicy,
                  weak_ptr_factory_.GetWeakPtr());
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-      this, "HostDiscardableSharedMemoryManager",
+      this, "DiscardableSharedMemoryManager",
       base::ThreadTaskRunnerHandle::Get());
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
-HostDiscardableSharedMemoryManager::~HostDiscardableSharedMemoryManager() {
+DiscardableSharedMemoryManager::~DiscardableSharedMemoryManager() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
-HostDiscardableSharedMemoryManager*
-HostDiscardableSharedMemoryManager::current() {
+DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::current() {
   return g_discardable_shared_memory_manager.Pointer();
 }
 
 std::unique_ptr<base::DiscardableMemory>
-HostDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
-    size_t size) {
+DiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(size_t size) {
   DCHECK_NE(size, 0u);
 
   DiscardableSharedMemoryId new_id =
@@ -206,9 +208,8 @@ HostDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
   // Note: Use DiscardableSharedMemoryHeap for in-process allocation
   // of discardable memory if the cost of each allocation is too high.
   base::SharedMemoryHandle handle;
-  AllocateLockedDiscardableSharedMemory(current_process_handle,
-                                        ChildProcessHost::kInvalidUniqueID,
-                                        size, new_id, &handle);
+  AllocateLockedDiscardableSharedMemory(
+      current_process_handle, kInvalidUniqueClientID, size, new_id, &handle);
   std::unique_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory(handle));
   if (!memory->Map(size))
@@ -218,11 +219,11 @@ HostDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
   return base::MakeUnique<DiscardableMemoryImpl>(
       std::move(memory),
       base::Bind(
-          &HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory,
-          base::Unretained(this), new_id, ChildProcessHost::kInvalidUniqueID));
+          &DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory,
+          base::Unretained(this), new_id, kInvalidUniqueClientID));
 }
 
-bool HostDiscardableSharedMemoryManager::OnMemoryDump(
+bool DiscardableSharedMemoryManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   if (args.level_of_detail ==
@@ -266,8 +267,7 @@ bool HostDiscardableSharedMemoryManager::OnMemoryDump(
       // double-count them in tracing. If, instead, no other process will emit a
       // dump with the same guid, the segment will be accounted to the browser.
       const uint64_t child_tracing_process_id =
-          ChildProcessHostImpl::ChildProcessUniqueIdToTracingProcessId(
-              child_process_id);
+          ClientIdToClientTracingId(child_process_id);
       base::trace_event::MemoryAllocatorDumpGuid shared_segment_guid =
           DiscardableSharedMemoryHeap::GetSegmentGUIDForTracing(
               child_tracing_process_id, segment_id);
@@ -294,7 +294,7 @@ bool HostDiscardableSharedMemoryManager::OnMemoryDump(
   return true;
 }
 
-void HostDiscardableSharedMemoryManager::
+void DiscardableSharedMemoryManager::
     AllocateLockedDiscardableSharedMemoryForChild(
         base::ProcessHandle process_handle,
         int child_process_id,
@@ -305,13 +305,13 @@ void HostDiscardableSharedMemoryManager::
                                         id, shared_memory_handle);
 }
 
-void HostDiscardableSharedMemoryManager::ChildDeletedDiscardableSharedMemory(
+void DiscardableSharedMemoryManager::ChildDeletedDiscardableSharedMemory(
     DiscardableSharedMemoryId id,
     int child_process_id) {
   DeletedDiscardableSharedMemory(id, child_process_id);
 }
 
-void HostDiscardableSharedMemoryManager::ProcessRemoved(int child_process_id) {
+void DiscardableSharedMemoryManager::ProcessRemoved(int child_process_id) {
   base::AutoLock lock(lock_);
 
   ProcessMap::iterator process_it = processes_.find(child_process_id);
@@ -329,27 +329,27 @@ void HostDiscardableSharedMemoryManager::ProcessRemoved(int child_process_id) {
     BytesAllocatedChanged(bytes_allocated_);
 }
 
-void HostDiscardableSharedMemoryManager::SetMemoryLimit(size_t limit) {
+void DiscardableSharedMemoryManager::SetMemoryLimit(size_t limit) {
   base::AutoLock lock(lock_);
 
   memory_limit_ = limit;
   ReduceMemoryUsageUntilWithinMemoryLimit();
 }
 
-void HostDiscardableSharedMemoryManager::EnforceMemoryPolicy() {
+void DiscardableSharedMemoryManager::EnforceMemoryPolicy() {
   base::AutoLock lock(lock_);
 
   enforce_memory_policy_pending_ = false;
   ReduceMemoryUsageUntilWithinMemoryLimit();
 }
 
-size_t HostDiscardableSharedMemoryManager::GetBytesAllocated() {
+size_t DiscardableSharedMemoryManager::GetBytesAllocated() {
   base::AutoLock lock(lock_);
 
   return bytes_allocated_;
 }
 
-void HostDiscardableSharedMemoryManager::OnMemoryStateChange(
+void DiscardableSharedMemoryManager::OnMemoryStateChange(
     base::MemoryState state) {
   switch (state) {
     case base::MemoryState::NORMAL:
@@ -359,15 +359,15 @@ void HostDiscardableSharedMemoryManager::OnMemoryStateChange(
       SetMemoryLimit(0);
       break;
     case base::MemoryState::SUSPENDED:
-      // Note that SUSPENDED never occurs in the main browser process so far.
-      // Fall through.
+    // Note that SUSPENDED never occurs in the main browser process so far.
+    // Fall through.
     case base::MemoryState::UNKNOWN:
       NOTREACHED();
       break;
   }
 }
 
-void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
+void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
     base::ProcessHandle process_handle,
     int client_process_id,
     size_t size,
@@ -432,7 +432,7 @@ void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
     ScheduleEnforceMemoryPolicy();
 }
 
-void HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
+void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
     DiscardableSharedMemoryId id,
     int client_process_id) {
   base::AutoLock lock(lock_);
@@ -455,7 +455,7 @@ void HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
     BytesAllocatedChanged(bytes_allocated_);
 }
 
-void HostDiscardableSharedMemoryManager::OnMemoryPressure(
+void DiscardableSharedMemoryManager::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   base::AutoLock lock(lock_);
 
@@ -473,8 +473,7 @@ void HostDiscardableSharedMemoryManager::OnMemoryPressure(
   }
 }
 
-void
-HostDiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinMemoryLimit() {
+void DiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinMemoryLimit() {
   lock_.AssertAcquired();
 
   if (bytes_allocated_ <= memory_limit_)
@@ -485,13 +484,12 @@ HostDiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinMemoryLimit() {
     ScheduleEnforceMemoryPolicy();
 }
 
-void HostDiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinLimit(
+void DiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinLimit(
     size_t limit) {
   TRACE_EVENT1("renderer_host",
-               "HostDiscardableSharedMemoryManager::"
+               "DiscardableSharedMemoryManager::"
                "ReduceMemoryUsageUntilWithinLimit",
-               "bytes_allocated",
-               bytes_allocated_);
+               "bytes_allocated", bytes_allocated_);
 
   // Usage time of currently locked segments are updated to this time and
   // we stop eviction attempts as soon as we come across a segment that we've
@@ -534,7 +532,7 @@ void HostDiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinLimit(
     BytesAllocatedChanged(bytes_allocated_);
 }
 
-void HostDiscardableSharedMemoryManager::ReleaseMemory(
+void DiscardableSharedMemoryManager::ReleaseMemory(
     base::DiscardableSharedMemory* memory) {
   lock_.AssertAcquired();
 
@@ -552,7 +550,7 @@ void HostDiscardableSharedMemoryManager::ReleaseMemory(
   memory->Close();
 }
 
-void HostDiscardableSharedMemoryManager::BytesAllocatedChanged(
+void DiscardableSharedMemoryManager::BytesAllocatedChanged(
     size_t new_bytes_allocated) const {
   static const char kTotalDiscardableMemoryAllocatedKey[] =
       "total-discardable-memory-allocated";
@@ -560,11 +558,11 @@ void HostDiscardableSharedMemoryManager::BytesAllocatedChanged(
                                 base::Uint64ToString(new_bytes_allocated));
 }
 
-base::Time HostDiscardableSharedMemoryManager::Now() const {
+base::Time DiscardableSharedMemoryManager::Now() const {
   return base::Time::Now();
 }
 
-void HostDiscardableSharedMemoryManager::ScheduleEnforceMemoryPolicy() {
+void DiscardableSharedMemoryManager::ScheduleEnforceMemoryPolicy() {
   lock_.AssertAcquired();
 
   if (enforce_memory_policy_pending_)
@@ -577,4 +575,4 @@ void HostDiscardableSharedMemoryManager::ScheduleEnforceMemoryPolicy() {
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
-}  // namespace content
+}  // namespace discardable_memory