base: Discardable memory types.

base/memory/discardable_memory.h

 // 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.
 
 #ifndef BASE_MEMORY_DISCARDABLE_MEMORY_H_
 #define BASE_MEMORY_DISCARDABLE_MEMORY_H_
 
+#include <string>
+#include <vector>
+
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace base {
 
-enum LockDiscardableMemoryStatus {
-  DISCARDABLE_MEMORY_FAILED = -1,
-  DISCARDABLE_MEMORY_PURGED = 0,
-  DISCARDABLE_MEMORY_SUCCESS = 1
+enum DiscardableMemoryType {
+  DISCARDABLE_MEMORY_TYPE_NONE,
+  DISCARDABLE_MEMORY_TYPE_ANDROID,

[willchan no longer on Chromium, 2013/12/24 01:21:06]

My inclination is to say we should guard these platform specific ones with the
platform specific defines. Any reason not to do this? Mainly, I don't feel like
we should let stuff like Mac code set the type to Android, and instead should
protect against this at compile-time. WDYT?

[reveman, 2013/12/26 11:46:08]

My plan here is to turn TYPE_ANDROID into TYPE_ASHMEM as I move the
implementation into discardable_memory_ashmem.cc and allow it to be used on
linux. I'd also like to turn TYPE_MAC into something like TYPE_DARWIN so it's
possible to have an _ios.cc file.

Passing TYPE_ASHMEM to SetType on MacOSX without checking if it's supported is
the same as passing TYPE_NONE. Hypothetically, some implementation might also
build on a platform but not be supported. ie. maybe we decide that the current
mac implementation should not be used on iOS but we want to make sure it keeps
building in case we want to use it in the future. Or maybe we don't want to
support TYPE_EMULATED or some future experimental implementation on some
specific platform.

That said, we could still guard these types using the same conditions we use to
decide what implementations to build. I'm OK with that but I think the compile
time protection we get here is weak at its best and not worth polluting this and
the .cc file with platform ifdefs for.

[willchan no longer on Chromium, 2013/12/26 18:25:54]

This isn't a big deal and is mostly stylistic preference. I'm cool with whatever
you want. Figured I'd just voice my minor pref just to make sure you considered
it.

[reveman, 2013/12/26 21:53:35]

I'll keep it in mind and re-evaluate as I land more refactor patches. 

+  DISCARDABLE_MEMORY_TYPE_MAC,
+  DISCARDABLE_MEMORY_TYPE_EMULATED
+};
+
+enum DiscardableMemoryLockStatus {
+  DISCARDABLE_MEMORY_LOCK_STATUS_FAILED,
+  DISCARDABLE_MEMORY_LOCK_STATUS_PURGED,
+  DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS
 };
 
 // Platform abstraction for discardable memory. DiscardableMemory is used to
 // cache large objects without worrying about blowing out memory, both on mobile
 // devices where there is no swap, and desktop devices where unused free memory
 // should be used to help the user experience. This is preferable to releasing
 // memory in response to an OOM signal because it is simpler, though it has less
 // flexibility as to which objects get discarded.
 //
 // Discardable memory has two states: locked and unlocked. While the memory is
@@ skipping 17 matching lines @@
 //   - Linux: http://lwn.net/Articles/452035/
 //   - Mac: http://trac.webkit.org/browser/trunk/Source/WebCore/platform/mac/PurgeableBufferMac.cpp
 //          the comment starting with "vm_object_purgable_control" at
 //            http://www.opensource.apple.com/source/xnu/xnu-792.13.8/osfmk/vm/vm_object.c
 //
 // Thread-safety: DiscardableMemory instances are not thread-safe.
 class BASE_EXPORT DiscardableMemory {
  public:
   virtual ~DiscardableMemory() {}
 
-  // Check whether the system supports discardable memory natively. Returns
-  // false if the support is emulated.
-  static bool SupportedNatively();
+  // Gets the discardable memory type with a given name.
+  static DiscardableMemoryType GetNamedType(const std::string& name);
+
+  // Gets the name of a discardable memory type.
+  static const char* GetTypeName(DiscardableMemoryType type);
+
+  // Gets system supported discardable memory types. Preferred type at the
+  // front of vector.
+  static void GetSupportedTypes(std::vector<DiscardableMemoryType>* types);
+
+  // Sets the current discardable memory type.
+  static void SetType(DiscardableMemoryType type);
+
+  // Gets the current discardable memory type.
+  static DiscardableMemoryType GetType();
 
   static scoped_ptr<DiscardableMemory> CreateLockedMemory(size_t size);
 
   // Locks the memory so that it will not be purged by the system. Returns
-  // DISCARDABLE_MEMORY_SUCCESS on success. If the return value is
-  // DISCARDABLE_MEMORY_FAILED then this object should be discarded and
-  // a new one should be created. If the return value is
-  // DISCARDABLE_MEMORY_PURGED then the memory is present but any data that
-  // was in it is gone.
-  virtual LockDiscardableMemoryStatus Lock() WARN_UNUSED_RESULT = 0;
+  // DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS on success. If the return value is
+  // DISCARDABLE_MEMORY_LOCK_STATUS_FAILED then this object should be
+  // discarded and a new one should be created. If the return value is
+  // DISCARDABLE_MEMORY_LOCK_STATUS_PURGED then the memory is present but any
+  // data that was in it is gone.
+  virtual DiscardableMemoryLockStatus Lock() WARN_UNUSED_RESULT = 0;
 
   // Unlocks the memory so that it can be purged by the system. Must be called
   // after every successful lock call.
   virtual void Unlock() = 0;
 
   // Returns the memory address held by this object. The object must be locked
   // before calling this. Otherwise, this will cause a DCHECK error.
   virtual void* Memory() const = 0;
 
   // Testing utility calls.
 
   // Check whether a purge of all discardable memory in the system is supported.
   // Use only for testing!
   static bool PurgeForTestingSupported();
 
   // Purge all discardable memory in the system. This call has global effects
   // across all running processes, so it should only be used for testing!
   static void PurgeForTesting();
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_DISCARDABLE_MEMORY_H_