Move discardable memory to //components from //content

components/discardable_memory/common/discardable_shared_memory_manager.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 "content/common/host_discardable_shared_memory_manager.h"
+#include "components/discardable_memory/common/discardable_shared_memory_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/debug/crash_logging.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/process/memory.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #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"
 #include "base/files/file_util.h"
 #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(
       std::unique_ptr<base::DiscardableSharedMemory> shared_memory,
       const base::Closure& deleted_callback)
       : shared_memory_(std::move(shared_memory)),
         deleted_callback_(deleted_callback),
         is_locked_(true) {}
 
   ~DiscardableMemoryImpl() override {
@@ skipping 86 matching lines @@
     max_default_memory_limit =
         std::min(max_default_memory_limit, shmem_dir_amount_of_free_space / 2);
   }
 #endif
 
   // Allow 25% of physical memory to be used for discardable memory.
   return std::min(max_default_memory_limit,
                   base::SysInfo::AmountOfPhysicalMemory() / 4);
 }
 
-base::LazyInstance<HostDiscardableSharedMemoryManager>
+base::LazyInstance<DiscardableSharedMemoryManager>
     g_discardable_shared_memory_manager = LAZY_INSTANCE_INITIALIZER;
 
 const int kEnforceMemoryPolicyDelayMs = 1000;
 
 // Global atomic to generate unique discardable shared memory IDs.
 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()),
       enforce_memory_policy_pending_(false),
       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 =
       g_next_discardable_shared_memory_id.GetNext();
   base::ProcessHandle current_process_handle = base::GetCurrentProcessHandle();
 
   // 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))
     base::TerminateBecauseOutOfMemory(size);
   // Close file descriptor to avoid running out.
   memory->Close();
   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 ==
       base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
     base::trace_event::MemoryAllocatorDump* total_dump =
         pmd->CreateAllocatorDump("discardable");
     total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                           base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                           GetBytesAllocated());
     return true;
   }
 
   base::AutoLock lock(lock_);
   for (const auto& process_entry : processes_) {
     const int child_process_id = process_entry.first;

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

nit: s/child/client/

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

Done.

     const MemorySegmentMap& process_segments = process_entry.second;
     for (const auto& segment_entry : process_segments) {
       const int segment_id = segment_entry.first;
       const MemorySegment* segment = segment_entry.second.get();
       if (!segment->memory()->mapped_size())
         continue;
 
       // The "size" will be inherited form the shared global dump.
       std::string dump_name = base::StringPrintf(
           "discardable/process_%x/segment_%d", child_process_id, segment_id);
       base::trace_event::MemoryAllocatorDump* dump =
           pmd->CreateAllocatorDump(dump_name);
 
       dump->AddScalar("virtual_size",
                       base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                       segment->memory()->mapped_size());
 
       // Host can only tell if whole segment is locked or not.
       dump->AddScalar(
           "locked_size", base::trace_event::MemoryAllocatorDump::kUnitsBytes,
           segment->memory()->IsMemoryLocked() ? segment->memory()->mapped_size()
                                               : 0u);
 
       // Create the cross-process ownership edge. If the child creates a

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

nit: s/child/client/

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

Done.

       // corresponding dump for the same segment, this will avoid to
       // 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);
       pmd->CreateSharedGlobalAllocatorDump(shared_segment_guid);
       pmd->AddOwnershipEdge(dump->guid(), shared_segment_guid);
 
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
       if (args.level_of_detail ==
           base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
         size_t resident_size =
             base::trace_event::ProcessMemoryDump::CountResidentBytes(
                 segment->memory()->memory(), segment->memory()->mapped_size());
 
         // This is added to the global dump since it has to be attributed to
         // both the allocator dumps involved.
         pmd->GetSharedGlobalAllocatorDump(shared_segment_guid)
             ->AddScalar("resident_size",
                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                         static_cast<uint64_t>(resident_size));
       }
 #endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
     }
   }
   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.

         size_t size,
         DiscardableSharedMemoryId id,
         base::SharedMemoryHandle* shared_memory_handle) {
   AllocateLockedDiscardableSharedMemory(process_handle, child_process_id, size,
                                         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);
   if (process_it == processes_.end())
     return;
 
   size_t bytes_allocated_before_releasing_memory = bytes_allocated_;
 
   for (auto& segment_it : process_it->second)
     ReleaseMemory(segment_it.second->memory());
 
   processes_.erase(process_it);
 
   if (bytes_allocated_ != bytes_allocated_before_releasing_memory)
     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:
       SetMemoryLimit(default_memory_limit_);
       break;
     case base::MemoryState::THROTTLED:
       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,
     DiscardableSharedMemoryId id,
     base::SharedMemoryHandle* shared_memory_handle) {
   base::AutoLock lock(lock_);
 
   // Make sure |id| is not already in use.
   MemorySegmentMap& process_segments = processes_[client_process_id];
   if (process_segments.find(id) != process_segments.end()) {
@@ skipping 44 matching lines @@
 
   scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory)));
   process_segments[id] = segment.get();
   segments_.push_back(segment.get());
   std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime);
 
   if (bytes_allocated_ > memory_limit_)
     ScheduleEnforceMemoryPolicy();
 }
 
-void HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
+void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
     DiscardableSharedMemoryId id,
     int client_process_id) {
   base::AutoLock lock(lock_);
 
   MemorySegmentMap& process_segments = processes_[client_process_id];
 
   MemorySegmentMap::iterator segment_it = process_segments.find(id);
   if (segment_it == process_segments.end()) {
     LOG(ERROR) << "Invalid discardable shared memory ID";
     return;
   }
 
   size_t bytes_allocated_before_releasing_memory = bytes_allocated_;
 
   ReleaseMemory(segment_it->second->memory());
 
   process_segments.erase(segment_it);
 
   if (bytes_allocated_ != bytes_allocated_before_releasing_memory)
     BytesAllocatedChanged(bytes_allocated_);
 }
 
-void HostDiscardableSharedMemoryManager::OnMemoryPressure(
+void DiscardableSharedMemoryManager::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   base::AutoLock lock(lock_);
 
   switch (memory_pressure_level) {
     case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
       break;
     case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
       // Purge memory until usage is within half of |memory_limit_|.
       ReduceMemoryUsageUntilWithinLimit(memory_limit_ / 2);
       break;
     case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
       // Purge everything possible when pressure is critical.
       ReduceMemoryUsageUntilWithinLimit(0);
       break;
   }
 }
 
-void
-HostDiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinMemoryLimit() {
+void DiscardableSharedMemoryManager::ReduceMemoryUsageUntilWithinMemoryLimit() {
   lock_.AssertAcquired();
 
   if (bytes_allocated_ <= memory_limit_)
     return;
 
   ReduceMemoryUsageUntilWithinLimit(memory_limit_);
   if (bytes_allocated_ > memory_limit_)
     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
   // previously tried to evict but was locked.
   base::Time current_time = Now();
 
   lock_.AssertAcquired();
   size_t bytes_allocated_before_purging = bytes_allocated_;
   while (!segments_.empty()) {
     if (bytes_allocated_ <= limit)
@@ skipping 22 matching lines @@
     // Add memory segment (with updated usage timestamp) back on heap after
     // failed attempt to purge it.
     segments_.push_back(segment.get());
     std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime);
   }
 
   if (bytes_allocated_ != bytes_allocated_before_purging)
     BytesAllocatedChanged(bytes_allocated_);
 }
 
-void HostDiscardableSharedMemoryManager::ReleaseMemory(
+void DiscardableSharedMemoryManager::ReleaseMemory(
     base::DiscardableSharedMemory* memory) {
   lock_.AssertAcquired();
 
   size_t size = memory->mapped_size();
   DCHECK_GE(bytes_allocated_, size);
   bytes_allocated_ -= size;
 
   // This will unmap the memory segment and drop our reference. The result
   // is that the memory will be released to the OS if the child process is
   // no longer referencing it.
   // Note: We intentionally leave the segment in the |segments| vector to
   // avoid reconstructing the heap. The element will be removed from the heap
   // when its last usage time is older than all other segments.
   memory->Unmap();
   memory->Close();
 }
 
-void HostDiscardableSharedMemoryManager::BytesAllocatedChanged(
+void DiscardableSharedMemoryManager::BytesAllocatedChanged(
     size_t new_bytes_allocated) const {
   static const char kTotalDiscardableMemoryAllocatedKey[] =
       "total-discardable-memory-allocated";
   base::debug::SetCrashKeyValue(kTotalDiscardableMemoryAllocatedKey,
                                 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_)
     return;
 
   enforce_memory_policy_pending_ = true;
   DCHECK(enforce_memory_policy_task_runner_);
   enforce_memory_policy_task_runner_->PostDelayedTask(
       FROM_HERE, enforce_memory_policy_callback_,
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
-}  // namespace content
+}  // namespace discardable_memory