Move ashmem utility functions to discardable_memory_allocator_android.cc.

base/memory/discardable_memory_android.cc

 // Copyright (c) 2013 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_memory_android.h"
-
-#include <sys/mman.h>
-#include <unistd.h>
-
-#include <limits>
+#include "base/memory/discardable_memory.h"
 
 #include "base/android/sys_utils.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
-#include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/discardable_memory_allocator_android.h"
 #include "base/memory/discardable_memory_emulated.h"
 #include "base/memory/discardable_memory_malloc.h"
-#include "third_party/ashmem/ashmem.h"
 
 namespace base {
 namespace {
 
 const char kAshmemAllocatorName[] = "DiscardableMemoryAllocator";
 
 struct DiscardableMemoryAllocatorWrapper {
   DiscardableMemoryAllocatorWrapper()
       : allocator(kAshmemAllocatorName,
                   GetOptimalAshmemRegionSizeForAllocator()) {
   }
 
   internal::DiscardableMemoryAllocator allocator;
 
  private:
   // Returns 64 MBytes for a 512 MBytes device, 128 MBytes for 1024 MBytes...
   static size_t GetOptimalAshmemRegionSizeForAllocator() {
     // Note that this may do some I/O (without hitting the disk though) so it
     // should not be called on the critical path.
     return base::android::SysUtils::AmountOfPhysicalMemoryKB() * 1024 / 8;
   }
 };
 
 LazyInstance<DiscardableMemoryAllocatorWrapper>::Leaky g_context =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-namespace internal {
-
-bool CreateAshmemRegion(const char* name,
-                        size_t size,
-                        int* out_fd,
-                        void** out_address) {
-  int fd = ashmem_create_region(name, size);
-  if (fd < 0) {
-    DLOG(ERROR) << "ashmem_create_region() failed";
-    return false;
-  }
-  file_util::ScopedFD fd_closer(&fd);
-
-  const int err = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
-  if (err < 0) {
-    DLOG(ERROR) << "Error " << err << " when setting protection of ashmem";
-    return false;
-  }
-
-  // There is a problem using MAP_PRIVATE here. As we are constantly calling
-  // Lock() and Unlock(), data could get lost if they are not written to the
-  // underlying file when Unlock() gets called.
-  void* const address = mmap(
-      NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-  if (address == MAP_FAILED) {
-    DPLOG(ERROR) << "Failed to map memory.";
-    return false;
-  }
-
-  ignore_result(fd_closer.release());
-  *out_fd = fd;
-  *out_address = address;
-  return true;
-}
-
-bool CloseAshmemRegion(int fd, size_t size, void* address) {
-  if (munmap(address, size) == -1) {
-    DPLOG(ERROR) << "Failed to unmap memory.";
-    close(fd);
-    return false;
-  }
-  return close(fd) == 0;
-}
-
-DiscardableMemoryLockStatus LockAshmemRegion(int fd,
-                                             size_t off,
-                                             size_t size,
-                                             const void* address) {
-  const int result = ashmem_pin_region(fd, off, size);
-  DCHECK_EQ(0, mprotect(address, size, PROT_READ | PROT_WRITE));
-  return result == ASHMEM_WAS_PURGED ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
-                                     : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
-}
-
-bool UnlockAshmemRegion(int fd, size_t off, size_t size, const void* address) {
-  const int failed = ashmem_unpin_region(fd, off, size);
-  if (failed)
-    DLOG(ERROR) << "Failed to unpin memory.";
-  // This allows us to catch accesses to unlocked memory.
-  DCHECK_EQ(0, mprotect(address, size, PROT_NONE));
-  return !failed;
-}
-
-}  // namespace internal
-
 // static
 void DiscardableMemory::RegisterMemoryPressureListeners() {
   internal::DiscardableMemoryEmulated::RegisterMemoryPressureListeners();
 }
 
 // static
 void DiscardableMemory::UnregisterMemoryPressureListeners() {
   internal::DiscardableMemoryEmulated::UnregisterMemoryPressureListeners();
 }
 
@@ skipping 44 matching lines @@
 bool DiscardableMemory::PurgeForTestingSupported() {
   return false;
 }
 
 // static
 void DiscardableMemory::PurgeForTesting() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace base