Move cros_network_functions.cc to src/chromeos

chrome/browser/chromeos/cros/sms_watcher.cc

Index: chrome/browser/chromeos/cros/sms_watcher.cc
diff --git a/chrome/browser/chromeos/cros/sms_watcher.cc b/chrome/browser/chromeos/cros/sms_watcher.cc
deleted file mode 100644
index c5a43356820de7070f032ab55de1c5a875f68b1c..0000000000000000000000000000000000000000
--- a/chrome/browser/chromeos/cros/sms_watcher.cc
+++ /dev/null
@@ -1,409 +0,0 @@
-// 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 "chrome/browser/chromeos/cros/sms_watcher.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/gsm_sms_client.h"
-#include "chromeos/dbus/modem_messaging_client.h"
-#include "chromeos/dbus/sms_client.h"
-#include "third_party/cros_system_api/dbus/service_constants.h"
-
-namespace chromeos {
-
-namespace {
-
-int decode_bcd(const char *s) {
-  return (s[0] - '0') * 10 + s[1] - '0';
-}
-
-void decode_timestamp(const std::string& sms_timestamp, SMS *sms) {
-  base::Time::Exploded exp;
-  exp.year = decode_bcd(&sms_timestamp[0]);
-  if (exp.year > 95)
-    exp.year += 1900;
-  else
-    exp.year += 2000;
-  exp.month = decode_bcd(&sms_timestamp[2]);
-  exp.day_of_month = decode_bcd(&sms_timestamp[4]);
-  exp.hour = decode_bcd(&sms_timestamp[6]);
-  exp.minute = decode_bcd(&sms_timestamp[8]);
-  exp.second = decode_bcd(&sms_timestamp[10]);
-  exp.millisecond = 0;
-  sms->timestamp = base::Time::FromUTCExploded(exp);
-  int hours = decode_bcd(&sms_timestamp[13]);
-  if (sms_timestamp[12] == '-')
-    hours = -hours;
-  sms->timestamp -= base::TimeDelta::FromHours(hours);
-}
-
-// Callback for Delete() method.  This method does nothing.
-void DeleteSMSCallback() {}
-
-}  // namespace
-
-const char SMSWatcher::kNumberKey[] = "number";
-const char SMSWatcher::kTextKey[] = "text";
-const char SMSWatcher::kTimestampKey[] = "timestamp";
-const char SMSWatcher::kSmscKey[] = "smsc";
-const char SMSWatcher::kValidityKey[] = "validity";
-const char SMSWatcher::kClassKey[] = "class";
-const char SMSWatcher::kIndexKey[] = "index";
-
-const char SMSWatcher::kModemManager1NumberKey[] = "Number";
-const char SMSWatcher::kModemManager1TextKey[] = "Text";
-const char SMSWatcher::kModemManager1TimestampKey[] = "Timestamp";
-const char SMSWatcher::kModemManager1SmscKey[] = "Smsc";
-const char SMSWatcher::kModemManager1ValidityKey[] = "Validity";
-const char SMSWatcher::kModemManager1ClassKey[] = "Class";
-const char SMSWatcher::kModemManager1IndexKey[] = "Index";
-
-class SMSWatcher::WatcherBase {
- public:
-  WatcherBase(const std::string& device_path,
-              MonitorSMSCallback callback,
-              const std::string& dbus_connection,
-              const dbus::ObjectPath& object_path) :
-      device_path_(device_path),
-      callback_(callback),
-      dbus_connection_(dbus_connection),
-      object_path_(object_path) {}
-
-  virtual ~WatcherBase() {}
-
- protected:
-  const std::string device_path_;
-  MonitorSMSCallback callback_;
-  const std::string dbus_connection_;
-  const dbus::ObjectPath object_path_;
-
-  DISALLOW_COPY_AND_ASSIGN(WatcherBase);
-};
-
-namespace {
-
-class GsmWatcher : public SMSWatcher::WatcherBase {
- public:
-  GsmWatcher(const std::string& device_path,
-             MonitorSMSCallback callback,
-             const std::string& dbus_connection,
-             const dbus::ObjectPath& object_path)
-      : WatcherBase(device_path, callback, dbus_connection, object_path),
-        weak_ptr_factory_(this) {
-    DBusThreadManager::Get()->GetGsmSMSClient()->SetSmsReceivedHandler(
-        dbus_connection_,
-        object_path_,
-        base::Bind(&GsmWatcher::OnSmsReceived, weak_ptr_factory_.GetWeakPtr()));
-
-    DBusThreadManager::Get()->GetGsmSMSClient()->List(
-        dbus_connection_, object_path_,
-        base::Bind(&GsmWatcher::ListSMSCallback,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  virtual ~GsmWatcher() {
-    DBusThreadManager::Get()->GetGsmSMSClient()->ResetSmsReceivedHandler(
-        dbus_connection_, object_path_);
-  }
-
- private:
-  // Callback for SmsReceived signal from ModemManager.Modem.Gsm.SMS
-  void OnSmsReceived(uint32 index, bool complete) {
-    // Only handle complete messages.
-    if (!complete)
-      return;
-    DBusThreadManager::Get()->GetGsmSMSClient()->Get(
-        dbus_connection_, object_path_, index,
-        base::Bind(&GsmWatcher::GetSMSCallback,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   index));
-  }
-
-  // Runs |callback_| with a SMS.
-  void RunCallbackWithSMS(const base::DictionaryValue& sms_dictionary) {
-    SMS sms;
-
-    if (!sms_dictionary.GetStringWithoutPathExpansion(SMSWatcher::kNumberKey,
-                                                      &sms.number))
-      LOG(WARNING) << "SMS did not contain a number";
-
-    if (!sms_dictionary.GetStringWithoutPathExpansion(SMSWatcher::kTextKey,
-                                                      &sms.text))
-      LOG(WARNING) << "SMS did not contain message text";
-
-    std::string sms_timestamp;
-    if (sms_dictionary.GetStringWithoutPathExpansion(SMSWatcher::kTimestampKey,
-                                                     &sms_timestamp)) {
-      decode_timestamp(sms_timestamp, &sms);
-    } else {
-      LOG(WARNING) << "SMS did not contain a timestamp";
-      sms.timestamp = base::Time();
-    }
-
-    sms_dictionary.GetStringWithoutPathExpansion(SMSWatcher::kSmscKey,
-                                                 &sms.smsc);
-
-    double validity = 0;
-    if (!sms_dictionary.GetDoubleWithoutPathExpansion(SMSWatcher::kValidityKey,
-                                                      &validity)) {
-      validity = -1;
-    }
-    sms.validity = validity;
-
-    double msgclass = 0;
-    if (!sms_dictionary.GetDoubleWithoutPathExpansion(SMSWatcher::kClassKey,
-                                                      &msgclass)) {
-      msgclass = -1;
-    }
-    sms.msgclass = msgclass;
-
-    callback_.Run(device_path_, sms);
-  }
-
-  // Callback for Get() method from ModemManager.Modem.Gsm.SMS
-  void GetSMSCallback(uint32 index,
-                      const base::DictionaryValue& sms_dictionary) {
-    RunCallbackWithSMS(sms_dictionary);
-
-    DBusThreadManager::Get()->GetGsmSMSClient()->Delete(
-        dbus_connection_, object_path_, index, base::Bind(&DeleteSMSCallback));
-  }
-
-  // Callback for List() method.
-  void ListSMSCallback(const base::ListValue& result) {
-    // List() is called only once; no one touches delete_queue_ before List().
-    CHECK(delete_queue_.empty());
-    for (size_t i = 0; i != result.GetSize(); ++i) {
-      const base::DictionaryValue* sms_dictionary = NULL;
-      if (!result.GetDictionary(i, &sms_dictionary)) {
-        LOG(ERROR) << "result[" << i << "] is not a dictionary.";
-        continue;
-      }
-      RunCallbackWithSMS(*sms_dictionary);
-      double index = 0;
-      if (sms_dictionary->GetDoubleWithoutPathExpansion(SMSWatcher::kIndexKey,
-                                                        &index)) {
-        delete_queue_.push_back(index);
-      }
-    }
-    DeleteSMSInChain();
-  }
-
-  // Deletes SMSs in the queue.
-  void DeleteSMSInChain() {
-    if (!delete_queue_.empty()) {
-      DBusThreadManager::Get()->GetGsmSMSClient()->Delete(
-          dbus_connection_, object_path_, delete_queue_.back(),
-          base::Bind(&GsmWatcher::DeleteSMSInChain,
-                     weak_ptr_factory_.GetWeakPtr()));
-      delete_queue_.pop_back();
-    }
-  }
-
-  base::WeakPtrFactory<GsmWatcher> weak_ptr_factory_;
-  std::vector<uint32> delete_queue_;
-
-  DISALLOW_COPY_AND_ASSIGN(GsmWatcher);
-};
-
-class ModemManager1Watcher : public SMSWatcher::WatcherBase {
- public:
-  ModemManager1Watcher(const std::string& device_path,
-                       MonitorSMSCallback callback,
-                       const std::string& dbus_connection,
-                       const dbus::ObjectPath& object_path)
-      : WatcherBase(device_path, callback, dbus_connection, object_path),
-        weak_ptr_factory_(this),
-        deleting_messages_(false),
-        retrieving_messages_(false) {
-    DBusThreadManager::Get()->GetModemMessagingClient()->SetSmsReceivedHandler(
-        dbus_connection_,
-        object_path_,
-        base::Bind(&ModemManager1Watcher::OnSmsReceived,
-                   weak_ptr_factory_.GetWeakPtr()));
-
-    DBusThreadManager::Get()->GetModemMessagingClient()->List(
-        dbus_connection_, object_path_,
-        base::Bind(&ModemManager1Watcher::ListSMSCallback,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  virtual ~ModemManager1Watcher() {
-    DBusThreadManager::Get()->GetModemMessagingClient()
-        ->ResetSmsReceivedHandler(dbus_connection_, object_path_);
-  }
-
- private:
-  void ListSMSCallback(
-      const std::vector<dbus::ObjectPath>& paths) {
-    // This receives all messages, so clear any pending gets and deletes.
-    retrieval_queue_.clear();
-    delete_queue_.clear();
-
-    retrieval_queue_.resize(paths.size());
-    std::copy(paths.begin(), paths.end(), retrieval_queue_.begin());
-    if (!retrieving_messages_)
-      GetMessages();
-  }
-
-  // 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.
-  void 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,
-        base::Bind(&ModemManager1Watcher::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 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,
-        base::Bind(&ModemManager1Watcher::GetCallback,
-                   weak_ptr_factory_.GetWeakPtr()));
-    delete_queue_.push_back(sms_path);
-  }
-
-  // Handles arrival of a new SMS message.
-  void OnSmsReceived(const dbus::ObjectPath& sms_path, bool complete) {
-    // Only handle complete messages.
-    if (!complete)
-      return;
-    retrieval_queue_.push_back(sms_path);
-    if (!retrieving_messages_)
-      GetMessages();
-  }
-
-  // Runs |callback_| with a SMS.
-  void RunCallbackWithSMS(const base::DictionaryValue& sms_dictionary) {
-    SMS sms;
-
-    if (!sms_dictionary.GetStringWithoutPathExpansion(
-            SMSWatcher::kModemManager1NumberKey, &sms.number))
-      LOG(WARNING) << "SMS did not contain a number";
-
-    if (!sms_dictionary.GetStringWithoutPathExpansion(
-            SMSWatcher::kModemManager1TextKey, &sms.text))
-      LOG(WARNING) << "SMS did not contain message text";
-
-    std::string sms_timestamp;
-    if (sms_dictionary.GetStringWithoutPathExpansion(
-            SMSWatcher::kModemManager1TimestampKey, &sms_timestamp)) {
-      decode_timestamp(sms_timestamp, &sms);
-    } else {
-      LOG(WARNING) << "SMS did not contain a timestamp";
-      sms.timestamp = base::Time();
-    }
-
-    sms_dictionary.GetStringWithoutPathExpansion(
-        SMSWatcher::kModemManager1SmscKey, &sms.smsc);
-
-    double validity = 0;
-    if (!sms_dictionary.GetDoubleWithoutPathExpansion(
-            SMSWatcher::kModemManager1ValidityKey, &validity)) {
-      validity = -1;
-    }
-    sms.validity = validity;
-
-    double msgclass = 0;
-    if (!sms_dictionary.GetDoubleWithoutPathExpansion(
-            SMSWatcher::kModemManager1ClassKey, &msgclass)) {
-      msgclass = -1;
-    }
-    sms.msgclass = msgclass;
-
-    callback_.Run(device_path_, sms);
-  }
-
-  void GetCallback(const base::DictionaryValue& dictionary) {
-    RunCallbackWithSMS(dictionary);
-    GetMessages();
-  }
-
-  base::WeakPtrFactory<ModemManager1Watcher> weak_ptr_factory_;
-  bool deleting_messages_;
-  bool retrieving_messages_;
-  std::vector<dbus::ObjectPath> delete_queue_;
-  std::deque<dbus::ObjectPath> retrieval_queue_;
-
-  DISALLOW_COPY_AND_ASSIGN(ModemManager1Watcher);
-};
-
-}  // namespace
-
-SMSWatcher::SMSWatcher(const std::string& modem_device_path,
-                       MonitorSMSCallback callback)
-    : weak_ptr_factory_(this),
-      device_path_(modem_device_path),
-      callback_(callback) {
-  DBusThreadManager::Get()->GetShillDeviceClient()->GetProperties(
-      dbus::ObjectPath(modem_device_path),
-      base::Bind(&SMSWatcher::DevicePropertiesCallback,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-SMSWatcher::~SMSWatcher() {
-}
-
-void SMSWatcher::DevicePropertiesCallback(
-    DBusMethodCallStatus call_status,
-    const base::DictionaryValue& properties) {
-  if (call_status != DBUS_METHOD_CALL_SUCCESS)
-    return;
-
-  std::string dbus_connection;
-  if (!properties.GetStringWithoutPathExpansion(
-          flimflam::kDBusConnectionProperty, &dbus_connection)) {
-    LOG(WARNING) << "Modem device properties do not include DBus connection.";
-    return;
-  }
-
-  std::string object_path_string;
-  if (!properties.GetStringWithoutPathExpansion(
-          flimflam::kDBusObjectProperty, &object_path_string)) {
-    LOG(WARNING) << "Modem device properties do not include DBus object.";
-    return;
-  }
-
-  if (object_path_string.compare(
-          0, sizeof(modemmanager::kModemManager1ServicePath) - 1,
-          modemmanager::kModemManager1ServicePath) == 0) {
-    watcher_.reset(
-        new ModemManager1Watcher(device_path_, callback_, dbus_connection,
-                                 dbus::ObjectPath(object_path_string)));
-  } else {
-    watcher_.reset(
-        new GsmWatcher(device_path_, callback_, dbus_connection,
-                       dbus::ObjectPath(object_path_string)));
-  }
-}
-
-}  // namespace chromeos