1// Copyright (c) 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "content/child/child_shared_bitmap_manager.h" 6 7#include "content/child/child_thread.h" 8#include "content/common/child_process_messages.h" 9#include "ui/gfx/size.h" 10 11namespace content { 12 13namespace { 14 15void FreeSharedMemory(scoped_refptr<ThreadSafeSender> sender, 16 cc::SharedBitmap* bitmap) { 17 TRACE_EVENT0("renderer", "ChildSharedBitmapManager::FreeSharedMemory"); 18 sender->Send(new ChildProcessHostMsg_DeletedSharedBitmap(bitmap->id())); 19 delete bitmap->memory(); 20} 21 22void ReleaseSharedBitmap(scoped_refptr<ThreadSafeSender> sender, 23 cc::SharedBitmap* handle) { 24 TRACE_EVENT0("renderer", "ChildSharedBitmapManager::ReleaseSharedBitmap"); 25 sender->Send(new ChildProcessHostMsg_DeletedSharedBitmap(handle->id())); 26} 27 28} // namespace 29 30ChildSharedBitmapManager::ChildSharedBitmapManager( 31 scoped_refptr<ThreadSafeSender> sender) 32 : sender_(sender) { 33} 34 35ChildSharedBitmapManager::~ChildSharedBitmapManager() {} 36 37scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::AllocateSharedBitmap( 38 const gfx::Size& size) { 39 TRACE_EVENT2("renderer", 40 "ChildSharedBitmapManager::AllocateSharedMemory", 41 "width", 42 size.width(), 43 "height", 44 size.height()); 45 size_t memory_size; 46 if (!cc::SharedBitmap::SizeInBytes(size, &memory_size)) 47 return scoped_ptr<cc::SharedBitmap>(); 48 cc::SharedBitmapId id = cc::SharedBitmap::GenerateId(); 49 scoped_ptr<base::SharedMemory> memory; 50#if defined(OS_POSIX) 51 base::SharedMemoryHandle handle; 52 sender_->Send(new ChildProcessHostMsg_SyncAllocateSharedBitmap( 53 memory_size, id, &handle)); 54 memory = make_scoped_ptr(new base::SharedMemory(handle, false)); 55 CHECK(memory->Map(memory_size)); 56#else 57 memory.reset(ChildThread::AllocateSharedMemory(memory_size, sender_)); 58 CHECK(memory); 59 base::SharedMemoryHandle handle_to_send = memory->handle(); 60 sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap( 61 memory_size, handle_to_send, id)); 62#endif 63 return scoped_ptr<cc::SharedBitmap>(new cc::SharedBitmap( 64 memory.release(), id, base::Bind(&FreeSharedMemory, sender_))); 65} 66 67scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::GetSharedBitmapFromId( 68 const gfx::Size&, 69 const cc::SharedBitmapId&) { 70 NOTREACHED(); 71 return scoped_ptr<cc::SharedBitmap>(); 72} 73 74scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::GetBitmapForSharedMemory( 75 base::SharedMemory* mem) { 76 cc::SharedBitmapId id = cc::SharedBitmap::GenerateId(); 77 base::SharedMemoryHandle handle_to_send = mem->handle(); 78#if defined(OS_POSIX) 79 if (!mem->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send)) 80 return scoped_ptr<cc::SharedBitmap>(); 81#endif 82 sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap( 83 mem->mapped_size(), handle_to_send, id)); 84 // The compositor owning the SharedBitmap will be closed before the 85 // ChildThread containng this, making the use of base::Unretained safe. 86 return scoped_ptr<cc::SharedBitmap>( 87 new cc::SharedBitmap(mem, id, base::Bind(&ReleaseSharedBitmap, sender_))); 88} 89 90} // namespace content 91