Deprecate named base::SharedMemory.

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 <sys/mman.h>
 #include <sys/stat.h>
@@ skipping 118 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;
   int readonly_fd_storage = -1;
   ScopedFD readonly_fd(&readonly_fd_storage);
 
   FilePath path;
-  if (options.name == NULL || options.name->empty()) {
+  if (options.name_deprecated == NULL || options.name_deprecated->empty()) {
     // It doesn't make sense to have a open-existing private piece of shmem
-    DCHECK(!options.open_existing);
+    DCHECK(!options.open_existing_deprecated);
     // Q: Why not use the shm_open() etc. APIs?
     // A: Because they're limited to 4mb on OS X.  FFFFFFFUUUUUUUUUUU
     fp.reset(base::CreateAndOpenTemporaryShmemFile(&path, options.executable));
 
     if (fp) {
       // Also open as readonly so that we can ShareReadOnlyToProcess.
       *readonly_fd = HANDLE_EINTR(open(path.value().c_str(), O_RDONLY));
       if (*readonly_fd < 0) {
         DPLOG(ERROR) << "open(\"" << path.value() << "\", O_RDONLY) failed";
         fp.reset();
       }
       // Deleting the file prevents anyone else from mapping it in (making it
       // private), and prevents the need for cleanup (once the last fd is
       // closed, it is truly freed).
       if (unlink(path.value().c_str()))
         PLOG(WARNING) << "unlink";
     }
   } else {
-    if (!FilePathForMemoryName(*options.name, &path))
+    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;
 
     // First, try to create the file.
     int fd = HANDLE_EINTR(
         open(path.value().c_str(), O_RDWR | O_CREAT | O_EXCL, kOwnerOnly));
-    if (fd == -1 && options.open_existing) {
+    if (fd == -1 && options.open_existing_deprecated) {
       // If this doesn't work, try and open an existing file in append mode.
       // Opening an existing file in a world writable directory has two main
       // security implications:
       // - Attackers could plant a file under their control, so ownership of
       //   the file is checked below.
       // - Attackers could plant a symbolic link so that an unexpected file
       //   is opened, so O_NOFOLLOW is passed to open().
       fd = HANDLE_EINTR(
           open(path.value().c_str(), O_RDWR | O_APPEND | O_NOFOLLOW));
 
@@ skipping 278 matching lines @@
   new_handle->fd = new_fd;
   new_handle->auto_close = true;
 
   if (close_self)
     Close();
 
   return true;
 }
 
 }  // namespace base