Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(841)

Unified Diff: components/discardable_memory/client/client_discardable_shared_memory_manager.cc

Issue 2485623002: discardable_memory: Using mojo IPC to replace Chrome IPC (Closed)
Patch Set: Rebase Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: components/discardable_memory/client/client_discardable_shared_memory_manager.cc
diff --git a/components/discardable_memory/client/client_discardable_shared_memory_manager.cc b/components/discardable_memory/client/client_discardable_shared_memory_manager.cc
index 22239e13869644b0243684a01e7a3c60eea03de1..12b006c342942a80620dac040657c089ab623744 100644
--- a/components/discardable_memory/client/client_discardable_shared_memory_manager.cc
+++ b/components/discardable_memory/client/client_discardable_shared_memory_manager.cc
@@ -11,6 +11,7 @@
#include "base/atomic_sequence_num.h"
#include "base/bind.h"
+#include "base/callback_helpers.h"
#include "base/debug/crash_logging.h"
#include "base/macros.h"
#include "base/memory/discardable_memory.h"
@@ -21,9 +22,11 @@
#include "base/process/process_metrics.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/trace_event/memory_dump_manager.h"
#include "base/trace_event/trace_event.h"
+#include "mojo/public/cpp/system/platform_handle.h"
namespace discardable_memory {
namespace {
@@ -82,29 +85,55 @@ class DiscardableMemoryImpl : public base::DiscardableMemory {
DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl);
};
-void SendDeletedDiscardableSharedMemoryMessage(
- ClientDiscardableSharedMemoryManager::Delegate* delegate,
- DiscardableSharedMemoryId id) {
- delegate->DeletedDiscardableSharedMemory(id);
+void OnManagerMojoConnectionError(
+ mojom::DiscardableSharedMemoryManagerPtr* manager_mojo) {
+ manager_mojo->reset();
+}
+
+void InitManagerMojoOnIO(mojom::DiscardableSharedMemoryManagerPtr* manager_mojo,
+ mojom::DiscardableSharedMemoryManagerPtrInfo info) {
+ manager_mojo->Bind(std::move(info));
+ manager_mojo->set_connection_error_handler(
+ base::Bind(&OnManagerMojoConnectionError, manager_mojo));
+}
+
+void DeletedDiscardableSharedMemoryOnIO(
+ mojom::DiscardableSharedMemoryManagerPtr* manager_mojo,
+ int32_t id) {
+ if (!manager_mojo->is_bound())
+ return;
+ (*manager_mojo)->DeletedDiscardableSharedMemory(id);
}
} // namespace
ClientDiscardableSharedMemoryManager::ClientDiscardableSharedMemoryManager(
- Delegate* delegate)
- : heap_(base::GetPageSize()), delegate_(delegate) {
+ mojom::DiscardableSharedMemoryManagerPtrInfo info,
+ base::SingleThreadTaskRunner* io_task_runner)
+ : io_task_runner_(io_task_runner),
+ manager_mojo_(new mojom::DiscardableSharedMemoryManagerPtr),
+ heap_(new DiscardableSharedMemoryHeap(base::GetPageSize())) {
base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
this, "ClientDiscardableSharedMemoryManager",
base::ThreadTaskRunnerHandle::Get());
+ io_task_runner_->PostTask(
+ FROM_HERE, base::Bind(&InitManagerMojoOnIO, manager_mojo_.get(),
+ base::Passed(&info)));
}
ClientDiscardableSharedMemoryManager::~ClientDiscardableSharedMemoryManager() {
base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
this);
// TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533
- // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists());
- if (heap_.GetSize())
+ // DCHECK_EQ(heap_->GetSize(), heap_->GetSizeOfFreeLists());
+ if (heap_->GetSize())
MemoryUsageChanged(0, 0);
+ heap_.reset();
reveman 2016/11/18 21:55:25 nit: please add a short comment here explaining wh
Peng 2016/11/21 15:56:38 Done.
+
+ // Delete the manager on IO thread, so any pinding tasks on IO thread will be
reveman 2016/11/18 21:55:25 s/the manager on IO/the manager mojo on IO/? s/pin
Peng 2016/11/21 15:56:38 Done.
+ // executed before the manager is deleted.
+ bool posted = io_task_runner_->DeleteSoon(FROM_HERE, manager_mojo_.release());
+ DCHECK(posted);
}
std::unique_ptr<base::DiscardableMemory>
@@ -138,11 +167,11 @@ ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
if (pages < allocation_pages)
slack = allocation_pages - pages;
- size_t heap_size_prior_to_releasing_purged_memory = heap_.GetSize();
+ size_t heap_size_prior_to_releasing_purged_memory = heap_->GetSize();
for (;;) {
// Search free lists for suitable span.
std::unique_ptr<DiscardableSharedMemoryHeap::Span> free_span =
- heap_.SearchFreeLists(pages, slack);
+ heap_->SearchFreeLists(pages, slack);
if (!free_span.get())
break;
@@ -155,7 +184,7 @@ ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
base::DiscardableSharedMemory::FAILED) {
DCHECK(!free_span->shared_memory()->IsMemoryResident());
// We have to release purged memory before |free_span| can be destroyed.
- heap_.ReleasePurgedMemory();
+ heap_->ReleasePurgedMemory();
DCHECK(!free_span->shared_memory());
continue;
}
@@ -164,50 +193,50 @@ ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
// Memory usage is guaranteed to have changed after having removed
// at least one span from the free lists.
- MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
+ MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists());
return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(free_span));
}
// Release purged memory to free up the address space before we attempt to
// allocate more memory.
- heap_.ReleasePurgedMemory();
+ heap_->ReleasePurgedMemory();
// Make sure crash keys are up to date in case allocation fails.
- if (heap_.GetSize() != heap_size_prior_to_releasing_purged_memory)
- MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
+ if (heap_->GetSize() != heap_size_prior_to_releasing_purged_memory)
+ MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists());
size_t pages_to_allocate =
std::max(kAllocationSize / base::GetPageSize(), pages);
size_t allocation_size_in_bytes = pages_to_allocate * base::GetPageSize();
- DiscardableSharedMemoryId new_id =
- g_next_discardable_shared_memory_id.GetNext();
+ int32_t new_id = g_next_discardable_shared_memory_id.GetNext();
// Ask parent process to allocate a new discardable shared memory segment.
- std::unique_ptr<base::DiscardableSharedMemory> shared_memory(
- AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id));
+ std::unique_ptr<base::DiscardableSharedMemory> shared_memory =
+ AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id);
// Create span for allocated memory.
- std::unique_ptr<DiscardableSharedMemoryHeap::Span> new_span(
- heap_.Grow(std::move(shared_memory), allocation_size_in_bytes, new_id,
- base::Bind(&SendDeletedDiscardableSharedMemoryMessage,
- delegate_, new_id)));
+ std::unique_ptr<DiscardableSharedMemoryHeap::Span> new_span(heap_->Grow(
+ std::move(shared_memory), allocation_size_in_bytes, new_id,
+ base::Bind(
+ &ClientDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory,
+ base::Unretained(this), new_id)));
new_span->set_is_locked(true);
// Unlock and insert any left over memory into free lists.
if (pages < pages_to_allocate) {
std::unique_ptr<DiscardableSharedMemoryHeap::Span> leftover =
- heap_.Split(new_span.get(), pages);
+ heap_->Split(new_span.get(), pages);
leftover->shared_memory()->Unlock(
leftover->start() * base::GetPageSize() -
reinterpret_cast<size_t>(leftover->shared_memory()->memory()),
leftover->length() * base::GetPageSize());
leftover->set_is_locked(false);
- heap_.MergeIntoFreeLists(std::move(leftover));
+ heap_->MergeIntoFreeLists(std::move(leftover));
}
- MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
+ MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists());
return base::MakeUnique<DiscardableMemoryImpl>(this, std::move(new_span));
}
@@ -222,8 +251,8 @@ bool ClientDiscardableSharedMemoryManager::OnMemoryDump(
pmd->CreateAllocatorDump(
base::StringPrintf("discardable/child_0x%" PRIXPTR,
reinterpret_cast<uintptr_t>(this)));
- const size_t total_size = heap_.GetSize();
- const size_t freelist_size = heap_.GetSizeOfFreeLists();
+ const size_t total_size = heap_->GetSize();
+ const size_t freelist_size = heap_->GetSizeOfFreeLists();
total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
base::trace_event::MemoryAllocatorDump::kUnitsBytes,
total_size - freelist_size);
@@ -233,29 +262,29 @@ bool ClientDiscardableSharedMemoryManager::OnMemoryDump(
return true;
}
- return heap_.OnMemoryDump(pmd);
+ return heap_->OnMemoryDump(pmd);
}
ClientDiscardableSharedMemoryManager::Statistics
ClientDiscardableSharedMemoryManager::GetStatistics() const {
base::AutoLock lock(lock_);
Statistics stats;
- stats.total_size = heap_.GetSize();
- stats.freelist_size = heap_.GetSizeOfFreeLists();
+ stats.total_size = heap_->GetSize();
+ stats.freelist_size = heap_->GetSizeOfFreeLists();
return stats;
}
void ClientDiscardableSharedMemoryManager::ReleaseFreeMemory() {
base::AutoLock lock(lock_);
- size_t heap_size_prior_to_releasing_memory = heap_.GetSize();
+ size_t heap_size_prior_to_releasing_memory = heap_->GetSize();
// Release both purged and free memory.
- heap_.ReleasePurgedMemory();
- heap_.ReleaseFreeMemory();
+ heap_->ReleasePurgedMemory();
+ heap_->ReleaseFreeMemory();
- if (heap_.GetSize() != heap_size_prior_to_releasing_memory)
- MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
+ if (heap_->GetSize() != heap_size_prior_to_releasing_memory)
+ MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists());
}
bool ClientDiscardableSharedMemoryManager::LockSpan(
@@ -306,10 +335,10 @@ void ClientDiscardableSharedMemoryManager::ReleaseSpan(
if (!span->shared_memory())
return;
- heap_.MergeIntoFreeLists(std::move(span));
+ heap_->MergeIntoFreeLists(std::move(span));
// Bytes of free memory changed.
- MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
+ MemoryUsageChanged(heap_->GetSize(), heap_->GetSizeOfFreeLists());
}
base::trace_event::MemoryAllocatorDump*
@@ -318,25 +347,71 @@ ClientDiscardableSharedMemoryManager::CreateMemoryAllocatorDump(
const char* name,
base::trace_event::ProcessMemoryDump* pmd) const {
base::AutoLock lock(lock_);
- return heap_.CreateMemoryAllocatorDump(span, name, pmd);
+ return heap_->CreateMemoryAllocatorDump(span, name, pmd);
}
std::unique_ptr<base::DiscardableSharedMemory>
ClientDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
size_t size,
- DiscardableSharedMemoryId id) {
+ int32_t id) {
TRACE_EVENT2("renderer",
"ClientDiscardableSharedMemoryManager::"
"AllocateLockedDiscardableSharedMemory",
"size", size, "id", id);
+ std::unique_ptr<base::DiscardableSharedMemory> memory;
+ base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
+ base::WaitableEvent::InitialState::NOT_SIGNALED);
+ io_task_runner_->PostTask(
+ FROM_HERE, base::Bind(&ClientDiscardableSharedMemoryManager::AllocateOnIO,
+ base::Unretained(this), size, id, &memory, &event));
+ // Waiting until IPC has finished on the IO thread.
+ event.Wait();
+ return memory;
+}
+
+void ClientDiscardableSharedMemoryManager::AllocateOnIO(
+ size_t size,
+ int32_t id,
+ std::unique_ptr<base::DiscardableSharedMemory>* memory,
+ base::WaitableEvent* event) {
+ if (!manager_mojo_->is_bound())
+ return;
+ (*manager_mojo_)
+ ->AllocateLockedDiscardableSharedMemory(
+ static_cast<uint32_t>(size), id,
+ base::Bind(
+ &ClientDiscardableSharedMemoryManager::AllocateCompletedOnIO,
+ base::Unretained(this), memory, event));
+}
+void ClientDiscardableSharedMemoryManager::AllocateCompletedOnIO(
+ std::unique_ptr<base::DiscardableSharedMemory>* memory,
+ base::WaitableEvent* event,
+ mojo::ScopedSharedBufferHandle mojo_handle) {
+ base::ScopedClosureRunner event_signal_runner(
+ base::Bind(&base::WaitableEvent::Signal, base::Unretained(event)));
+
+ if (!mojo_handle.is_valid())
+ return;
base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle();
- delegate_->AllocateLockedDiscardableSharedMemory(size, id, &handle);
- std::unique_ptr<base::DiscardableSharedMemory> memory(
- new base::DiscardableSharedMemory(handle));
- if (!memory->Map(size))
- base::TerminateBecauseOutOfMemory(size);
- return memory;
+ size_t memory_size = 0;
+ bool read_only = false;
+ auto result = mojo::UnwrapSharedMemoryHandle(std::move(mojo_handle), &handle,
+ &memory_size, &read_only);
+ if (result != MOJO_RESULT_OK)
+ return;
+ auto discardable_shared_memory =
+ base::MakeUnique<base::DiscardableSharedMemory>(handle);
+ if (!discardable_shared_memory->Map(memory_size))
+ base::TerminateBecauseOutOfMemory(memory_size);
+ *memory = std::move(discardable_shared_memory);
+}
+
+void ClientDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
+ int32_t id) {
+ io_task_runner_->PostTask(
+ FROM_HERE,
+ base::Bind(&DeletedDiscardableSharedMemoryOnIO, manager_mojo_.get(), id));
}
void ClientDiscardableSharedMemoryManager::MemoryUsageChanged(

Powered by Google App Engine
This is Rietveld 408576698