Code cleaning: Uses scoped_ptr<> to express ownership rather than writing ownership in comments.

dbus/message.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/message.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/format_macros.h"
@@ skipping 382 matching lines @@
   return signal;
 }
 
 //
 // Response implementation.
 //
 
 Response::Response() : Message() {
 }
 
-Response* Response::FromRawMessage(DBusMessage* raw_message) {
+scoped_ptr<Response> Response::FromRawMessage(DBusMessage* raw_message) {
   DCHECK_EQ(DBUS_MESSAGE_TYPE_METHOD_RETURN,
             dbus_message_get_type(raw_message));
 
-  Response* response = new Response;
+  scoped_ptr<Response> response(new Response);
   response->Init(raw_message);
-  return response;
+  return response.Pass();
 }
 
-Response* Response::FromMethodCall(MethodCall* method_call) {
-  Response* response = new Response;
+scoped_ptr<Response> Response::FromMethodCall(MethodCall* method_call) {
+  scoped_ptr<Response> response(new Response);
   response->Init(dbus_message_new_method_return(method_call->raw_message()));
-  return response;
+  return response.Pass();
 }
 
-Response* Response::CreateEmpty() {
-  Response* response = new Response;
+scoped_ptr<Response> Response::CreateEmpty() {
+  scoped_ptr<Response> response(new Response);
   response->Init(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN));
-  return response;
+  return response.Pass();
 }
+
 //
 // ErrorResponse implementation.
 //
 
 ErrorResponse::ErrorResponse() : Response() {
 }
 
-ErrorResponse* ErrorResponse::FromRawMessage(DBusMessage* raw_message) {
+scoped_ptr<ErrorResponse> ErrorResponse::FromRawMessage(
+    DBusMessage* raw_message) {
   DCHECK_EQ(DBUS_MESSAGE_TYPE_ERROR, dbus_message_get_type(raw_message));
 
-  ErrorResponse* response = new ErrorResponse;
+  scoped_ptr<ErrorResponse> response(new ErrorResponse);
   response->Init(raw_message);
-  return response;
+  return response.Pass();
 }
 
-ErrorResponse* ErrorResponse::FromMethodCall(
+scoped_ptr<ErrorResponse> ErrorResponse::FromMethodCall(
     MethodCall* method_call,
     const std::string& error_name,
     const std::string& error_message) {
-  ErrorResponse* response = new ErrorResponse;
+  scoped_ptr<ErrorResponse> response(new ErrorResponse);
   response->Init(dbus_message_new_error(method_call->raw_message(),
                                         error_name.c_str(),
                                         error_message.c_str()));
-  return response;
+  return response.Pass();
 }
 
 //
 // MessageWriter implementation.
 //
 
 MessageWriter::MessageWriter(Message* message) :
     message_(message),
     container_is_open_(false) {
   memset(&raw_message_iter_, 0, sizeof(raw_message_iter_));
@@ skipping 520 matching lines @@
   const bool success = PopBasic(DBUS_TYPE_UNIX_FD, &fd);
   if (!success)
     return false;
 
   value->PutValue(fd);
   // NB: the caller must check validity before using the value
   return true;
 }
 
 }  // namespace dbus