Fix NetworkSMSHandler to use DBus service name instead of connection.

chromeos/network/network_sms_handler.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/network/network_sms_handler.h"
 
 #include <algorithm>
 #include <deque>
 #include <string>
 #include <vector>
@@ skipping 36 matching lines @@
   NetworkSmsDeviceHandler() {}
   virtual ~NetworkSmsDeviceHandler() {}
 
   virtual void RequestUpdate() = 0;
 };
 
 class NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler
     : public NetworkSmsHandler::NetworkSmsDeviceHandler {
  public:
   ModemManagerNetworkSmsDeviceHandler(NetworkSmsHandler* host,
-                                      std::string dbus_connection,
-                                      dbus::ObjectPath object_path);
+                                      const std::string& service_name,
+                                      const dbus::ObjectPath& object_path);
 
   virtual void RequestUpdate() OVERRIDE;
 
  private:
   void ListCallback(const base::ListValue& message_list);
   void SmsReceivedCallback(uint32 index, bool complete);
   void GetCallback(uint32 index, const base::DictionaryValue& dictionary);
   void DeleteMessages();
   void MessageReceived(const base::DictionaryValue& dictionary);
 
   NetworkSmsHandler* host_;
-  std::string dbus_connection_;
+  std::string service_name_;
   dbus::ObjectPath object_path_;
   bool deleting_messages_;
   base::WeakPtrFactory<ModemManagerNetworkSmsDeviceHandler> weak_ptr_factory_;
   std::vector<uint32> delete_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(ModemManagerNetworkSmsDeviceHandler);
 };
 
 NetworkSmsHandler::
 ModemManagerNetworkSmsDeviceHandler::ModemManagerNetworkSmsDeviceHandler(
     NetworkSmsHandler* host,
-    std::string dbus_connection,
-    dbus::ObjectPath object_path)
+    const std::string& service_name,
+    const dbus::ObjectPath& object_path)
     : host_(host),
-      dbus_connection_(dbus_connection),
+      service_name_(service_name),
       object_path_(object_path),
       deleting_messages_(false),
       weak_ptr_factory_(this) {
   // Set the handler for received Sms messaages.
   DBusThreadManager::Get()->GetGsmSMSClient()->SetSmsReceivedHandler(
-      dbus_connection_, object_path_,
+      service_name_, object_path_,
       base::Bind(&ModemManagerNetworkSmsDeviceHandler::SmsReceivedCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 
   // List the existing messages.
   DBusThreadManager::Get()->GetGsmSMSClient()->List(
-      dbus_connection_, object_path_,
+      service_name_, object_path_,
       base::Bind(&NetworkSmsHandler::
                  ModemManagerNetworkSmsDeviceHandler::ListCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::RequestUpdate() {
   DBusThreadManager::Get()->GetGsmSMSClient()->RequestUpdate(
-      dbus_connection_, object_path_);
+      service_name_, object_path_);
 }
 
 void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::ListCallback(
     const base::ListValue& message_list) {
   // This receives all messages, so clear any pending deletes.
   delete_queue_.clear();
   for (base::ListValue::const_iterator iter = message_list.begin();
        iter != message_list.end(); ++iter) {
     base::DictionaryValue* message = NULL;
     if (!(*iter)->GetAsDictionary(&message))
@@ skipping 11 matching lines @@
 // the back of the list so that the indices are valid.
 void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::DeleteMessages() {
   if (delete_queue_.empty()) {
     deleting_messages_ = false;
     return;
   }
   deleting_messages_ = true;
   uint32 index = delete_queue_.back();
   delete_queue_.pop_back();
   DBusThreadManager::Get()->GetGsmSMSClient()->Delete(
-      dbus_connection_, object_path_, index,
+      service_name_, object_path_, index,
       base::Bind(&NetworkSmsHandler::
                  ModemManagerNetworkSmsDeviceHandler::DeleteMessages,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkSmsHandler::
 ModemManagerNetworkSmsDeviceHandler::SmsReceivedCallback(
     uint32 index,
     bool complete) {
   // Only handle complete messages.
   if (!complete)
     return;
   DBusThreadManager::Get()->GetGsmSMSClient()->Get(
-      dbus_connection_, object_path_, index,
+      service_name_, object_path_, index,
       base::Bind(&NetworkSmsHandler::
                  ModemManagerNetworkSmsDeviceHandler::GetCallback,
                  weak_ptr_factory_.GetWeakPtr(), index));
 }
 
 void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::GetCallback(
     uint32 index,
     const base::DictionaryValue& dictionary) {
   MessageReceived(dictionary);
   delete_queue_.push_back(index);
   if (!deleting_messages_)
     DeleteMessages();
 }
 
 void NetworkSmsHandler::
 ModemManagerNetworkSmsDeviceHandler::MessageReceived(
     const base::DictionaryValue& dictionary) {
   // The keys of the ModemManager.Modem.Gsm.SMS interface match the
   // exported keys, so the dictionary used as a notification argument
   // unchanged.
   host_->MessageReceived(dictionary);
 }
 
 class NetworkSmsHandler::ModemManager1NetworkSmsDeviceHandler
     : public NetworkSmsHandler::NetworkSmsDeviceHandler {
  public:
   ModemManager1NetworkSmsDeviceHandler(NetworkSmsHandler* host,
-                                       std::string dbus_connection,
-                                       dbus::ObjectPath object_path);
+                                       const std::string& service_name,
+                                       const dbus::ObjectPath& object_path);
 
   virtual void RequestUpdate() OVERRIDE;
 
  private:
   void ListCallback(const std::vector<dbus::ObjectPath>& paths);
   void SmsReceivedCallback(const dbus::ObjectPath& path, bool complete);
   void GetCallback(const base::DictionaryValue& dictionary);
   void DeleteMessages();
   void GetMessages();
   void MessageReceived(const base::DictionaryValue& dictionary);
 
   NetworkSmsHandler* host_;
-  std::string dbus_connection_;
+  std::string service_name_;
   dbus::ObjectPath object_path_;
   bool deleting_messages_;
   bool retrieving_messages_;
   base::WeakPtrFactory<ModemManager1NetworkSmsDeviceHandler> weak_ptr_factory_;
   std::vector<dbus::ObjectPath> delete_queue_;
   std::deque<dbus::ObjectPath> retrieval_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(ModemManager1NetworkSmsDeviceHandler);
 };
 
 NetworkSmsHandler::
 ModemManager1NetworkSmsDeviceHandler::ModemManager1NetworkSmsDeviceHandler(
     NetworkSmsHandler* host,
-    std::string dbus_connection,
-    dbus::ObjectPath object_path)
+    const std::string& service_name,
+    const dbus::ObjectPath& object_path)
     : host_(host),
-      dbus_connection_(dbus_connection),
+      service_name_(service_name),
       object_path_(object_path),
       deleting_messages_(false),
       retrieving_messages_(false),
       weak_ptr_factory_(this) {
   // Set the handler for received Sms messaages.
   DBusThreadManager::Get()->GetModemMessagingClient()->SetSmsReceivedHandler(
-      dbus_connection_, object_path_,
+      service_name_, object_path_,
       base::Bind(
           &NetworkSmsHandler::
           ModemManager1NetworkSmsDeviceHandler::SmsReceivedCallback,
           weak_ptr_factory_.GetWeakPtr()));
 
   // List the existing messages.
   DBusThreadManager::Get()->GetModemMessagingClient()->List(
-      dbus_connection_, object_path_,
+      service_name_, object_path_,
       base::Bind(&NetworkSmsHandler::
                  ModemManager1NetworkSmsDeviceHandler::ListCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkSmsHandler::ModemManager1NetworkSmsDeviceHandler::RequestUpdate() {
   // Calling List using the service "AddSMS" causes the stub
   // implementation to deliver new sms messages.
   DBusThreadManager::Get()->GetModemMessagingClient()->List(
       std::string("AddSMS"), dbus::ObjectPath("/"),
@@ skipping 19 matching lines @@
 // the back of the list so that the indices are valid.
 void NetworkSmsHandler::ModemManager1NetworkSmsDeviceHandler::DeleteMessages() {
   if (delete_queue_.empty()) {
     deleting_messages_ = false;
     return;
   }
   deleting_messages_ = true;
   dbus::ObjectPath sms_path = delete_queue_.back();
   delete_queue_.pop_back();
   DBusThreadManager::Get()->GetModemMessagingClient()->Delete(
-      dbus_connection_, object_path_, sms_path,
+      service_name_, object_path_, sms_path,
       base::Bind(&NetworkSmsHandler::
                  ModemManager1NetworkSmsDeviceHandler::DeleteMessages,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 // Messages must be fetched one at a time, so that we do not queue too
 // many requests to a single threaded server.
 void NetworkSmsHandler::ModemManager1NetworkSmsDeviceHandler::GetMessages() {
   if (retrieval_queue_.empty()) {
     retrieving_messages_ = false;
     if (!deleting_messages_)
       DeleteMessages();
     return;
   }
   retrieving_messages_ = true;
   dbus::ObjectPath sms_path = retrieval_queue_.front();
   retrieval_queue_.pop_front();
   DBusThreadManager::Get()->GetSMSClient()->GetAll(
-      dbus_connection_, sms_path,
+      service_name_, sms_path,
       base::Bind(&NetworkSmsHandler::
                  ModemManager1NetworkSmsDeviceHandler::GetCallback,
                  weak_ptr_factory_.GetWeakPtr()));
   delete_queue_.push_back(sms_path);
 }
 
 void NetworkSmsHandler::
 ModemManager1NetworkSmsDeviceHandler::SmsReceivedCallback(
     const dbus::ObjectPath& sms_path,
     bool complete) {
@@ skipping 155 matching lines @@
 
   std::string device_type;
   if (!properties.GetStringWithoutPathExpansion(
           shill::kTypeProperty, &device_type)) {
     LOG(ERROR) << "NetworkSmsHandler: No type for: " << device_path;
     return;
   }
   if (device_type != shill::kTypeCellular)
     return;
 
-  std::string dbus_connection;
+  std::string service_name;
   if (!properties.GetStringWithoutPathExpansion(
-          shill::kDBusConnectionProperty, &dbus_connection)) {
-    LOG(ERROR) << "Device has no DBusConnection Property: " << device_path;
+          shill::kDBusServiceProperty, &service_name)) {
+    LOG(ERROR) << "Device has no DBusService Property: " << device_path;
     return;
   }
 
   std::string object_path_string;
   if (!properties.GetStringWithoutPathExpansion(
           shill::kDBusObjectProperty, &object_path_string)) {
     LOG(ERROR) << "Device has no DBusObject Property: " << device_path;
     return;
   }
   dbus::ObjectPath object_path(object_path_string);
-  if (object_path_string.compare(
-          0, sizeof(modemmanager::kModemManager1ServicePath) - 1,
-          modemmanager::kModemManager1ServicePath) == 0) {
+  if (service_name == modemmanager::kModemManager1) {
     device_handlers_.push_back(
         new ModemManager1NetworkSmsDeviceHandler(
-            this, dbus_connection, object_path));
+            this, service_name, object_path));
   } else {
     device_handlers_.push_back(
         new ModemManagerNetworkSmsDeviceHandler(
-            this, dbus_connection, object_path));
+            this, service_name, object_path));
   }
 }
 
-
 }  // namespace chromeos