Add lock around modification of HostSharedBitmapManagerClient::owned_bitmaps_

content/common/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 "content/common/host_shared_bitmap_manager.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/process_memory_dump.h"
@@ skipping 45 matching lines @@
 
 base::LazyInstance<HostSharedBitmapManager> g_shared_memory_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 HostSharedBitmapManagerClient::HostSharedBitmapManagerClient(
     HostSharedBitmapManager* manager)
     : manager_(manager) {
 }
 
 HostSharedBitmapManagerClient::~HostSharedBitmapManagerClient() {
+  base::AutoLock lock(lock_);
   for (const auto& id : owned_bitmaps_)
     manager_->ChildDeletedSharedBitmap(id);
 }
 
 void HostSharedBitmapManagerClient::AllocateSharedBitmapForChild(
     base::ProcessHandle process_handle,
     size_t buffer_size,
     const cc::SharedBitmapId& id,
     base::SharedMemoryHandle* shared_memory_handle) {
+  base::AutoLock lock(lock_);

[piman, 2015/11/24 01:39:58]

Is it possible to lock only when accessing the map? This is used on the FILE
thread because arguably it takes time. We wouldn't want to block the IO thread
during that time.

   manager_->AllocateSharedBitmapForChild(process_handle, buffer_size, id,
                                          shared_memory_handle);
   owned_bitmaps_.insert(id);
 }
 
 void HostSharedBitmapManagerClient::ChildAllocatedSharedBitmap(
     size_t buffer_size,
     const base::SharedMemoryHandle& handle,
     base::ProcessHandle process_handle,
     const cc::SharedBitmapId& id) {
+  base::AutoLock lock(lock_);
   manager_->ChildAllocatedSharedBitmap(buffer_size, handle, process_handle, id);
   owned_bitmaps_.insert(id);
 }
 
 void HostSharedBitmapManagerClient::ChildDeletedSharedBitmap(
     const cc::SharedBitmapId& id) {
+  base::AutoLock lock(lock_);
   manager_->ChildDeletedSharedBitmap(id);
   owned_bitmaps_.erase(id);
 }
 
 HostSharedBitmapManager::HostSharedBitmapManager() {}
 HostSharedBitmapManager::~HostSharedBitmapManager() {
   DCHECK(handle_map_.empty());
 }
 
 HostSharedBitmapManager* HostSharedBitmapManager::current() {
@@ skipping 139 matching lines @@
   return handle_map_.size();
 }
 
 void HostSharedBitmapManager::FreeSharedMemoryFromMap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
 }  // namespace content