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

chrome/browser/password_manager/native_backend_kwallet_x_unittest.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 <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 233 matching lines @@
 
   dbus::Bus::Options options;
   options.bus_type = dbus::Bus::SESSION;
   mock_session_bus_ = new dbus::MockBus(options);
 
   mock_klauncher_proxy_ =
       new dbus::MockObjectProxy(mock_session_bus_.get(),
                                 "org.kde.klauncher",
                                 dbus::ObjectPath("/KLauncher"));
   EXPECT_CALL(*mock_klauncher_proxy_,
-              CallMethodAndBlock(_, _))
+              MockCallMethodAndBlock(_, _))
       .WillRepeatedly(Invoke(this,
           &NativeBackendKWalletTest::KLauncherMethodCall));
 
   mock_kwallet_proxy_ =
       new dbus::MockObjectProxy(mock_session_bus_.get(),
                                 "org.kde.kwalletd",
                                 dbus::ObjectPath("/modules/kwalletd"));
   EXPECT_CALL(*mock_kwallet_proxy_,
-              CallMethodAndBlock(_, _))
+              MockCallMethodAndBlock(_, _))
       .WillRepeatedly(Invoke(this,
           &NativeBackendKWalletTest::KWalletMethodCall));
 
   EXPECT_CALL(*mock_session_bus_, GetObjectProxy(
       "org.kde.klauncher",
       dbus::ObjectPath("/KLauncher")))
       .WillRepeatedly(Return(mock_klauncher_proxy_.get()));
   EXPECT_CALL(*mock_session_bus_, GetObjectProxy(
       "org.kde.kwalletd",
       dbus::ObjectPath("/modules/kwalletd")))
@@ skipping 31 matching lines @@
 
   EXPECT_EQ("kwalletd", service_name);
   EXPECT_TRUE(urls.empty());
   EXPECT_TRUE(envs.empty());
   EXPECT_TRUE(startup_id.empty());
   EXPECT_FALSE(blind);
 
   if (kwallet_runnable_)
     kwallet_running_ = true;
 
-  dbus::Response* response = dbus::Response::CreateEmpty();
-  dbus::MessageWriter writer(response);
+  scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
   writer.AppendInt32(klauncher_ret_);
   writer.AppendString("");   // dbus_name
   writer.AppendString(klauncher_error_);
   writer.AppendInt32(1234);  // pid
-  return response;
+  return response.release();
 }
 
 dbus::Response* NativeBackendKWalletTest::KWalletMethodCall(
     dbus::MethodCall* method_call, testing::Unused) {
   if (!kwallet_running_)
     return NULL;
   EXPECT_EQ("org.kde.KWallet", method_call->GetInterface());
 
-  dbus::Response* response = NULL;
+  scoped_ptr<dbus::Response> response;
   if (method_call->GetMember() == "isEnabled") {
     response = dbus::Response::CreateEmpty();
-    dbus::MessageWriter writer(response);
+    dbus::MessageWriter writer(response.get());
     writer.AppendBool(kwallet_enabled_);
   } else if (method_call->GetMember() == "networkWallet") {
     response = dbus::Response::CreateEmpty();
-    dbus::MessageWriter writer(response);
+    dbus::MessageWriter writer(response.get());
     writer.AppendString("test_wallet");  // Should match |open| below.
   } else if (method_call->GetMember() == "open") {
     dbus::MessageReader reader(method_call);
     std::string wallet_name;
     int64_t wallet_id;
     std::string app_name;
     EXPECT_TRUE(reader.PopString(&wallet_name));
     EXPECT_TRUE(reader.PopInt64(&wallet_id));
     EXPECT_TRUE(reader.PopString(&app_name));
     EXPECT_EQ("test_wallet", wallet_name);  // Should match |networkWallet|.
     response = dbus::Response::CreateEmpty();
-    dbus::MessageWriter writer(response);
+    dbus::MessageWriter writer(response.get());
     writer.AppendInt32(1);  // Can be anything but kInvalidKWalletHandle.
   } else if (method_call->GetMember() == "hasFolder" ||
              method_call->GetMember() == "createFolder") {
     dbus::MessageReader reader(method_call);
     int handle = NativeBackendKWalletStub::kInvalidKWalletHandle;
     std::string folder_name;
     std::string app_name;
     EXPECT_TRUE(reader.PopInt32(&handle));
     EXPECT_TRUE(reader.PopString(&folder_name));
     EXPECT_TRUE(reader.PopString(&app_name));
     EXPECT_NE(NativeBackendKWalletStub::kInvalidKWalletHandle, handle);
     response = dbus::Response::CreateEmpty();
-    dbus::MessageWriter writer(response);
+    dbus::MessageWriter writer(response.get());
     if (method_call->GetMember() == "hasFolder")
       writer.AppendBool(wallet_.hasFolder(folder_name));
     else
       writer.AppendBool(wallet_.createFolder(folder_name));
   } else if (method_call->GetMember() == "hasEntry" ||
              method_call->GetMember() == "removeEntry") {
     dbus::MessageReader reader(method_call);
     int handle = NativeBackendKWalletStub::kInvalidKWalletHandle;
     std::string folder_name;
     std::string key;
     std::string app_name;
     EXPECT_TRUE(reader.PopInt32(&handle));
     EXPECT_TRUE(reader.PopString(&folder_name));
     EXPECT_TRUE(reader.PopString(&key));
     EXPECT_TRUE(reader.PopString(&app_name));
     EXPECT_NE(NativeBackendKWalletStub::kInvalidKWalletHandle, handle);
     response = dbus::Response::CreateEmpty();
-    dbus::MessageWriter writer(response);
+    dbus::MessageWriter writer(response.get());
     if (method_call->GetMember() == "hasEntry")
       writer.AppendBool(wallet_.hasEntry(folder_name, key));
     else
       writer.AppendInt32(wallet_.removeEntry(folder_name, key) ? 0 : 1);
   } else if (method_call->GetMember() == "entryList") {
     dbus::MessageReader reader(method_call);
     int handle = NativeBackendKWalletStub::kInvalidKWalletHandle;
     std::string folder_name;
     std::string app_name;
     EXPECT_TRUE(reader.PopInt32(&handle));
     EXPECT_TRUE(reader.PopString(&folder_name));
     EXPECT_TRUE(reader.PopString(&app_name));
     EXPECT_NE(NativeBackendKWalletStub::kInvalidKWalletHandle, handle);
     std::vector<std::string> entries;
     if (wallet_.entryList(folder_name, &entries)) {
       response = dbus::Response::CreateEmpty();
-      dbus::MessageWriter writer(response);
+      dbus::MessageWriter writer(response.get());
       writer.AppendArrayOfStrings(entries);
     }
   } else if (method_call->GetMember() == "readEntry") {
     dbus::MessageReader reader(method_call);
     int handle = NativeBackendKWalletStub::kInvalidKWalletHandle;
     std::string folder_name;
     std::string key;
     std::string app_name;
     EXPECT_TRUE(reader.PopInt32(&handle));
     EXPECT_TRUE(reader.PopString(&folder_name));
     EXPECT_TRUE(reader.PopString(&key));
     EXPECT_TRUE(reader.PopString(&app_name));
     EXPECT_NE(NativeBackendKWalletStub::kInvalidKWalletHandle, handle);
     TestKWallet::Blob value;
     if (wallet_.readEntry(folder_name, key, &value)) {
       response = dbus::Response::CreateEmpty();
-      dbus::MessageWriter writer(response);
+      dbus::MessageWriter writer(response.get());
       writer.AppendArrayOfBytes(value.data(), value.size());
     }
   } else if (method_call->GetMember() == "writeEntry") {
     dbus::MessageReader reader(method_call);
     int handle = NativeBackendKWalletStub::kInvalidKWalletHandle;
     std::string folder_name;
     std::string key;
     uint8_t* bytes = NULL;
     size_t length = 0;
     std::string app_name;
     EXPECT_TRUE(reader.PopInt32(&handle));
     EXPECT_TRUE(reader.PopString(&folder_name));
     EXPECT_TRUE(reader.PopString(&key));
     EXPECT_TRUE(reader.PopArrayOfBytes(&bytes, &length));
     EXPECT_TRUE(reader.PopString(&app_name));
     EXPECT_NE(NativeBackendKWalletStub::kInvalidKWalletHandle, handle);
     response = dbus::Response::CreateEmpty();
-    dbus::MessageWriter writer(response);
+    dbus::MessageWriter writer(response.get());
     writer.AppendInt32(
         wallet_.writeEntry(folder_name, key,
                            TestKWallet::Blob(bytes, length)) ? 0 : 1);
   }
 
-  EXPECT_FALSE(response == NULL);
-  return response;
+  EXPECT_FALSE(response.get() == NULL);
+  return response.release();
 }
 
 void NativeBackendKWalletTest::CheckPasswordForms(
     const std::string& folder, const ExpectationArray& sorted_expected) {
   EXPECT_TRUE(wallet_.hasFolder(folder));
   std::vector<std::string> entries;
   EXPECT_TRUE(wallet_.entryList(folder, &entries));
   EXPECT_EQ(sorted_expected.size(), entries.size());
   std::sort(entries.begin(), entries.end());
   for (size_t i = 0; i < entries.size() && i < sorted_expected.size(); ++i) {
@@ skipping 629 matching lines @@
   CheckVersion0Pickle(true, PasswordForm::SCHEME_BASIC);
 }
 
 TEST_F(NativeBackendKWalletPickleTest, ReadsOld64BitHTMLPickles) {
   CheckVersion0Pickle(false, PasswordForm::SCHEME_HTML);
 }
 
 TEST_F(NativeBackendKWalletPickleTest, ReadsOld64BitHTTPPickles) {
   CheckVersion0Pickle(false, PasswordForm::SCHEME_BASIC);
 }