Add crash keys about field trial shared memory errors.

base/memory/shared_memory_posix.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 <fcntl.h>
 #include <stddef.h>
 #include <sys/mman.h>
@@ skipping 100 matching lines @@
   // the temporary files we create will just go into the buffer cache
   // and be deleted before they ever make it out to disk.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   ScopedFILE fp;
   bool fix_size = true;
   ScopedFD readonly_fd;
 
   FilePath path;
   if (options.name_deprecated == NULL || options.name_deprecated->empty()) {
-    bool result =
-        CreateAnonymousSharedMemory(options, &fp, &readonly_fd, &path);
+    bool result = CreateAnonymousSharedMemory(options, &fp, &readonly_fd, &path,
+                                              &last_error_);
     if (!result)
       return false;
   } else {
     if (!FilePathForMemoryName(*options.name_deprecated, &path))
       return false;
 
     // Make sure that the file is opened without any permission
     // to other users on the system.
     const mode_t kOwnerOnly = S_IRUSR | S_IWUSR;
 
@@ skipping 46 matching lines @@
       }
     }
     if (fd >= 0) {
       // "a+" is always appropriate: if it's a new file, a+ is similar to w+.
       fp.reset(fdopen(fd, "a+"));
     }
   }
   if (fp && fix_size) {
     // Get current size.
     struct stat stat;
     if (fstat(fileno(fp.get()), &stat) != 0)

[erikchen, 2017/05/10 17:42:11]

shouldn't every "return false" be prefixed with last_error_ update?

[Alexei Svitkine (slow), 2017/05/10 17:46:22]

This is in shared_memory_posix.cc code which Mac doesn't call. So this doesn't
need an update to investigate the Mac issue.

The only reason it has changes is it uses PrepareMapFile() and
CreateAnonymousSharedMemory() helpers that are shared with the Mac code and
whose signature is being changed.

       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)
         return false;
     }
     requested_size_ = options.size;
   }
   if (fp == NULL) {
     PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
     FilePath dir = path.DirName();
     if (access(dir.value().c_str(), W_OK | X_OK) < 0) {
       PLOG(ERROR) << "Unable to access(W_OK|X_OK) " << dir.value();
       if (dir.value() == "/dev/shm") {
         LOG(FATAL) << "This is frequently caused by incorrect permissions on "
                    << "/dev/shm.  Try 'sudo chmod 1777 /dev/shm' to fix.";
       }
     }
     return false;
   }
 
   int mapped_file = -1;
   int readonly_mapped_file = -1;
-  bool result = PrepareMapFile(std::move(fp), std::move(readonly_fd),
-                               &mapped_file, &readonly_mapped_file);
+  bool result =
+      PrepareMapFile(std::move(fp), std::move(readonly_fd), &mapped_file,
+                     &readonly_mapped_file, &last_error_);
   shm_ = SharedMemoryHandle(base::FileDescriptor(mapped_file, false),
                             UnguessableToken::Create());
   readonly_shm_ = SharedMemoryHandle(
       base::FileDescriptor(readonly_mapped_file, false), shm_.GetGUID());
   return result;
 }
 
 // Our current implementation of shmem is with mmap()ing of files.
 // These files need to be deleted explicitly.
 // In practice this call is only needed for unit tests.
@@ skipping 18 matching lines @@
 
   const char *mode = read_only ? "r" : "r+";
   ScopedFILE fp(base::OpenFile(path, mode));
   ScopedFD readonly_fd(HANDLE_EINTR(open(path.value().c_str(), O_RDONLY)));
   if (!readonly_fd.is_valid()) {
     DPLOG(ERROR) << "open(\"" << path.value() << "\", O_RDONLY) failed";
     return false;
   }
   int mapped_file = -1;
   int readonly_mapped_file = -1;
-  bool result = PrepareMapFile(std::move(fp), std::move(readonly_fd),
-                               &mapped_file, &readonly_mapped_file);
+  bool result =
+      PrepareMapFile(std::move(fp), std::move(readonly_fd), &mapped_file,
+                     &readonly_mapped_file, &last_error_);
   // This form of sharing shared memory is deprecated. https://crbug.com/345734.
   // However, we can't get rid of it without a significant refactor because its
   // used to communicate between two versions of the same service process, very
   // early in the life cycle.
   // Technically, we should also pass the GUID from the original shared memory
   // region. We don't do that - this means that we will overcount this memory,
   // which thankfully isn't relevant since Chrome only communicates with a
   // single version of the service process.
   shm_ = SharedMemoryHandle(base::FileDescriptor(mapped_file, false),
                             UnguessableToken::Create());
@@ skipping 120 matching lines @@
   struct stat file_stat;
   if (HANDLE_EINTR(
           ::fstat(static_cast<int>(handle().GetHandle()), &file_stat)) != 0)
     return false;
   id->first = file_stat.st_dev;
   id->second = file_stat.st_ino;
   return true;
 }
 
 }  // namespace base