base: Avoid calling VirtualAlloc with 0 length.

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>
 
@@ skipping 184 matching lines @@
     if (result.value.u != old_state.value.u) {
       // Update |last_known_usage_| in case the above CAS failed because of
       // an incorrect timestamp.
       last_known_usage_ = result.GetTimestamp();
       return FAILED;
     }
   }
 
   // Zero for length means "everything onward".
   if (!length)
     length = AlignToPageSize(mapped_size_) - offset;

[Nico, 2016/02/29 20:10:13]

this writes to length_ if it's 0 and nothing after this writes to it. Does this
mean mapped_size_ - offset is 0 here? should your change be here, since this
already tries to handle that case?

What happens if callers pass in an offset larget than mapped_size_, won't this
underflow?

[reveman, 2016/02/29 20:42:45]

correct.
The DCHECK below will catch that and that's also why I prefer having the "if
(!length) return PURGED" below. I'd rather not duplicate that DCHECK logic here
only for the case where length==0. Does that make sense?  

 
   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());
 
   // Add pages to |locked_page_count_|.
   // Note: Locking a page that is already locked is an error.
   locked_page_count_ += end - start;
 #if DCHECK_IS_ON()
   // Detect incorrect usage by keeping track of exactly what pages are locked.
   for (auto page = start; page < end; ++page) {
     auto result = locked_pages_.insert(page);
     DCHECK(result.second);
   }
   DCHECK_EQ(locked_pages_.size(), locked_page_count_);
 #endif
 
+  // Always behave as if memory was purged when trying to lock a 0 byte segment.
+  if (!length)
+      return PURGED;
+
 // 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)
@@ skipping 176 matching lines @@
 
 void DiscardableSharedMemory::Close() {
   shared_memory_.Close();
 }
 
 Time DiscardableSharedMemory::Now() const {
   return Time::Now();
 }
 
 }  // namespace base