Add crash keys about field trial shared memory errors.

base/memory/shared_memory_mac.cc

 // Copyright (c) 2012 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/memory/shared_memory.h"
 
 #include <errno.h>
 #include <mach/mach_vm.h>
 #include <stddef.h>
 #include <sys/mman.h>
@@ skipping 126 matching lines @@
 bool SharedMemory::GetSizeFromSharedMemoryHandle(
     const SharedMemoryHandle& handle,
     size_t* size) {
   return handle.GetSize(size);
 }
 
 // Chromium mostly only uses the unique/private shmem as specified by
 // "name == L"". The exception is in the StatsTable.
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
   DCHECK(!shm_.IsValid());
-  if (options.size == 0) return false;
+  if (options.size == 0) {
+    last_error_ = SharedMemoryError::BAD_PARAMS;
+    return false;
+  }
 
-  if (options.size > static_cast<size_t>(std::numeric_limits<int>::max()))
+  if (options.size > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    last_error_ = SharedMemoryError::BAD_PARAMS;
     return false;
+  }
 
   if (options.type == SharedMemoryHandle::MACH) {
     shm_ = SharedMemoryHandle(options.size, UnguessableToken::Create());
     requested_size_ = options.size;
     return shm_.IsValid();
   }
 
   // This function theoretically can block on the disk. Both profiling of real
   // users and local instrumentation shows that this is a real problem.
   // https://code.google.com/p/chromium/issues/detail?id=466437
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   ScopedFILE fp;
   ScopedFD readonly_fd;
 
   FilePath path;
-  bool result = CreateAnonymousSharedMemory(options, &fp, &readonly_fd, &path);
+  bool result = CreateAnonymousSharedMemory(options, &fp, &readonly_fd, &path,
+                                            &last_error_);
   if (!result)
     return false;
-
-  if (!fp) {
-    PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
-    return false;
-  }
+  DCHECK(fp);  // Should be guaranteed by CreateAnonymousSharedMemory().
 
   // Get current size.
   struct stat stat;
-  if (fstat(fileno(fp.get()), &stat) != 0)
+  if (fstat(fileno(fp.get()), &stat) != 0) {
+    last_error_ = SharedMemoryError::STAT_FAILED;
     return false;
+  }
   const size_t current_size = stat.st_size;
   if (current_size != options.size) {
-    if (HANDLE_EINTR(ftruncate(fileno(fp.get()), options.size)) != 0)
+    if (HANDLE_EINTR(ftruncate(fileno(fp.get()), options.size)) != 0) {
+      last_error_ = SharedMemoryError::TRUNCATE_FAILED;
       return false;
+    }
   }
   requested_size_ = options.size;
 
   int mapped_file = -1;
   int readonly_mapped_file = -1;
   result = PrepareMapFile(std::move(fp), std::move(readonly_fd), &mapped_file,
-                          &readonly_mapped_file);
+                          &readonly_mapped_file, &last_error_);
   shm_ = SharedMemoryHandle(FileDescriptor(mapped_file, false),
                             UnguessableToken::Create());
   readonly_shm_ = SharedMemoryHandle(
       FileDescriptor(readonly_mapped_file, false), shm_.GetGUID());
   return result;
 }
 
 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (!shm_.IsValid())
+  if (!shm_.IsValid()) {
+    last_error_ = SharedMemoryError::BAD_PARAMS;
     return false;
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
+  }
+  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    last_error_ = SharedMemoryError::BAD_PARAMS;
     return false;
-  if (memory_)
+  }
+  if (memory_) {
+    last_error_ = SharedMemoryError::BAD_PARAMS;
     return false;
+  }
 
   bool success = shm_.MapAt(offset, bytes, &memory_, read_only_);
   if (success) {
     mapped_size_ = bytes;
     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
                       (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
     mapped_memory_mechanism_ = shm_.type_;
   } else {
+    last_error_ = SharedMemoryError::MMAP_FAILED;
     memory_ = NULL;
   }
 
   return success;
 }
 
 bool SharedMemory::Unmap() {
   if (memory_ == NULL)
     return false;
 
@@ skipping 50 matching lines @@
 
   DCHECK(shm_.IsValid());
   base::SharedMemoryHandle new_handle;
   bool success = MakeMachSharedMemoryHandleReadOnly(&new_handle, shm_, memory_);
   if (success)
     new_handle.SetOwnershipPassesToIPC(true);
   return new_handle;
 }
 
 }  // namespace base