Fix NetworkSmsHandler to observe Manager and improve API

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>
 
 #include "base/bind.h"
+#include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/gsm_sms_client.h"
 #include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/sms_client.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-// Not exposed/exported.
 namespace {
+
+// Not exposed/exported:
 const char kSmscKey[] = "smsc";
 const char kValidityKey[] = "validity";
 const char kClassKey[] = "class";
 const char kIndexKey[] = "index";
 
 // Keys from ModemManager1
 const char kModemManager1NumberKey[] = "Number";
 const char kModemManager1TextKey[] = "Text";
 const char kModemManager1TimestampKey[] = "Timestamp";
+
+// Maximum number of messages stored for RequestUpdate(true).
+const size_t kMaxReceivedMessages = 100;
+
 }  // namespace
 
 namespace chromeos {
 
 // static
 const char NetworkSmsHandler::kNumberKey[] = "number";
 const char NetworkSmsHandler::kTextKey[] = "text";
 const char NetworkSmsHandler::kTimestampKey[] = "timestamp";
 
 class NetworkSmsHandler::NetworkSmsDeviceHandler {
@@ skipping 11 matching lines @@
                                       std::string dbus_connection,
                                       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 NotifyMessageReceived(const base::DictionaryValue& dictionary);
+  void MessageReceived(const base::DictionaryValue& dictionary);
 
   NetworkSmsHandler* host_;
   std::string dbus_connection_;
   dbus::ObjectPath object_path_;
   bool deleting_messages_;
   base::WeakPtrFactory<ModemManagerNetworkSmsDeviceHandler> weak_ptr_factory_;
   std::vector<uint32> delete_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(ModemManagerNetworkSmsDeviceHandler);
 };
@@ skipping 29 matching lines @@
 
 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))
       continue;
-    NotifyMessageReceived(*message);
+    MessageReceived(*message);
     double index = 0;
     if (message->GetDoubleWithoutPathExpansion(kIndexKey, &index))
       delete_queue_.push_back(static_cast<uint32>(index));
   }
   DeleteMessages();
 }
 
 // Messages must be deleted one at a time, since we can not guarantee
 // the order the deletion will be executed in. Delete messages from
 // the back of the list so that the indices are valid.
@@ skipping 22 matching lines @@
   DBusThreadManager::Get()->GetGsmSMSClient()->Get(
       dbus_connection_, object_path_, index,
       base::Bind(&NetworkSmsHandler::
                  ModemManagerNetworkSmsDeviceHandler::GetCallback,
                  weak_ptr_factory_.GetWeakPtr(), index));
 }
 
 void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::GetCallback(
     uint32 index,
     const base::DictionaryValue& dictionary) {
-  NotifyMessageReceived(dictionary);
+  MessageReceived(dictionary);
   delete_queue_.push_back(index);
   if (!deleting_messages_)
     DeleteMessages();
 }
 
 void NetworkSmsHandler::
-ModemManagerNetworkSmsDeviceHandler::NotifyMessageReceived(
+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_->NotifyMessageReceived(dictionary);
+  host_->MessageReceived(dictionary);
 }
 
 class NetworkSmsHandler::ModemManager1NetworkSmsDeviceHandler
     : public NetworkSmsHandler::NetworkSmsDeviceHandler {
  public:
   ModemManager1NetworkSmsDeviceHandler(NetworkSmsHandler* host,
                                        std::string dbus_connection,
                                        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 NotifyMessageReceived(const base::DictionaryValue& dictionary);
+  void MessageReceived(const base::DictionaryValue& dictionary);
 
   NetworkSmsHandler* host_;
   std::string dbus_connection_;
   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_;
 
@@ skipping 94 matching lines @@
   // Only handle complete messages.
   if (!complete)
     return;
   retrieval_queue_.push_back(sms_path);
   if (!retrieving_messages_)
     GetMessages();
 }
 
 void NetworkSmsHandler::ModemManager1NetworkSmsDeviceHandler::GetCallback(
     const base::DictionaryValue& dictionary) {
-  NotifyMessageReceived(dictionary);
+  MessageReceived(dictionary);
   GetMessages();
 }
 
 void NetworkSmsHandler::
-ModemManager1NetworkSmsDeviceHandler::NotifyMessageReceived(
+ModemManager1NetworkSmsDeviceHandler::MessageReceived(
     const base::DictionaryValue& dictionary) {
   // The keys of the ModemManager1.SMS interface do not match the
   // exported keys, so a new dictionary is created with the expected
   // key namaes.
   base::DictionaryValue new_dictionary;
   std::string text, number, timestamp;
   if (dictionary.GetStringWithoutPathExpansion(kModemManager1NumberKey,
                                                &number))
     new_dictionary.SetString(kNumberKey, number);
   if (dictionary.GetStringWithoutPathExpansion(kModemManager1TextKey, &text))
     new_dictionary.SetString(kTextKey, text);
   // TODO(jglasgow): consider normalizing timestamp.
   if (dictionary.GetStringWithoutPathExpansion(kModemManager1TimestampKey,
                                                &timestamp))
     new_dictionary.SetString(kTimestampKey, timestamp);
-  host_->NotifyMessageReceived(new_dictionary);
+  host_->MessageReceived(new_dictionary);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // NetworkSmsHandler
 
 NetworkSmsHandler::NetworkSmsHandler()
     : weak_ptr_factory_(this) {
 }
 
 NetworkSmsHandler::~NetworkSmsHandler() {
+  DBusThreadManager::Get()->GetShillManagerClient()->
+      RemovePropertyChangedObserver(this);
 }
 
 void NetworkSmsHandler::Init() {
-  // TODO(stevenjb): This code needs to monitor changes to Manager.Network
-  // so that devices added after Init() is called get added to device_handlers_.
-  // See: crbug.com/133416.
-
+  // Add as an observer here so that new devices added after this call are
+  // recognized.
+  DBusThreadManager::Get()->GetShillManagerClient()->AddPropertyChangedObserver(
+      this);
   // Request network manager properties so that we can get the list of devices.
   DBusThreadManager::Get()->GetShillManagerClient()->GetProperties(
       base::Bind(&NetworkSmsHandler::ManagerPropertiesCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void NetworkSmsHandler::RequestUpdate() {
+void NetworkSmsHandler::RequestUpdate(bool request_existing) {
+  // If we already received messages and |request_existing| is true, send
+  // updates for existing messages.
+  for (ScopedVector<base::DictionaryValue>::iterator iter =
+           received_messages_.begin();
+       iter != received_messages_.end(); ++iter) {
+    base::DictionaryValue* message = *iter;
+    NotifyMessageReceived(*message);
+  }
+  // Request updates from each device.
   for (ScopedVector<NetworkSmsDeviceHandler>::iterator iter =
            device_handlers_.begin(); iter != device_handlers_.end(); ++iter) {
     (*iter)->RequestUpdate();
   }
 }
 
 void NetworkSmsHandler::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void NetworkSmsHandler::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void NetworkSmsHandler::OnPropertyChanged(const std::string& name,
+                                          const base::Value& value) {
+  if (name != flimflam::kDevicesProperty)
+    return;
+  const base::ListValue* devices = NULL;
+  if (!value.GetAsList(&devices) || !devices)
+    return;
+  UpdateDevices(devices);
+}
+
+// Private methods
+
+void NetworkSmsHandler::AddReceivedMessage(
+    const base::DictionaryValue& message) {
+  base::DictionaryValue* new_message = message.DeepCopy();
+  if (received_messages_.size() >= kMaxReceivedMessages)
+    received_messages_.erase(received_messages_.begin());
+  received_messages_.push_back(new_message);
+}
+
 void NetworkSmsHandler::NotifyMessageReceived(
     const base::DictionaryValue& message) {
   FOR_EACH_OBSERVER(Observer, observers_, MessageReceived(message));
 }
 
+void NetworkSmsHandler::MessageReceived(const base::DictionaryValue& message) {
+  AddReceivedMessage(message);
+  NotifyMessageReceived(message);
+}
+
 void NetworkSmsHandler::ManagerPropertiesCallback(
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties) {
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
     LOG(ERROR) << "NetworkSmsHandler: Failed to get manager properties.";
     return;
   }
   const base::Value* value;
   if (!properties.GetWithoutPathExpansion(flimflam::kDevicesProperty, &value) ||
       value->GetType() != base::Value::TYPE_LIST) {
     LOG(ERROR) << "NetworkSmsHandler: No list value for: "
                << flimflam::kDevicesProperty;
     return;
   }
   const base::ListValue* devices = static_cast<const base::ListValue*>(value);
+  UpdateDevices(devices);
+}
+
+void NetworkSmsHandler::UpdateDevices(const base::ListValue* devices) {
   for (base::ListValue::const_iterator iter = devices->begin();
        iter != devices->end(); ++iter) {
     std::string device_path;
     (*iter)->GetAsString(&device_path);
     if (!device_path.empty()) {
       // Request device properties.
       VLOG(1) << "GetDeviceProperties: " << device_path;
       DBusThreadManager::Get()->GetShillDeviceClient()->GetProperties(
           dbus::ObjectPath(device_path),
           base::Bind(&NetworkSmsHandler::DevicePropertiesCallback,
@@ skipping 44 matching lines @@
             this, dbus_connection, object_path));
   } else {
     device_handlers_.push_back(
         new ModemManagerNetworkSmsDeviceHandler(
             this, dbus_connection, object_path));
   }
 }
 
 
 }  // namespace chromeos