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

chromeos/dbus/ibus/ibus_panel_service_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 "chromeos/dbus/ibus/ibus_panel_service.h"
 
 #include <map>
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 45 matching lines @@
   MOCK_METHOD1(RegisterProperties,
                void(const IBusPropertyList& properties));
   MOCK_METHOD1(UpdateProperty, void(const IBusProperty& property));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIBusPanelPropertyHandler);
 };
 
 class MockResponseSender {
  public:
-  MOCK_METHOD1(Run, void(dbus::Response* reponse));
+  // GMock doesn't support mocking methods which take scoped_ptr<>.
+  MOCK_METHOD1(MockRun, void(dbus::Response* reponse));
+  void Run(scoped_ptr<dbus::Response> response) {
+    MockRun(response.get());
+  }
 };
 
 // This class is used to verify that a method call response is empty. This class
 // verifies the response has correct message serial number and has no entry in
 // response.
 class EmptyResponseVerifier {
  public:
   explicit EmptyResponseVerifier(uint32 expected_serial_number)
       : expected_serial_number_(expected_serial_number) {}
 
   // Verifies the given |response| has no argument.
   void Verify(dbus::Response* response) {
-    scoped_ptr<dbus::Response> response_deleter(response);
     EXPECT_EQ(expected_serial_number_, response->GetReplySerial());
     dbus::MessageReader reader(response);
     EXPECT_FALSE(reader.HasMoreData());
   }
 
  private:
   const uint32 expected_serial_number_;
 
   DISALLOW_COPY_AND_ASSIGN(EmptyResponseVerifier);
 };
@@ skipping 252 matching lines @@
                                                  success));
   }
 };
 
 TEST_F(IBusPanelServiceTest, HideLookupTableTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*candidate_window_handler_, HideLookupTable());
   MockResponseSender response_sender;
   EmptyResponseVerifier response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kHideLookupTableMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kHideLookupTableMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kHideLookupTableMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusPanelServiceTest, HideAuxiliaryTextTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*candidate_window_handler_, HideAuxiliaryText());
   MockResponseSender response_sender;
   EmptyResponseVerifier response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kHideAuxiliaryTextMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kHideAuxiliaryTextMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kHideAuxiliaryTextMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusPanelServiceTest, HidePreeditTextTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   EXPECT_CALL(*candidate_window_handler_, HidePreeditText());
   MockResponseSender response_sender;
   EmptyResponseVerifier response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kHidePreeditTextMethod);
   method_call.SetSerial(kSerialNo);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kHidePreeditTextMethod),
@@ skipping 12 matching lines @@
   table.set_cursor_position(4);
   const bool kVisible = false;
 
 
   UpdateLookupTableVerifier evaluator(table, kVisible);
   EXPECT_CALL(*candidate_window_handler_, UpdateLookupTable(_, _))
       .WillOnce(Invoke(&evaluator,
                        &UpdateLookupTableVerifier::Verify));
   MockResponseSender response_sender;
   EmptyResponseVerifier response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kUpdateLookupTableMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   AppendIBusLookupTable(table, &writer);
   writer.AppendBool(kVisible);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kUpdateLookupTableMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kUpdateLookupTableMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusPanelServiceTest, UpdateAuxiliaryTextTest) {
   // Set expectations.
   const uint32 kSerialNo = 1;
   const std::string text = "Sample text";
   const bool kVisible = false;
 
   EXPECT_CALL(*candidate_window_handler_, UpdateAuxiliaryText(text, kVisible));
   MockResponseSender response_sender;
   EmptyResponseVerifier response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kUpdateAuxiliaryTextMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   AppendStringAsIBusText(text, &writer);
   writer.AppendBool(kVisible);
@@ skipping 11 matching lines @@
   // Set expectations.
   const uint32 kSerialNo = 1;
   const std::string text = "Sample text";
   const uint32 kCursorPos = 4;
   const bool kVisible = false;
 
   EXPECT_CALL(*candidate_window_handler_,
               UpdatePreeditText(text, kCursorPos, kVisible));
   MockResponseSender response_sender;
   EmptyResponseVerifier response_expectation(kSerialNo);
-  EXPECT_CALL(response_sender, Run(_))
+  EXPECT_CALL(response_sender, MockRun(_))
       .WillOnce(Invoke(&response_expectation,
                        &EmptyResponseVerifier::Verify));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kUpdatePreeditTextMethod);
   method_call.SetSerial(kSerialNo);
   dbus::MessageWriter writer(&method_call);
   AppendStringAsIBusText(text, &writer);
   writer.AppendUint32(kCursorPos);
@@ skipping 60 matching lines @@
     property->set_key(keys[i]);
     properties.push_back(property);
   }
 
   PropertyListVerifier response_expectation(keys);
   EXPECT_CALL(*property_handler_, RegisterProperties(_))
       .WillOnce(Invoke(&response_expectation,
                         &PropertyListVerifier::Verify));
 
   MockResponseSender response_sender;
-  EXPECT_CALL(response_sender, Run(_));
+  EXPECT_CALL(response_sender, MockRun(_));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kRegisterPropertiesMethod);
   method_call.SetSerial(1UL);
   dbus::MessageWriter writer(&method_call);
   AppendIBusPropertyList(properties, &writer);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kRegisterPropertiesMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kRegisterPropertiesMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run, base::Unretained(&response_sender)));
 }
 
 TEST_F(IBusPanelServiceTest, UpdatePropertyTest) {
   // Set expectations.
   const char kKey[] = "key";
   IBusProperty property;
   property.set_key(kKey);
 
   PropertyVerifier response_expectation(kKey);
   EXPECT_CALL(*property_handler_, UpdateProperty(_))
       .WillOnce(Invoke(&response_expectation, &PropertyVerifier::Verify));
 
   MockResponseSender response_sender;
-  EXPECT_CALL(response_sender, Run(_));
+  EXPECT_CALL(response_sender, MockRun(_));
 
   // Create method call;
   dbus::MethodCall method_call(ibus::panel::kServiceInterface,
                                ibus::panel::kUpdatePropertyMethod);
   method_call.SetSerial(1UL);
   dbus::MessageWriter writer(&method_call);
   AppendIBusProperty(property, &writer);
 
   // Call exported function.
   EXPECT_NE(method_callback_map_.find(ibus::panel::kUpdatePropertyMethod),
             method_callback_map_.end());
   method_callback_map_[ibus::panel::kUpdatePropertyMethod].Run(
       &method_call,
       base::Bind(&MockResponseSender::Run,
                  base::Unretained(&response_sender)));
 }
 
 }  // namespace chromeos