[Discardable Shared Memory] Remove Windows (un)pinning support.

base/memory/discardable_shared_memory.cc

 // Copyright 2014 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/discardable_shared_memory.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/atomicops.h"
 #include "base/bits.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/process/process_metrics.h"
 #include "build/build_config.h"
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 // For madvise() which is available on all POSIX compatible systems.
 #include <sys/mman.h>
 #endif
 
 #if defined(OS_ANDROID)
 #include "third_party/ashmem/ashmem.h"
 #endif
 
-#if defined(OS_WIN)
-#include "base/win/windows_version.h"
-#endif
-
 namespace base {
 namespace {
 
 // Use a machine-sized pointer as atomic type. It will use the Atomic32 or
 // Atomic64 routines, depending on the architecture.
 typedef intptr_t AtomicType;
 typedef uintptr_t UAtomicType;
 
 // Template specialization for timestamp serialization/deserialization. This
 // is used to serialize timestamps using Unix time on systems where AtomicType
@@ skipping 186 matching lines @@
 
 // Pin pages if supported.
 #if defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
   if (SharedMemory::IsHandleValid(handle)) {
     if (ashmem_pin_region(
             handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
       return PURGED;
     }
   }
-#elif defined(OS_WIN)
-  if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
-    if (!VirtualAlloc(reinterpret_cast<char*>(shared_memory_.memory()) +
-                          AlignToPageSize(sizeof(SharedState)) + offset,
-                      length, MEM_RESET_UNDO, PAGE_READWRITE)) {

[danakj, 2016/03/25 23:49:39]

I'm confused by this code heh.

https://msdn.microsoft.com/en-us/library/windows/desktop/aa366887(v=vs.85).aspx
says MEM_RESET_UNDO "should only be called on an address range to which
MEM_RESET was successfully applied earlier", but Lock() is usually called before
Unlock(), or not in this case?

Were we using this incorrectly? I don't suppose that could be related to our
woes.

[reveman, 2016/03/26 07:01:10]

Discardable memory is initially locked. The only time we'd call Lock is as a
result of first calling Unlock.

-      return PURGED;
-    }
-  }
 #endif
 
   return SUCCESS;
 }
 
 void DiscardableSharedMemory::Unlock(size_t offset, size_t length) {
   DCHECK_EQ(AlignToPageSize(offset), offset);
   DCHECK_EQ(AlignToPageSize(length), length);
 
   // Calls to this function must be synchronized properly.
   DFAKE_SCOPED_LOCK(thread_collision_warner_);
 
   // Zero for length means "everything onward".
   if (!length)
     length = AlignToPageSize(mapped_size_) - offset;
 
   DCHECK(shared_memory_.memory());
 
 // Unpin pages if supported.
 #if defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
   if (SharedMemory::IsHandleValid(handle)) {
     if (ashmem_unpin_region(
             handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
       DPLOG(ERROR) << "ashmem_unpin_region() failed";
     }
   }
-#elif defined(OS_WIN)
-  if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
-    // Note: MEM_RESET is not technically gated on Win8.  However, this Unlock
-    // function needs to match the Lock behaviour (MEM_RESET_UNDO) to properly
-    // implement memory pinning.  It needs to bias towards preserving the
-    // contents of memory between an Unlock and next Lock.
-    if (!VirtualAlloc(reinterpret_cast<char*>(shared_memory_.memory()) +
-                          AlignToPageSize(sizeof(SharedState)) + offset,
-                      length, MEM_RESET, PAGE_READWRITE)) {
-      DPLOG(ERROR) << "VirtualAlloc() MEM_RESET failed in Unlock()";
-    }
-  }
 #endif
 
   size_t start = offset / base::GetPageSize();
   size_t end = start + length / base::GetPageSize();
   DCHECK_LE(start, end);
   DCHECK_LE(end, AlignToPageSize(mapped_size_) / base::GetPageSize());
 
   // Remove pages from |locked_page_count_|.
   // Note: Unlocking a page that is not locked is an error.
   DCHECK_GE(locked_page_count_, end - start);
@@ skipping 120 matching lines @@
 
 void DiscardableSharedMemory::Close() {
   shared_memory_.Close();
 }
 
 Time DiscardableSharedMemory::Now() const {
   return Time::Now();
 }
 
 }  // namespace base