base: Rename DiscardableMemory::Memory() to ::data().

mojo/services/html_viewer/discardable_memory_allocator.cc

 // Copyright 2015 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 "mojo/services/html_viewer/discardable_memory_allocator.h"
 
 #include "base/memory/discardable_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 
 namespace html_viewer {
 
 // Represents an actual memory chunk. This is an object owned by
 // DiscardableMemoryAllocator. DiscardableMemoryChunkImpl are passed to the
 // rest of the program, and access this memory through a weak ptr.
 class DiscardableMemoryAllocator::OwnedMemoryChunk {
  public:
   OwnedMemoryChunk(size_t size, DiscardableMemoryAllocator* allocator)
       : is_locked_(true),
         size_(size),
-        memory_(new uint8_t[size]),
+        data_(new uint8_t[size]),
         allocator_(allocator),
         weak_factory_(this) {}
   ~OwnedMemoryChunk() {}
 
   void Lock() {
     DCHECK(!is_locked_);
     is_locked_ = true;
     allocator_->NotifyLocked(unlocked_position_);
   }
 
   void Unlock() {
     DCHECK(is_locked_);
     is_locked_ = false;
     unlocked_position_ = allocator_->NotifyUnlocked(this);
   }
 
   bool is_locked() const { return is_locked_; }
   size_t size() const { return size_; }
-  void* Memory() const {
+  void* data() const {
     DCHECK(is_locked_);
-    return memory_.get();
+    return data_.get();
   }
 
   base::WeakPtr<OwnedMemoryChunk> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
  private:
   bool is_locked_;
   size_t size_;
-  scoped_ptr<uint8_t[]> memory_;
+  scoped_ptr<uint8_t[]> data_;
   DiscardableMemoryAllocator* allocator_;
 
   std::list<OwnedMemoryChunk*>::iterator unlocked_position_;
 
   base::WeakPtrFactory<OwnedMemoryChunk> weak_factory_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(OwnedMemoryChunk);
 };
 
 namespace {
@@ skipping 19 matching lines @@
 
     memory_chunk_->Lock();
     return true;
   }
 
   void Unlock() override {
     DCHECK(memory_chunk_);
     memory_chunk_->Unlock();
   }
 
-  void* Memory() const override {
+  void* data() const override {
     if (memory_chunk_)
-      return memory_chunk_->Memory();
+      return memory_chunk_->data();
     return nullptr;
   }
 
  private:
   base::WeakPtr<DiscardableMemoryAllocator::OwnedMemoryChunk> memory_chunk_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DiscardableMemoryChunkImpl);
 };
 
 }  // namespace
@@ skipping 37 matching lines @@
   return live_unlocked_chunks_.insert(live_unlocked_chunks_.end(), chunk);
 }
 
 void DiscardableMemoryAllocator::NotifyLocked(
     std::list<OwnedMemoryChunk*>::iterator it) {
   locked_chunks_++;
   live_unlocked_chunks_.erase(it);
 }
 
 }  // namespace html_viewer