content: Remove non-thread-safe use of WeakPtrs.

content/child/child_discardable_shared_memory_manager.cc

 // 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.
 
 #include "content/child/child_discardable_shared_memory_manager.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/debug/crash_logging.h"
 #include "base/memory/discardable_memory.h"
@@ skipping 53 matching lines @@
   }
 
  private:
   ChildDiscardableSharedMemoryManager* const manager_;
   scoped_ptr<DiscardableSharedMemoryHeap::Span> span_;
   bool is_locked_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl);
 };
 
+void DeletedDiscardableSharedMemory(

[Avi (use Gerrit), 2015/03/27 21:13:01]

We name functions based on what they do, not when they are called.

For example:
- AllocateLockedDiscardableMemory
- LockSpan
- ReleaseFreeMemory

Name this after what it does.

[reveman, 2015/03/27 21:27:34]

Hm, this is supposed to handle the notification that DiscardableSharedMemory
instance was deleted. The current name matches the IPC and the IPC name matches
a number of similar IPCs. We could call it something like
NotifyHostThatDiscardableSharedMemoryWasDeleted here but I think I prefer to
keep this as it is. I don't feel that strongly about though and will change to
NotifyHost... if you prefer that?

[Avi (use Gerrit), 2015/03/27 21:38:46]

Something like SendMemoryDeletedMessage?. I'm looking for a verb to be the first
word.

[reveman, 2015/03/27 21:53:52]

SendDeletedDiscardableSharedMemoryMessage where "DeletedDiscardableSharedMemory"
is the name of the IPC message.

+    scoped_refptr<ThreadSafeSender> sender, DiscardableSharedMemoryId id) {
+  sender->Send(new ChildProcessHostMsg_DeletedDiscardableSharedMemory(id));
+}
+
 }  // namespace
 
 ChildDiscardableSharedMemoryManager::ChildDiscardableSharedMemoryManager(
-    ThreadSafeSender* sender)
-    : heap_(base::GetPageSize()), sender_(sender), weak_ptr_factory_(this) {
+    ThreadSafeSender* sender) : heap_(base::GetPageSize()), sender_(sender) {
 }
 
 ChildDiscardableSharedMemoryManager::~ChildDiscardableSharedMemoryManager() {
-  // Cancel all DeletedDiscardableSharedMemory callbacks.
-  weak_ptr_factory_.InvalidateWeakPtrs();
-
   // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533
   // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists());
   if (heap_.GetSize())
     MemoryUsageChanged(0, 0);
 }
 
 scoped_ptr<base::DiscardableMemory>
 ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
     size_t size) {
   base::AutoLock lock(lock_);
@@ skipping 65 matching lines @@
   DiscardableSharedMemoryId new_id =
       g_next_discardable_shared_memory_id.GetNext();
 
   // Ask parent process to allocate a new discardable shared memory segment.
   scoped_ptr<base::DiscardableSharedMemory> shared_memory(
       AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id));
 
   // Create span for allocated memory.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(heap_.Grow(
       shared_memory.Pass(), allocation_size_in_bytes,
-      base::Bind(
-          &ChildDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory,
-          weak_ptr_factory_.GetWeakPtr(), new_id)));
+      base::Bind(&DeletedDiscardableSharedMemory, sender_, new_id)));
 
   // Unlock and insert any left over memory into free lists.
   if (pages < pages_to_allocate) {
     scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover =
         heap_.Split(new_span.get(), pages);
     leftover->shared_memory()->Unlock(
         leftover->start() * base::GetPageSize() -
             reinterpret_cast<size_t>(leftover->shared_memory()->memory()),
         leftover->length() * base::GetPageSize());
     heap_.MergeIntoFreeLists(leftover.Pass());
@@ skipping 81 matching lines @@
   sender_->Send(
       new ChildProcessHostMsg_SyncAllocateLockedDiscardableSharedMemory(
           size, id, &handle));
   CHECK(base::SharedMemory::IsHandleValid(handle));
   scoped_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory(handle));
   CHECK(memory->Map(size));
   return memory.Pass();
 }
 
-void ChildDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
-    DiscardableSharedMemoryId id) {
-  sender_->Send(new ChildProcessHostMsg_DeletedDiscardableSharedMemory(id));
-}
-
 void ChildDiscardableSharedMemoryManager::MemoryUsageChanged(
     size_t new_bytes_total,
     size_t new_bytes_free) const {
   TRACE_COUNTER2("renderer", "DiscardableMemoryUsage", "allocated",
                  new_bytes_total - new_bytes_free, "free", new_bytes_free);
 
   static const char kDiscardableMemoryAllocatedKey[] =
       "discardable-memory-allocated";
   base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey,
                                 base::Uint64ToString(new_bytes_total));
 
   static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free";
   base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey,
                                 base::Uint64ToString(new_bytes_free));
 }
 
 }  // namespace content