Improve SharedMemory::Lock on Posix and reenable StatsTableTest.MultipleThreads

base/shared_memory_posix.cc

 // Copyright (c) 2011 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 "base/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "base/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/platform_thread.h"
 #include "base/safe_strerror_posix.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/foundation_util.h"
 #endif  // OS_MACOSX
 
 #if defined(OS_ANDROID)
 #include "base/os_compat_android.h"
 #include "third_party/ashmem/ashmem.h"
 #endif
 
 namespace base {
 
 namespace {
 
 // Paranoia. Semaphores and shared memory segments should live in different
 // namespaces, but who knows what's out there.
 const char kSemaphoreSuffix[] = "-sem";
 
+LazyInstance<Lock> g_thread_lock_ = LAZY_INSTANCE_INITIALIZER;

[jar (doing other things), 2012/02/25 00:01:39]

Should this be a leaky lazy instance?  Are you sure that nothing bad will happen
around shutdown time??

[vandebo (ex-Chrome), 2012/02/25 01:50:36]

Good point - The existing uses *might* be ok to use with a regular LazyInstance,
but a future caller could use it in a non-safe way.  Changed to a leaky lazy
instance.

+
 }
 
 SharedMemory::SharedMemory()
     : mapped_file_(-1),
       mapped_size_(0),
       inode_(0),
       memory_(NULL),
       read_only_(false),
       created_size_(0) {
 }
@@ skipping 214 matching lines @@
   Unmap();
 
   if (mapped_file_ > 0) {
     if (HANDLE_EINTR(close(mapped_file_)) < 0)
       PLOG(ERROR) << "close";
     mapped_file_ = -1;
   }
 }
 
 void SharedMemory::Lock() {
+  g_thread_lock_.Get().Acquire();
   LockOrUnlockCommon(F_LOCK);
 }
 
 void SharedMemory::Unlock() {
   LockOrUnlockCommon(F_ULOCK);
+  g_thread_lock_.Get().Release();
 }
 
 #if !defined(OS_ANDROID)
 bool SharedMemory::PrepareMapFile(FILE *fp) {
   DCHECK_EQ(-1, mapped_file_);
   if (fp == NULL) return false;
 
   // This function theoretically can block on the disk, but realistically
   // the temporary files we create will just go into the buffer cache
   // and be deleted before they ever make it out to disk.
@@ skipping 74 matching lines @@
   new_handle->fd = new_fd;
   new_handle->auto_close = true;
 
   if (close_self)
     Close();
 
   return true;
 }
 
 }  // namespace base