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 56 matching lines @@
     manager_->ChildDeletedSharedBitmap(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);
-  owned_bitmaps_.insert(id);
+  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,
     base::ProcessHandle process_handle,
     const cc::SharedBitmapId& id) {
-  manager_->ChildAllocatedSharedBitmap(buffer_size, handle, process_handle, id);
-  owned_bitmaps_.insert(id);
+  if (manager_->ChildAllocatedSharedBitmap(buffer_size, handle, process_handle,
+                                           id)) {
+    base::AutoLock lock(lock_);
+    owned_bitmaps_.insert(id);
+  }
 }
 
 void HostSharedBitmapManagerClient::ChildDeletedSharedBitmap(
     const cc::SharedBitmapId& id) {
   manager_->ChildDeletedSharedBitmap(id);
-  owned_bitmaps_.erase(id);
+  {
+    base::AutoLock lock(lock_);
+    owned_bitmaps_.erase(id);
+  }
 }
 
 HostSharedBitmapManager::HostSharedBitmapManager() {}
 HostSharedBitmapManager::~HostSharedBitmapManager() {
   DCHECK(handle_map_.empty());
 }
 
 HostSharedBitmapManager* HostSharedBitmapManager::current() {
   return g_shared_memory_manager.Pointer();
 }
@@ skipping 66 matching lines @@
     // Generate a global GUID used to share this allocation with renderer
     // processes.
     auto guid = cc::GetSharedBitmapGUIDForTracing(bitmap.first);
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid);
   }
 
   return true;
 }
 
-void HostSharedBitmapManager::ChildAllocatedSharedBitmap(
+bool HostSharedBitmapManager::ChildAllocatedSharedBitmap(
     size_t buffer_size,
     const base::SharedMemoryHandle& handle,
     base::ProcessHandle process_handle,
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   if (handle_map_.find(id) != handle_map_.end())
-    return;
+    return false;
   scoped_refptr<BitmapData> data(
       new BitmapData(process_handle, buffer_size));
 
   handle_map_[id] = data;
 #if defined(OS_WIN)
   data->memory = make_scoped_ptr(
       new base::SharedMemory(handle, false, data->process_handle));
 #else
   data->memory =
       make_scoped_ptr(new base::SharedMemory(handle, false));
 #endif
- data->memory->Map(data->buffer_size);
- data->memory->Close();
+  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();
@@ skipping 30 matching lines @@
   return handle_map_.size();
 }
 
 void HostSharedBitmapManager::FreeSharedMemoryFromMap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
 }  // namespace content