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

third_party/WebKit/Source/platform/SharedBuffer.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 105 matching lines @@
     const char* segment;
     size_t position = 0;
     while (size_t length = data->getSomeDataInternal(segment, position)) {
         append(segment, length);
         position += length;
     }
 }
 
 void SharedBuffer::appendInternal(const char* data, size_t length)
 {
-    ASSERT(isLocked());
     if (!length)
         return;
 
     ASSERT(m_size >= m_buffer.size());
     size_t positionInSegment = offsetInSegment(m_size - m_buffer.size());
     m_size += length;
 
     if (m_size <= kSegmentSize) {
         // No need to use segments for small resource data.
         m_buffer.append(data, length);
@@ skipping 66 matching lines @@
             m_buffer.append(m_segments[i], bytesToCopy);
             bytesLeft -= bytesToCopy;
             freeSegment(m_segments[i]);
         }
         m_segments.clear();
     }
 }
 
 size_t SharedBuffer::getSomeDataInternal(const char*& someData, size_t position) const
 {
-    ASSERT(isLocked());
     size_t totalSize = size();
     if (position >= totalSize) {
         someData = 0;
         return 0;
     }
 
     ASSERT_WITH_SECURITY_IMPLICATION(position < m_size);
     size_t consecutiveSize = m_buffer.size();
     if (position < consecutiveSize) {
         someData = m_buffer.data() + position;
@@ skipping 52 matching lines @@
     }
 
     if (position != bufferLength) {
         ASSERT_NOT_REACHED();
         // Don't return the incomplete SkData.
         return nullptr;
     }
     return data;
 }
 
-bool SharedBuffer::lock()
-{
-    return m_buffer.lock();
-}
-
-void SharedBuffer::unlock()
-{
-    mergeSegmentsIntoBuffer();
-    m_buffer.unlock();
-}
-
-bool SharedBuffer::isLocked() const
-{
-    return m_buffer.isLocked();
-}
-
 void SharedBuffer::onMemoryDump(const String& dumpPrefix, WebProcessMemoryDump* memoryDump) const
 {
     if (m_buffer.size()) {
         m_buffer.onMemoryDump(dumpPrefix + "/shared_buffer", memoryDump);
     } else {
         // If there is data in the segments, then it should have been allocated
         // using fastMalloc.
         const String dataDumpName = dumpPrefix + "/segments";
         auto dump = memoryDump->createMemoryAllocatorDump(dataDumpName);
         dump->addScalar("size", "bytes", m_size);
         memoryDump->addSuballocation(dump->guid(), String(WTF::Partitions::kAllocatedObjectPoolName));
     }
 }
 
 } // namespace blink