Clean up potentially leaky use of base::DeletePointer.

dbus/object_proxy.cc

 // Copyright (c) 2012 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 "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 311 matching lines @@
   } else if (dbus_message_get_type(response_message) ==
              DBUS_MESSAGE_TYPE_ERROR) {
     // This will take |response_message| and release (unref) it.
     scoped_ptr<ErrorResponse> error_response(
         ErrorResponse::FromRawMessage(response_message));
     error_callback.Run(error_response.get());
     // Delete the message  on the D-Bus thread. See below for why.
     bus_->GetDBusTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&base::DeletePointer<ErrorResponse>,
-                   error_response.release()));
+                   base::Passed(&error_response)));
   } else {
     // This will take |response_message| and release (unref) it.
     scoped_ptr<Response> response(Response::FromRawMessage(response_message));
     // The response is successfully received.
     response_callback.Run(response.get());
     // The message should be deleted on the D-Bus thread for a complicated
     // reason:
     //
     // libdbus keeps track of the number of bytes in the incoming message
     // queue to ensure that the data size in the queue is manageable. The
     // bookkeeping is partly done via dbus_message_unref(), and immediately
     // asks the client code (Chrome) to stop monitoring the underlying
     // socket, if the number of bytes exceeds a certian number, which is set
     // to 63MB, per dbus-transport.cc:
     //
     //   /* Try to default to something that won't totally hose the system,
     //    * but doesn't impose too much of a limitation.
     //    */
     //   transport->max_live_messages_size = _DBUS_ONE_MEGABYTE * 63;
     //
     // The monitoring of the socket is done on the D-Bus thread (see Watch
     // class in bus.cc), hence we should stop the monitoring from D-Bus
     // thread, not from the current thread here, which is likely UI thread.
     bus_->GetDBusTaskRunner()->PostTask(
         FROM_HERE,
-        base::Bind(&base::DeletePointer<Response>, response.release()));
+        base::Bind(&base::DeletePointer<Response>, base::Passed(&response)));
 
     method_call_successful = true;
     // Record time spent for the method call. Don't include failures.
     UMA_HISTOGRAM_TIMES("DBus.AsyncMethodCallTime",
                         base::TimeTicks::Now() - start_time);
   }
   // Record if the method call is successful, or not. 1 if successful.
   UMA_HISTOGRAM_ENUMERATION("DBus.AsyncMethodCallSuccess",
                             method_call_successful,
                             kSuccessRatioHistogramMaxValue);
@@ skipping 130 matching lines @@
     LOG(ERROR) << "Rejecting a message from a wrong sender.";
     UMA_HISTOGRAM_COUNTS("DBus.RejectedSignalCount", 1);
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
 
   const base::TimeTicks start_time = base::TimeTicks::Now();
   if (bus_->HasDBusThread()) {
     // Post a task to run the method in the origin thread.
     // Transfer the ownership of |signal| to RunMethod().
     // |released_signal| will be deleted in RunMethod().
-    Signal* released_signal = signal.release();
     bus_->GetOriginTaskRunner()->PostTask(FROM_HERE,
                                           base::Bind(&ObjectProxy::RunMethod,
                                                      this,
                                                      start_time,
                                                      iter->second,
-                                                     released_signal));
+                                                     base::Passed(&signal)));
   } else {
     const base::TimeTicks start_time = base::TimeTicks::Now();
     // If the D-Bus thread is not used, just call the callback on the
     // current thread. Transfer the ownership of |signal| to RunMethod().
-    Signal* released_signal = signal.release();
-    RunMethod(start_time, iter->second, released_signal);
+    RunMethod(start_time, iter->second, signal.Pass());
   }
 
   // We don't return DBUS_HANDLER_RESULT_HANDLED for signals because other
   // objects may be interested in them. (e.g. Signals from org.freedesktop.DBus)
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 void ObjectProxy::RunMethod(base::TimeTicks start_time,
                             std::vector<SignalCallback> signal_callbacks,
-                            Signal* signal) {
+                            scoped_ptr<Signal> signal) {
   bus_->AssertOnOriginThread();
 
   for (std::vector<SignalCallback>::iterator iter = signal_callbacks.begin();
        iter != signal_callbacks.end(); ++iter)
-    iter->Run(signal);
+    iter->Run(signal.get());
 
   // Delete the message on the D-Bus thread. See comments in
   // RunResponseCallback().
   bus_->GetDBusTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&base::DeletePointer<Signal>, signal));
+      base::Bind(&base::DeletePointer<Signal>, base::Passed(&signal)));
 
   // Record time spent for handling the signal.
   UMA_HISTOGRAM_TIMES("DBus.SignalHandleTime",
                       base::TimeTicks::Now() - start_time);
 }
 
 DBusHandlerResult ObjectProxy::HandleMessageThunk(
     DBusConnection* connection,
     DBusMessage* raw_message,
     void* user_data) {
@@ skipping 147 matching lines @@
     bool service_is_available) {
   bus_->AssertOnOriginThread();
 
   std::vector<WaitForServiceToBeAvailableCallback> callbacks;
   callbacks.swap(wait_for_service_to_be_available_callbacks_);
   for (size_t i = 0; i < callbacks.size(); ++i)
     callbacks[i].Run(service_is_available);
 }
 
 }  // namespace dbus