Rework chromeos::FlimflamDevice/ServiceClient with CallMethodWithErrorCallback

chromeos/dbus/flimflam_client_unittest_base.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/flimflam_client_unittest_base.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "dbus/message.h"
@@ skipping 12 matching lines @@
 namespace {
 
 // Runs the given task.  This function is used to implement the mock bus.
 void RunTask(const tracked_objects::Location& from_here,
              const base::Closure& task) {
   task.Run();
 }
 
 }  // namespace
 
+FlimflamClientUnittestBase::MockClosure::MockClosure() {}
+
+FlimflamClientUnittestBase::MockClosure::~MockClosure() {}
+
+base::Closure FlimflamClientUnittestBase::MockClosure::GetCallback() {
+  return base::Bind(&MockClosure::Run, base::Unretained(this));
+}
+
+
+FlimflamClientUnittestBase::MockErrorCallback::MockErrorCallback() {}
+
+FlimflamClientUnittestBase::MockErrorCallback::~MockErrorCallback() {}
+
+FlimflamClientHelper::ErrorCallback
+FlimflamClientUnittestBase::MockErrorCallback::GetCallback() {
+  return base::Bind(&MockErrorCallback::Run, base::Unretained(this));
+}
+
+
 FlimflamClientUnittestBase::FlimflamClientUnittestBase(
     const std::string& interface_name,
     const dbus::ObjectPath& object_path)
     : interface_name_(interface_name),
-      object_path_(object_path) {
+      object_path_(object_path),
+      response_(NULL) {
 }
 
 FlimflamClientUnittestBase::~FlimflamClientUnittestBase() {
 }
 
 void FlimflamClientUnittestBase::SetUp() {
   // Create a mock bus.
   dbus::Bus::Options options;
   options.bus_type = dbus::Bus::SYSTEM;
   mock_bus_ = new dbus::MockBus(options);
 
   // Create a mock proxy.
   mock_proxy_ = new dbus::MockObjectProxy(
       mock_bus_.get(),
       flimflam::kFlimflamServiceName,
       object_path_);
 
   // Set an expectation so mock_proxy's CallMethodAndBlock() will use
   // OnCallMethodAndBlock() to return responses.
   EXPECT_CALL(*mock_proxy_, CallMethodAndBlock(_, _))
       .WillRepeatedly(Invoke(
           this, &FlimflamClientUnittestBase::OnCallMethodAndBlock));
 
   // Set an expectation so mock_proxy's CallMethod() will use OnCallMethod()
   // to return responses.
   EXPECT_CALL(*mock_proxy_, CallMethod(_, _, _))
       .WillRepeatedly(Invoke(this, &FlimflamClientUnittestBase::OnCallMethod));
 
+  // Set an expectation so mock_proxy's CallMethodWithErrorCallback() will use
+  // OnCallMethodWithErrorCallback() to return responses.
+  EXPECT_CALL(*mock_proxy_, CallMethodWithErrorCallback(_, _, _, _))
+      .WillRepeatedly(Invoke(
+          this, &FlimflamClientUnittestBase::OnCallMethodWithErrorCallback));
+
   // Set an expectation so mock_proxy's ConnectToSignal() will use
   // OnConnectToSignal() to run the callback.
   EXPECT_CALL(*mock_proxy_, ConnectToSignal(
       interface_name_,
       flimflam::kMonitorPropertyChanged, _, _))
       .WillRepeatedly(Invoke(this,
                              &FlimflamClientUnittestBase::OnConnectToSignal));
 
   // Set an expectation so mock_bus's GetObjectProxy() for the given
   // service name and the object path will return mock_proxy_.
@@ skipping 125 matching lines @@
     int timeout_ms,
     const dbus::ObjectProxy::ResponseCallback& response_callback) {
   EXPECT_EQ(interface_name_, method_call->GetInterface());
   EXPECT_EQ(expected_method_name_, method_call->GetMember());
   dbus::MessageReader reader(method_call);
   argument_checker_.Run(&reader);
   message_loop_.PostTask(FROM_HERE,
                          base::Bind(response_callback, response_));
 }
 
+void FlimflamClientUnittestBase::OnCallMethodWithErrorCallback(
+    dbus::MethodCall* method_call,
+    int timeout_ms,
+    const dbus::ObjectProxy::ResponseCallback& response_callback,
+    const dbus::ObjectProxy::ErrorCallback& error_callback) {
+  OnCallMethod(method_call, timeout_ms, response_callback);
+}
+
 dbus::Response* FlimflamClientUnittestBase::OnCallMethodAndBlock(
     dbus::MethodCall* method_call,
     int timeout_ms) {
   EXPECT_EQ(interface_name_, method_call->GetInterface());
   EXPECT_EQ(expected_method_name_, method_call->GetMember());
   dbus::MessageReader reader(method_call);
   argument_checker_.Run(&reader);
   return dbus::Response::FromRawMessage(
       dbus_message_copy(response_->raw_message()));
 }
 
 }  // namespace chromeos