Move base to DEPS

base/memory/discardable_shared_memory.h

Index: base/memory/discardable_shared_memory.h
diff --git a/base/memory/discardable_shared_memory.h b/base/memory/discardable_shared_memory.h
deleted file mode 100644
index 74bbe8e95f427ba347d696e6c6e9c408e166e167..0000000000000000000000000000000000000000
--- a/base/memory/discardable_shared_memory.h
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright 2014 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_SHARED_MEMORY_H_
-#define BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/memory/shared_memory.h"
-#include "base/threading/thread_collision_warner.h"
-#include "base/time/time.h"
-
-#if DCHECK_IS_ON()
-#include <set>
-#endif
-
-// Define DISCARDABLE_SHARED_MEMORY_SHRINKING if platform supports shrinking
-// of discardable shared memory segments.
-#if defined(OS_POSIX) && !defined(OS_ANDROID)
-#define DISCARDABLE_SHARED_MEMORY_SHRINKING
-#endif
-
-namespace base {
-
-// Platform abstraction for discardable shared memory.
-//
-// This class is not thread-safe. Clients are responsible for synchronizing
-// access to an instance of this class.
-class BASE_EXPORT DiscardableSharedMemory {
- public:
-  enum LockResult { SUCCESS, PURGED, FAILED };
-
-  DiscardableSharedMemory();
-
-  // Create a new DiscardableSharedMemory object from an existing, open shared
-  // memory file. Memory must be locked.
-  explicit DiscardableSharedMemory(SharedMemoryHandle handle);
-
-  // Closes any open files.
-  virtual ~DiscardableSharedMemory();
-
-  // Creates and maps a locked DiscardableSharedMemory object with |size|.
-  // Returns true on success and false on failure.
-  bool CreateAndMap(size_t size);
-
-  // Maps the locked discardable memory into the caller's address space.
-  // Returns true on success, false otherwise.
-  bool Map(size_t size);
-
-  // Unmaps the discardable shared memory from the caller's address space.
-  // Returns true if successful; returns false on error or if the memory is
-  // not mapped.
-  bool Unmap();
-
-  // The actual size of the mapped memory (may be larger than requested).
-  size_t mapped_size() const { return mapped_size_; }
-
-  // Returns a shared memory handle for this DiscardableSharedMemory object.
-  SharedMemoryHandle handle() const { return shared_memory_.handle(); }
-
-  // Locks a range of memory so that it will not be purged by the system.
-  // The range of memory must be unlocked. The result of trying to lock an
-  // already locked range is undefined. |offset| and |length| must both be
-  // a multiple of the page size as returned by GetPageSize().
-  // Passing 0 for |length| means "everything onward".
-  // Returns SUCCESS if range was successfully locked and the memory is still
-  // resident, PURGED if range was successfully locked but has been purged
-  // since last time it was locked and FAILED if range could not be locked.
-  // Locking can fail for two reasons; object might have been purged, our
-  // last known usage timestamp might be out of date. Last known usage time
-  // is updated to the actual last usage timestamp if memory is still resident
-  // or 0 if not.
-  LockResult Lock(size_t offset, size_t length);
-
-  // Unlock a previously successfully locked range of memory. The range of
-  // memory must be locked. The result of trying to unlock a not
-  // previously locked range is undefined.
-  // |offset| and |length| must both be a multiple of the page size as returned
-  // by GetPageSize().
-  // Passing 0 for |length| means "everything onward".
-  void Unlock(size_t offset, size_t length);
-
-  // Gets a pointer to the opened discardable memory space. Discardable memory
-  // must have been mapped via Map().
-  void* memory() const;
-
-  // Returns the last known usage time for DiscardableSharedMemory object. This
-  // may be earlier than the "true" usage time when memory has been used by a
-  // different process. Returns NULL time if purged.
-  Time last_known_usage() const { return last_known_usage_; }
-
-  // This returns true and sets |last_known_usage_| to 0 if
-  // DiscardableSharedMemory object was successfully purged. Purging can fail
-  // for two reasons; object might be locked or our last known usage timestamp
-  // might be out of date. Last known usage time is updated to |current_time|
-  // if locked or the actual last usage timestamp if unlocked. It is often
-  // necessary to call this function twice for the object to successfully be
-  // purged. First call, updates |last_known_usage_|. Second call, successfully
-  // purges the object using the updated |last_known_usage_|.
-  // Note: there is no guarantee that multiple calls to this function will
-  // successfully purge object. DiscardableSharedMemory object might be locked
-  // or another thread/process might be able to lock and unlock it in between
-  // each call.
-  bool Purge(Time current_time);
-
-  // Returns true if memory is still resident.
-  bool IsMemoryResident() const;
-
-  // Closes the open discardable memory segment.
-  // It is safe to call Close repeatedly.
-  void Close();
-
-  // Shares the discardable memory segment to another process. Attempts to
-  // create a platform-specific |new_handle| which can be used in a remote
-  // process to access the discardable memory segment. |new_handle| is an
-  // output parameter to receive the handle for use in the remote process.
-  // Returns true on success, false otherwise.
-  bool ShareToProcess(ProcessHandle process_handle,
-                      SharedMemoryHandle* new_handle) {
-    return shared_memory_.ShareToProcess(process_handle, new_handle);
-  }
-
-#if defined(DISCARDABLE_SHARED_MEMORY_SHRINKING)
-  // Release as much memory as possible to the OS. The change in size will
-  // be reflected by the return value of mapped_size().
-  void Shrink();
-#endif
-
- private:
-  // Virtual for tests.
-  virtual Time Now() const;
-
-  SharedMemory shared_memory_;
-  size_t mapped_size_;
-  size_t locked_page_count_;
-#if DCHECK_IS_ON()
-  std::set<size_t> locked_pages_;
-#endif
-  // Implementation is not thread-safe but still usable if clients are
-  // synchronized somehow. Use a collision warner to detect incorrect usage.
-  DFAKE_MUTEX(thread_collision_warner_);
-  Time last_known_usage_;
-
-  DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemory);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_