Cashew: implement backend usage API

src/service_manager.cc

 // Copyright (c) 2010 The Chromium OS 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 "src/service_manager.h"
 
 #include <glog/logging.h>
 
+#include "src/cashew_server.h"
 #include "src/service.h"
 
 namespace cashew {
 
 // Flimflam D-Bus indentifiers
 static const char* kFlimflamManagerName = "org.chromium.flimflam";
 static const char* kFlimflamManagerPath = "/";
 
 // Flimflam property names
 static const char* kServicesProperty = "Services";
 
 // Flimflam service types
 static const char* kTypeCellular = "cellular";
 
 ServiceManager::ServiceManager(DBus::Connection& connection)  // NOLINT
     : DBus::ObjectProxy(connection, kFlimflamManagerPath,
                         kFlimflamManagerName),
-      connection_(connection) {
+      connection_(connection), cashew_server_(NULL) {
   // init our state with a GetProperties() call to Flimflam
   // we'll update this state by monitoring PropertyChanged signals
   GetFlimflamServices();
 }
 
 ServiceManager::~ServiceManager() {
   DeleteServices(&services_);
 }
 
 const Service* ServiceManager::GetService(const std::string& service_path)
     const {
   ServiceMap::const_iterator it = services_.find(service_path);
   if (it == services_.end()) {
     return NULL;
   }
   DCHECK(it->second != NULL);
   return static_cast<const Service *>(it->second);
 }
 
+void ServiceManager::SetCashewServer(CashewServer *cashew_server) {
+  DLOG(INFO) << "SetCashewServer";
+  cashew_server_ = cashew_server;
+}
+
 // Flimflam Manager D-Bus Proxy methods
 
 void ServiceManager::PropertyChanged(const std::string& property_name,
                                      const DBus::Variant& new_value) {
   DLOG(INFO) << "PropertyChanged: property_name = " << property_name;
 
   // we only care about Services changes
   if (property_name.compare(kServicesProperty)) {
       return;
   }
 
   // interpret new_value as a vector of service paths
   ServicePathList paths;
   DBus::MessageIter reader = new_value.reader();
   reader >> paths;
 
   OnServicesUpdate(paths);
 }
 
 void ServiceManager::StateChanged(const std::string& new_state) {
   DLOG(INFO) << "StateChanged: new_state = " << new_state;
   // TODO(vlaviano): switch on state and call private onFlimflamOffline(),
   // onFlimflamOnline() hooks.  If we care.
 }
 
+// Service methods
+
+void ServiceManager::EmitDataPlansUpdate(const Service& service) {
+  DLOG(INFO) << "EmitDataPlansUpdate: service = " << service.GetPath();
+  if (cashew_server_ == NULL) {
+    DLOG(WARNING) << "EmitDataPlansUpdate: no Cashew server";
+    return;
+  }
+  cashew_server_->EmitDataPlansUpdate(service);
+}
+
 // Private methods
 
 void ServiceManager::DeleteServices(ServiceMap *service_map) {
   DCHECK(service_map != NULL);
   while (!service_map->empty()) {
     const std::string& path =
         static_cast<std::string>(service_map->begin()->first);
     DLOG(INFO) << "DeleteServices: deleting service: " << path;
     Service *service = static_cast<Service *>(service_map->begin()->second);
     delete service;
@@ skipping 72 matching lines @@
     }
   }
 
   // services left in old_services failed to appear in the update: delete them
   DeleteServices(&old_services);
 }
 
 void ServiceManager::OnNewService(const DBus::Path& path) {
   DLOG(INFO) << "OnNewService: " << path;
   DCHECK(GetService(path) == NULL);
-  Service *service = new(std::nothrow) Service(connection_, path);
+  Service *service = new(std::nothrow) Service(this, connection_, path);
   if (service == NULL) {
     LOG(ERROR) << "OnNewService: couldn't create service for " << path;
     return;
   }
   services_[path] = service;
 }
 
 }  // namespace cashew