Remove SharedBuffer::unlock() and keep Resource's SharedBuffer always locked

third_party/WebKit/Source/platform/PurgeableVector.cpp

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 32 matching lines @@
 
 // DiscardableMemory allocations are expensive and page-grained. We only use
 // them when there's a reasonable amount of memory to be saved by the OS
 // discarding the memory.
 static const size_t minimumDiscardableAllocationSize = 4 * 4096;
 
 PurgeableVector::PurgeableVector(PurgeableOption purgeable)
     : m_discardableCapacity(0)
     , m_discardableSize(0)
     , m_isPurgeable(purgeable == Purgeable)
-    , m_locksCount(1) // The buffer is locked at creation.
 {
 }
 
 PurgeableVector::~PurgeableVector()
 {
 }
 
 void PurgeableVector::reserveCapacity(size_t capacity)
 {
-    ASSERT(isLocked());
-
     if (m_isPurgeable) {
         if (reservePurgeableCapacity(capacity, UseExactCapacity))
             return;
         // Fallback to non-purgeable buffer allocation in case discardable memory allocation failed.
     }
 
     if (!m_vector.capacity()) {
         // Using reserveInitialCapacity() on the underlying vector ensures that the vector uses the
         // exact specified capacity to avoid consuming too much memory for small resources.
         m_vector.reserveInitialCapacity(capacity);
@@ skipping 28 matching lines @@
 
 void PurgeableVector::clearDiscardable()
 {
     m_discardable = nullptr;
     m_discardableCapacity = 0;
     m_discardableSize = 0;
 }
 
 void PurgeableVector::append(const char* data, size_t length)
 {
-    ASSERT(isLocked());
-
     if (!m_isPurgeable) {
         m_vector.append(data, length);
         return;
     }
 
     const size_t currentSize = m_discardable ? m_discardableSize : m_vector.size();
     const size_t newBufferSize = currentSize + length;
 
     if (!reservePurgeableCapacity(newBufferSize, UseExponentialGrowth)) {
         moveDataFromDiscardableToVector();
@@ skipping 22 matching lines @@
 }
 
 void PurgeableVector::clear()
 {
     clearDiscardable();
     m_vector.clear();
 }
 
 char* PurgeableVector::data()
 {
-    ASSERT(isLocked());
     return m_discardable ? static_cast<char*>(m_discardable->data()) : m_vector.data();
 }
 
 size_t PurgeableVector::size() const
 {
     return m_discardable ? m_discardableSize : m_vector.size();
 }
 
 void PurgeableVector::adopt(Vector<char>& other)
 {
     if (size() > 0)
         clear();
 
     if (!m_isPurgeable) {
         m_vector.swap(other);
         return;
     }
 
     if (other.isEmpty())
         return;
 
     append(other.data(), other.size());
     other.clear();
 }
 
-bool PurgeableVector::lock()
-{
-    ++m_locksCount;
-    if (m_locksCount > 1)
-        return true;
-
-    ASSERT(m_locksCount == 1);
-    if (!m_discardable)
-        return true;
-
-    return m_discardable->Lock();
-}
-
-void PurgeableVector::unlock()
-{
-    ASSERT(isLocked());
-    --m_locksCount;
-    if (m_locksCount > 0)
-        return;
-
-    if (!m_vector.isEmpty()) {
-        ASSERT(!m_discardable);
-        m_isPurgeable = true;
-        if (!reservePurgeableCapacity(m_vector.size(), UseExactCapacity))
-            return;
-    }
-
-    if (m_discardable)
-        m_discardable->Unlock();
-}
-
-bool PurgeableVector::isLocked() const
-{
-    ASSERT(m_locksCount >= 0);
-    return m_locksCount > 0;
-}
-
 bool PurgeableVector::reservePurgeableCapacity(size_t capacity, PurgeableAllocationStrategy allocationStrategy)
 {
     ASSERT(m_isPurgeable);
 
     if (m_discardable && m_discardableCapacity >= capacity) {
         ASSERT(!m_vector.capacity());
         return true;
     }
 
     if (capacity < minimumDiscardableAllocationSize)
@@ skipping 33 matching lines @@
     // fragmentation.
     // Since the page size is only used below to minimize fragmentation it's still safe to use it
     // even if it gets out of sync (e.g. due to the use of huge pages).
     const size_t kPageSize = 4096;
     newCapacity = (newCapacity + kPageSize - 1) & ~(kPageSize - 1);
 
     return std::max(capacity, newCapacity); // Overflow check.
 }
 
 } // namespace blink