Added SharedMemory::MapFrom.

base/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/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/sys_info.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"
@@ skipping 183 matching lines @@
 
   read_only_ = read_only;
 
   const char *mode = read_only ? "r" : "r+";
   FILE *fp = file_util::OpenFile(path, mode);
   return PrepareMapFile(fp);
 }
 
 #endif  // !defined(OS_ANDROID)
 
-bool SharedMemory::Map(size_t bytes) {
+bool SharedMemory::MapAt(off_t offset, size_t bytes) {
   if (mapped_file_ == -1)
     return false;
 
   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
     return false;
 
 #if defined(OS_ANDROID)
   if (bytes == 0) {
     int ashmem_bytes = ashmem_get_size_region(mapped_file_);
     if (ashmem_bytes < 0)
       return false;
 
     DCHECK_GE(static_cast<uint32>(ashmem_bytes), bytes);
     // The caller wants to determine the map region size from ashmem.
     bytes = ashmem_bytes;
     // TODO(port): we set the created size here so that it is available in
     // transport_dib_android.cc. We should use ashmem_get_size_region()
     // in transport_dib_android.cc.
     created_size_ = bytes;
   }
 #endif
 
+  DCHECK_EQ(static_cast<size_t>(0),

[jar (doing other things), 2013/01/15 22:20:29]

I assume this call is not made that often... so how about doing a real check,
rather then a DCHECK (or at least returning false when this is violated)?

[Vitaly Buka (NO REVIEWS), 2013/01/15 22:58:54]

it will return false because memory_ will be invalid.

+            offset & (SysInfo::VMAllocationGranularity() - 1));

[Mark Mentovai, 2013/01/15 22:26:02]

My point was that this is sort of an implementation detail. There are a few
different reasons that memory_ might wind up NULL. Why are you singling this one
out and DCHECKing for it? mmap parameter validity checks are mmap’s
responsibility. If we want to crash when mmap returns NULL, we should
CHECK(memory_). Otherwise, why are you picking on one parameter and writing your
own debug-only check for it?

[Vitaly Buka (NO REVIEWS), 2013/01/15 22:58:54]

I don't believe we want crash on mmap returns null, it may happen on reasonable
runtime conditions.

So then I just remove dcheck.

   memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
-                 MAP_SHARED, mapped_file_, 0);
+                 MAP_SHARED, mapped_file_, offset);
 
   bool mmap_succeeded = memory_ != (void*)-1 && memory_ != NULL;
   if (mmap_succeeded) {
     mapped_size_ = bytes;
     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
   } else {
     memory_ = NULL;
   }
 
@@ skipping 123 matching lines @@
   new_handle->fd = new_fd;
   new_handle->auto_close = true;
 
   if (close_self)
     Close();
 
   return true;
 }
 
 }  // namespace base