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) {

[reveman, 2016/11/01 17:18:38]

nit: ClientProcessUniqueIdToTracingProcessId

[Peng, 2016/11/01 18:38:30]

Done.

+  // TODO(penghuang): Using a meaningful tracing id.
+  return client_id;

[reveman, 2016/11/01 17:18:38]

This needs to work properly for chrome as we rely on it for critical memory
measurements. Can we just have it do what ChildProcessUniqueIdToTracingProcessId
is currently doing and then leave the exercise of making it adjustable by the
embedder as a TODO?

[Peng, 2016/11/01 18:38:30]

Done.

BTW for mojo, I don't think we can get process id of a client. So we need figure
out how to generate a tracing id for mojo IPC.

+}
+
 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 =

[reveman, 2016/11/01 17:18:38]

nit: s/child/client/

[Peng, 2016/11/01 18:38:30]

Done.

-          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,

[reveman, 2016/11/01 17:18:38]

nit: s/child/client/

[Peng, 2016/11/01 18:38:30]

Done.

@@ -305,13 +305,13 @@ void HostDiscardableSharedMemoryManager::
                                         id, shared_memory_handle);
 }
 
-void HostDiscardableSharedMemoryManager::ChildDeletedDiscardableSharedMemory(
+void DiscardableSharedMemoryManager::ChildDeletedDiscardableSharedMemory(
     DiscardableSharedMemoryId id,
     int child_process_id) {

[reveman, 2016/11/01 17:18:38]

nit: s/child/client/

[Peng, 2016/11/01 18:38:30]

Done.

   DeletedDiscardableSharedMemory(id, child_process_id);
 }
 
-void HostDiscardableSharedMemoryManager::ProcessRemoved(int child_process_id) {
+void DiscardableSharedMemoryManager::ProcessRemoved(int child_process_id) {

[reveman, 2016/11/01 17:18:38]

nit: s/child/client/

[Peng, 2016/11/01 18:38:30]

Done.

   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