Convert TrayVPN to use new NetworkState code

chromeos/dbus/shill_manager_client_stub.cc

 // Copyright (c) 2013 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_manager_client_stub.h"
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 224 matching lines @@
   if (GetListProperty(flimflam::kDevicesProperty)->Remove(
       device_path_value, NULL)) {
     CallNotifyObserversPropertyChanged(flimflam::kDevicesProperty, 0);
   }
 }
 
 void ShillManagerClientStub::ClearDevices() {
   stub_properties_.Remove(flimflam::kDevicesProperty, NULL);
 }
 
+void ShillManagerClientStub::ClearServices() {
+  stub_properties_.Remove(flimflam::kServicesProperty, NULL);
+  stub_properties_.Remove(flimflam::kServiceWatchListProperty, NULL);
+}
+
 void ShillManagerClientStub::AddService(const std::string& service_path,
                                         bool add_to_watch_list) {
   if (GetListProperty(flimflam::kServicesProperty)->AppendIfNotPresent(
       base::Value::CreateStringValue(service_path))) {
     CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
   }
   if (add_to_watch_list)
     AddServiceToWatchList(service_path);
 }
 
@@ skipping 152 matching lines @@
   base::ListValue* list_property = NULL;
   if (!stub_properties_.GetListWithoutPathExpansion(
       property, &list_property)) {
     list_property = new base::ListValue;
     stub_properties_.SetWithoutPathExpansion(property, list_property);
   }
   return list_property;
 }
 
 bool ShillManagerClientStub::TechnologyEnabled(const std::string& type) const {
+  if (type == flimflam::kTypeVPN)
+    return true;  // VPN is always "enabled" since there is no associated device
   bool enabled = false;
   const base::ListValue* technologies;
   if (stub_properties_.GetListWithoutPathExpansion(
           flimflam::kEnabledTechnologiesProperty, &technologies)) {
     base::StringValue type_value(type);
     if (technologies->Find(type_value) != technologies->end())
       enabled = true;
   }
   return enabled;
 }
 
 base::ListValue* ShillManagerClientStub::GetEnabledServiceList(
     const std::string& property) const {
   base::ListValue* new_service_list = new base::ListValue;
   const base::ListValue* service_list;
   if (stub_properties_.GetListWithoutPathExpansion(property, &service_list)) {
     ShillServiceClient::TestInterface* service_client =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     for (base::ListValue::const_iterator iter = service_list->begin();
          iter != service_list->end(); ++iter) {
       std::string service_path;
       if (!(*iter)->GetAsString(&service_path))
         continue;
       const base::DictionaryValue* properties =
           service_client->GetServiceProperties(service_path);
+      if (!properties) {
+        LOG(ERROR) << "Properties not found for service: " << service_path;
+        continue;
+      }
       std::string name;
       properties->GetString(flimflam::kNameProperty, &name);
       std::string type;
       properties->GetString(flimflam::kTypeProperty, &type);
       if (TechnologyEnabled(type))
         new_service_list->Append((*iter)->DeepCopy());
     }
   }
   return new_service_list;
 }
 
 }  // namespace chromeos