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
Peng
2016/11/01 18:38:30
Done.
BTW for mojo, I don't think we can get proc
|
+} |
+ |
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 |