Remove HostSharedBitmapManager::AllocateSharedBitmapForChild

components/display_compositor/host_shared_bitmap_manager.cc

 // Copyright 2013 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 "components/display_compositor/host_shared_bitmap_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 68 matching lines @@
     mojo::ScopedSharedBufferHandle buffer,
     const cc::SharedBitmapId& id) {
   base::SharedMemoryHandle memory_handle;
   size_t size;
   MojoResult result = mojo::UnwrapSharedMemoryHandle(
       std::move(buffer), &memory_handle, &size, NULL);
   DCHECK_EQ(result, MOJO_RESULT_OK);
   this->ChildAllocatedSharedBitmap(size, memory_handle, id);
 }
 
-void HostSharedBitmapManagerClient::AllocateSharedBitmapForChild(
-    base::ProcessHandle process_handle,
-    size_t buffer_size,
-    const cc::SharedBitmapId& id,
-    base::SharedMemoryHandle* shared_memory_handle) {
-  manager_->AllocateSharedBitmapForChild(process_handle, buffer_size, id,
-                                         shared_memory_handle);
-  if (*shared_memory_handle != base::SharedMemory::NULLHandle()) {
-    base::AutoLock lock(lock_);
-    owned_bitmaps_.insert(id);
-  }
-}
-
 void HostSharedBitmapManagerClient::ChildAllocatedSharedBitmap(
     size_t buffer_size,
     const base::SharedMemoryHandle& handle,
     const cc::SharedBitmapId& id) {
   if (manager_->ChildAllocatedSharedBitmap(buffer_size, handle, id)) {
     base::AutoLock lock(lock_);
     owned_bitmaps_.insert(id);
   }
 }
 
@@ skipping 96 matching lines @@
     return false;
   scoped_refptr<BitmapData> data(new BitmapData(buffer_size));
 
   handle_map_[id] = data;
   data->memory = base::MakeUnique<base::SharedMemory>(handle, false);
   data->memory->Map(data->buffer_size);
   data->memory->Close();
   return true;
 }
 
-void HostSharedBitmapManager::AllocateSharedBitmapForChild(
-    base::ProcessHandle process_handle,
-    size_t buffer_size,
-    const cc::SharedBitmapId& id,
-    base::SharedMemoryHandle* shared_memory_handle) {
-  base::AutoLock lock(lock_);
-  if (handle_map_.find(id) != handle_map_.end()) {
-    *shared_memory_handle = base::SharedMemory::NULLHandle();
-    return;
-  }
-  std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
-  if (!shared_memory->CreateAndMapAnonymous(buffer_size)) {
-    LOG(ERROR) << "Cannot create shared memory buffer";
-    *shared_memory_handle = base::SharedMemory::NULLHandle();
-    return;
-  }
-
-  scoped_refptr<BitmapData> data(new BitmapData(buffer_size));
-  data->memory = std::move(shared_memory);
-
-  handle_map_[id] = data;
-  if (!data->memory->ShareToProcess(process_handle, shared_memory_handle)) {
-    LOG(ERROR) << "Cannot share shared memory buffer";
-    *shared_memory_handle = base::SharedMemory::NULLHandle();
-    return;
-  }
-  data->memory->Close();
-}
-
 void HostSharedBitmapManager::ChildDeletedSharedBitmap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
 size_t HostSharedBitmapManager::AllocatedBitmapCount() const {
   base::AutoLock lock(lock_);
   return handle_map_.size();
 }
 
 void HostSharedBitmapManager::FreeSharedMemoryFromMap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
 }  // namespace display_compositor