This converts the Shill clients to allow propagation of shill errors

chromeos/dbus/shill_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/shill_client_unittest_base.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "dbus/message.h"
@@ skipping 25 matching lines @@
 
 base::Closure ShillClientUnittestBase::MockClosure::GetCallback() {
   return base::Bind(&MockClosure::Run, base::Unretained(this));
 }
 
 
 ShillClientUnittestBase::MockErrorCallback::MockErrorCallback() {}
 
 ShillClientUnittestBase::MockErrorCallback::~MockErrorCallback() {}
 
+ShillClientUnittestBase::MockPropertyChangeObserver::
+  MockPropertyChangeObserver() {}
+
+ShillClientUnittestBase::MockPropertyChangeObserver::
+  ~MockPropertyChangeObserver() {}
+
 ShillClientHelper::ErrorCallback
 ShillClientUnittestBase::MockErrorCallback::GetCallback() {
   return base::Bind(&MockErrorCallback::Run, base::Unretained(this));
 }
 
 
 ShillClientUnittestBase::ShillClientUnittestBase(
     const std::string& interface_name,
     const dbus::ObjectPath& object_path)
     : interface_name_(interface_name),
@@ skipping 69 matching lines @@
   response_ = response;
 }
 
 void ShillClientUnittestBase::SendPropertyChangedSignal(
     dbus::Signal* signal) {
   ASSERT_FALSE(property_changed_handler_.is_null());
   property_changed_handler_.Run(signal);
 }
 
 // static
-void ShillClientUnittestBase::ExpectPropertyChanged(
-    const std::string& expected_name,
-    const base::Value* expected_value,
-    const std::string& name,
-    const base::Value& value) {
-  EXPECT_EQ(expected_name, name);
-  EXPECT_TRUE(expected_value->Equals(&value));
-}
-
-// static
 void ShillClientUnittestBase::ExpectNoArgument(dbus::MessageReader* reader) {
   EXPECT_FALSE(reader->HasMoreData());
 }
 
 // static
 void ShillClientUnittestBase::ExpectStringArgument(
     const std::string& expected_string,
     dbus::MessageReader* reader) {
   std::string str;
   ASSERT_TRUE(reader->PopString(&str));
@@ skipping 34 matching lines @@
 // static
 void ShillClientUnittestBase::ExpectObjectPathResult(
     const dbus::ObjectPath& expected_result,
     DBusMethodCallStatus call_status,
     const dbus::ObjectPath& result) {
   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
   EXPECT_EQ(expected_result, result);
 }
 
 // static
-void ShillClientUnittestBase::ExpectDictionaryValueResult(
+void ShillClientUnittestBase::ExpectDictionaryValueResultWithoutStatus(
     const base::DictionaryValue* expected_result,
-    DBusMethodCallStatus call_status,
     const base::DictionaryValue& result) {
-  EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
   std::string expected_result_string;
   base::JSONWriter::Write(expected_result, &expected_result_string);
   std::string result_string;
   base::JSONWriter::Write(&result, &result_string);
   EXPECT_EQ(expected_result_string, result_string);
 }
 
+// static
+void ShillClientUnittestBase::ExpectDictionaryValueResult(
+    const base::DictionaryValue* expected_result,
+    DBusMethodCallStatus call_status,
+    const base::DictionaryValue& result) {
+  EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
+  ExpectDictionaryValueResultWithoutStatus(expected_result, result);
+}
+
 void ShillClientUnittestBase::OnConnectToSignal(
     const std::string& interface_name,
     const std::string& signal_name,
     const dbus::ObjectProxy::SignalCallback& signal_callback,
     const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
   property_changed_handler_ = signal_callback;
   const bool success = true;
   message_loop_.PostTask(FROM_HERE,
                          base::Bind(on_connected_callback,
                                     interface_name,
@@ skipping 26 matching lines @@
     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