Clean up potentially leaky use of base::DeletePointer.

ipc/mojo/async_handle_waiter.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 "ipc/mojo/async_handle_waiter.h"
 
 #include "base/atomic_ref_count.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
 
 namespace IPC {
 namespace internal {
 
 class AsyncHandleWaiterContextTraits {
  public:
   static void Destruct(const AsyncHandleWaiter::Context* context);
+  static void Delete(const AsyncHandleWaiter::Context* context);
 };
 
 // The thread-safe part of |AsyncHandleWaiter|.
 // As |AsyncWait()| invokes the given callback from an arbitrary thread,
 // |HandleIsReady()| and the bound |this| have to be thread-safe.
 class AsyncHandleWaiter::Context
     : public base::RefCountedThreadSafe<AsyncHandleWaiter::Context,
                                         AsyncHandleWaiterContextTraits>,
       public base::MessageLoopForIO::IOObserver {
  public:
@@ skipping 14 matching lines @@
     if (IsCalledFromIOHandler()) {
       should_invoke_callback_ = true;
       return;
     }
 
     io_runner_->PostTask(FROM_HERE,
                          base::Bind(&Context::InvokeWaiterCallback, this));
   }
 
  private:
-  friend void base::DeletePointer<const Context>(const Context* self);
   friend class AsyncHandleWaiterContextTraits;
+  friend class base::internal::OwnedWrapper<
+    const IPC::internal::AsyncHandleWaiter::Context>;
   friend class base::RefCountedThreadSafe<Context>;
 
   ~Context() override {
     DCHECK(base::MessageLoopForIO::current()->task_runner() == io_runner_);
     base::MessageLoopForIO::current()->RemoveIOObserver(this);
   }
 
   bool IsCalledFromIOHandler() const {
     base::MessageLoop* loop = base::MessageLoop::current();
     if (!loop)
@@ skipping 84 matching lines @@
 
 base::Callback<void(MojoResult)> AsyncHandleWaiter::GetWaitCallbackForTest() {
   return base::Bind(&Context::HandleIsReady, context_);
 }
 
 // static
 void AsyncHandleWaiterContextTraits::Destruct(
     const AsyncHandleWaiter::Context* context) {
   context->io_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&base::DeletePointer<const AsyncHandleWaiter::Context>,
-                 base::Unretained(context)));
+      base::Bind(&AsyncHandleWaiterContextTraits::Delete,
+                 base::Owned(context)));
+}
+
+// static
+void AsyncHandleWaiterContextTraits::Delete(
+    const AsyncHandleWaiter::Context* context) {
+  // base::Owned() is going to do it for us.
 }
 
 }  // namespace internal
 }  // namespace IPC