Create a platform-dependent object for accessing purgeable memory.

src/ports/SkPurgeableMemoryBlock_android.cpp

+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkPurgeableMemoryBlock.h"
+
+#include "android/ashmem.h"
+#include <sys/mman.h>
+#include <unistd.h>
+
+bool SkPurgeableMemoryBlock::IsSupported() {
+    return true;
+}
+
+#ifdef SK_DEBUG
+bool SkPurgeableMemoryBlock::PlatformSupportsPurgingAllUnpinnedBlocks() {
+    return false;
+}
+
+bool SkPurgeableMemoryBlock::PurgeAllUnpinnedBlocks() {
+    return false;
+}
+
+bool SkPurgeableMemoryBlock::purge() {
+    SkASSERT(!fPinned);
+    if (-1 != fFD) {
+        ashmem_purge_all_caches(fFD);
+        return true;
+    } else {
+        return false;
+    }
+}
+#endif
+
+// ashmem likes lengths on page boundaries.
+static size_t round_to_page_size(size_t size) {
+    const size_t mask = getpagesize() - 1;
+    size_t newSize = (size + mask) & ~mask;
+    return newSize;
+}
+
+SkPurgeableMemoryBlock::SkPurgeableMemoryBlock(size_t size)
+    : fAddr(NULL)
+    , fSize(round_to_page_size(size))
+    , fPinned(false)
+    , fFD(-1) {
+}
+
+SkPurgeableMemoryBlock::~SkPurgeableMemoryBlock() {
+    if (-1 != fFD) {
+        munmap(fAddr, fSize);
+        close(fFD);
+    }
+}
+
+void* SkPurgeableMemoryBlock::pin(SkPurgeableMemoryBlock::PinResult* pinResult) {
+    SkASSERT(!fPinned);
+    if (-1 == fFD) {
+        int fd = ashmem_create_region(NULL, fSize);
+        if (-1 == fd) {
+            SkDebugf("ashmem_create_region failed\n");
+            return NULL;
+        }
+
+        int err = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
+        if (err != 0) {
+            SkDebugf("ashmem_set_prot_region failed\n");
+            close(fd);
+            return NULL;
+        }
+
+        void* addr = mmap(NULL, fSize, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+        if (-1 == (long) addr) {
+            SkDebugf("mmap failed\n");
+            close(fd);
+            return NULL;
+        }
+        fAddr = addr;
+        fFD = fd;
+        (void) ashmem_pin_region(fd, 0, 0);
+        *pinResult = kUninitialized_PinResult;
+        fPinned = true;
+    } else {
+        int pin = ashmem_pin_region(fFD, 0, 0);
+        if (ASHMEM_NOT_PURGED == pin) {
+            fPinned = true;
+            *pinResult = kRetained_PinResult;
+        } else if (ASHMEM_WAS_PURGED == pin) {
+            fPinned = true;
+            *pinResult = kUninitialized_PinResult;
+        } else {
+            // Failed.
+            munmap(fAddr, fSize);
+            close(fFD);
+            fFD = -1;
+            fAddr = NULL;
+        }
+    }
+    return fAddr;
+}
+
+void SkPurgeableMemoryBlock::unpin() {
+    if (-1 != fFD) {
+        ashmem_unpin_region(fFD, 0, 0);
+        fPinned = false;
+    }
+}
+