Update from https://crrev.com/316786

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"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
@@ skipping 144 matching lines @@
 #endif
 
   return true;
 }
 
 DiscardableSharedMemory::LockResult DiscardableSharedMemory::Lock(
     size_t offset, size_t length) {
   DCHECK_EQ(AlignToPageSize(offset), offset);
   DCHECK_EQ(AlignToPageSize(length), length);
 
-  // Calls to this function must synchronized properly.
+  // Calls to this function must be synchronized properly.
   DFAKE_SCOPED_LOCK(thread_collision_warner_);
 
-  // Return false when instance has been purged or not initialized properly by
-  // checking if |last_known_usage_| is NULL.
-  if (last_known_usage_.is_null())
-    return FAILED;
-
   DCHECK(shared_memory_.memory());
 
   // We need to successfully acquire the platform independent lock before
   // individual pages can be locked.
   if (!locked_page_count_) {
+    // Return false when instance has been purged or not initialized properly
+    // by checking if |last_known_usage_| is NULL.
+    if (last_known_usage_.is_null())
+      return FAILED;
+
     SharedState old_state(SharedState::UNLOCKED, last_known_usage_);
     SharedState new_state(SharedState::LOCKED, Time());
     SharedState result(subtle::Acquire_CompareAndSwap(
         &SharedStateFromSharedMemory(shared_memory_)->value.i,
         old_state.value.i,
         new_state.value.i));
     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();
@@ skipping 31 matching lines @@
   }
 #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 synchronized properly.
+  // 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());
 
 #if defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
@@ skipping 47 matching lines @@
 
   last_known_usage_ = current_time;
 }
 
 void* DiscardableSharedMemory::memory() const {
   return reinterpret_cast<uint8*>(shared_memory_.memory()) +
          AlignToPageSize(sizeof(SharedState));
 }
 
 bool DiscardableSharedMemory::Purge(Time current_time) {
-  // Calls to this function must synchronized properly.
+  // Calls to this function must be synchronized properly.
   DFAKE_SCOPED_LOCK(thread_collision_warner_);
 
   // Early out if not mapped. This can happen if the segment was previously
   // unmapped using a call to Close().
   if (!shared_memory_.memory())
     return true;
 
   SharedState old_state(SharedState::UNLOCKED, last_known_usage_);
   SharedState new_state(SharedState::UNLOCKED, Time());
   SharedState result(subtle::Acquire_CompareAndSwap(
@@ skipping 47 matching lines @@
   shared_memory_.Unmap();
   shared_memory_.Close();
   mapped_size_ = 0;
 }
 
 Time DiscardableSharedMemory::Now() const {
   return Time::Now();
 }
 
 }  // namespace base