Home | History | Annotate | Download | only in dbus 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chromeos/dbus/fake_shill_profile_client.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/bind_helpers.h"
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/stl_util.h"
     11 #include "base/values.h"
     12 #include "chromeos/dbus/dbus_thread_manager.h"
     13 #include "chromeos/dbus/shill_manager_client.h"
     14 #include "chromeos/dbus/shill_property_changed_observer.h"
     15 #include "chromeos/dbus/shill_service_client.h"
     16 #include "dbus/bus.h"
     17 #include "dbus/message.h"
     18 #include "dbus/object_path.h"
     19 #include "dbus/values_util.h"
     20 #include "third_party/cros_system_api/dbus/service_constants.h"
     21 
     22 namespace chromeos {
     23 
     24 struct FakeShillProfileClient::ProfileProperties {
     25   base::DictionaryValue entries;  // Dictionary of Service Dictionaries
     26   base::DictionaryValue properties;  // Dictionary of Profile properties
     27 };
     28 
     29 namespace {
     30 
     31 void PassDictionary(
     32     const ShillProfileClient::DictionaryValueCallbackWithoutStatus& callback,
     33     const base::DictionaryValue* dictionary) {
     34   callback.Run(*dictionary);
     35 }
     36 
     37 }  // namespace
     38 
     39 FakeShillProfileClient::FakeShillProfileClient() {
     40 }
     41 
     42 FakeShillProfileClient::~FakeShillProfileClient() {
     43   STLDeleteValues(&profiles_);
     44 }
     45 
     46 void FakeShillProfileClient::Init(dbus::Bus* bus) {
     47 }
     48 
     49 void FakeShillProfileClient::AddPropertyChangedObserver(
     50     const dbus::ObjectPath& profile_path,
     51     ShillPropertyChangedObserver* observer) {
     52 }
     53 
     54 void FakeShillProfileClient::RemovePropertyChangedObserver(
     55     const dbus::ObjectPath& profile_path,
     56     ShillPropertyChangedObserver* observer) {
     57 }
     58 
     59 void FakeShillProfileClient::GetProperties(
     60     const dbus::ObjectPath& profile_path,
     61     const DictionaryValueCallbackWithoutStatus& callback,
     62     const ErrorCallback& error_callback) {
     63   ProfileProperties* profile = GetProfile(profile_path, error_callback);
     64   if (!profile)
     65     return;
     66 
     67   scoped_ptr<base::DictionaryValue> properties(profile->properties.DeepCopy());
     68   base::ListValue* entry_paths = new base::ListValue;
     69   properties->SetWithoutPathExpansion(shill::kEntriesProperty, entry_paths);
     70   for (base::DictionaryValue::Iterator it(profile->entries); !it.IsAtEnd();
     71        it.Advance()) {
     72     entry_paths->AppendString(it.key());
     73   }
     74 
     75   base::MessageLoop::current()->PostTask(
     76       FROM_HERE,
     77       base::Bind(&PassDictionary, callback, base::Owned(properties.release())));
     78 }
     79 
     80 void FakeShillProfileClient::GetEntry(
     81     const dbus::ObjectPath& profile_path,
     82     const std::string& entry_path,
     83     const DictionaryValueCallbackWithoutStatus& callback,
     84     const ErrorCallback& error_callback) {
     85   ProfileProperties* profile = GetProfile(profile_path, error_callback);
     86   if (!profile)
     87     return;
     88 
     89   base::DictionaryValue* entry = NULL;
     90   profile->entries.GetDictionaryWithoutPathExpansion(entry_path, &entry);
     91   if (!entry) {
     92     error_callback.Run("Error.InvalidProfileEntry", "Invalid profile entry");
     93     return;
     94   }
     95 
     96   base::MessageLoop::current()->PostTask(
     97       FROM_HERE,
     98       base::Bind(&PassDictionary, callback, base::Owned(entry->DeepCopy())));
     99 }
    100 
    101 void FakeShillProfileClient::DeleteEntry(const dbus::ObjectPath& profile_path,
    102                                          const std::string& entry_path,
    103                                          const base::Closure& callback,
    104                                          const ErrorCallback& error_callback) {
    105   ProfileProperties* profile = GetProfile(profile_path, error_callback);
    106   if (!profile)
    107     return;
    108 
    109   if (!profile->entries.RemoveWithoutPathExpansion(entry_path, NULL)) {
    110     error_callback.Run("Error.InvalidProfileEntry", entry_path);
    111     return;
    112   }
    113 
    114   base::StringValue profile_path_value("");
    115   DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()->
    116       SetServiceProperty(entry_path,
    117                          shill::kProfileProperty,
    118                          profile_path_value);
    119 
    120   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
    121 }
    122 
    123 ShillProfileClient::TestInterface* FakeShillProfileClient::GetTestInterface() {
    124   return this;
    125 }
    126 
    127 void FakeShillProfileClient::AddProfile(const std::string& profile_path,
    128                                         const std::string& userhash) {
    129   if (GetProfile(dbus::ObjectPath(profile_path), ErrorCallback()))
    130     return;
    131 
    132   ProfileProperties* profile = new ProfileProperties;
    133   profile->properties.SetStringWithoutPathExpansion(shill::kUserHashProperty,
    134                                                     userhash);
    135   profiles_[profile_path] = profile;
    136   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
    137       AddProfile(profile_path);
    138 }
    139 
    140 void FakeShillProfileClient::AddEntry(const std::string& profile_path,
    141                                       const std::string& entry_path,
    142                                       const base::DictionaryValue& properties) {
    143   ProfileProperties* profile = GetProfile(dbus::ObjectPath(profile_path),
    144                                           ErrorCallback());
    145   DCHECK(profile);
    146   profile->entries.SetWithoutPathExpansion(entry_path, properties.DeepCopy());
    147   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
    148       AddManagerService(entry_path, true);
    149 }
    150 
    151 bool FakeShillProfileClient::AddService(const std::string& profile_path,
    152                                         const std::string& service_path) {
    153   ProfileProperties* profile = GetProfile(dbus::ObjectPath(profile_path),
    154                                           ErrorCallback());
    155   if (!profile) {
    156     LOG(ERROR) << "AddService: No matching profile: " << profile_path
    157                << " for: " << service_path;
    158     return false;
    159   }
    160   if (profile->entries.HasKey(service_path))
    161     return false;
    162   return AddOrUpdateServiceImpl(profile_path, service_path, profile);
    163 }
    164 
    165 bool FakeShillProfileClient::UpdateService(const std::string& profile_path,
    166                                            const std::string& service_path) {
    167   ProfileProperties* profile = GetProfile(dbus::ObjectPath(profile_path),
    168                                           ErrorCallback());
    169   if (!profile) {
    170     LOG(ERROR) << "UpdateService: No matching profile: " << profile_path
    171                << " for: " << service_path;
    172     return false;
    173   }
    174   if (!profile->entries.HasKey(service_path)) {
    175     LOG(ERROR) << "UpdateService: Profile: " << profile_path
    176                << " does not contain Service: " << service_path;
    177     return false;
    178   }
    179   return AddOrUpdateServiceImpl(profile_path, service_path, profile);
    180 }
    181 
    182 bool FakeShillProfileClient::AddOrUpdateServiceImpl(
    183     const std::string& profile_path,
    184     const std::string& service_path,
    185     ProfileProperties* profile) {
    186   ShillServiceClient::TestInterface* service_test =
    187       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
    188   const base::DictionaryValue* service_properties =
    189       service_test->GetServiceProperties(service_path);
    190   if (!service_properties) {
    191     LOG(ERROR) << "No matching service: " << service_path;
    192     return false;
    193   }
    194   std::string service_profile_path;
    195   service_properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
    196                                                     &service_profile_path);
    197   if (service_profile_path.empty()) {
    198     base::StringValue profile_path_value(profile_path);
    199     service_test->SetServiceProperty(service_path,
    200                                      shill::kProfileProperty,
    201                                      profile_path_value);
    202   } else if (service_profile_path != profile_path) {
    203     LOG(ERROR) << "Service has non matching profile path: "
    204                << service_profile_path;
    205     return false;
    206   }
    207 
    208   profile->entries.SetWithoutPathExpansion(service_path,
    209                                            service_properties->DeepCopy());
    210   return true;
    211 }
    212 
    213 void FakeShillProfileClient::GetProfilePaths(
    214     std::vector<std::string>* profiles) {
    215   for (ProfileMap::iterator iter = profiles_.begin();
    216        iter != profiles_.end(); ++iter) {
    217     profiles->push_back(iter->first);
    218   }
    219 }
    220 
    221 bool FakeShillProfileClient::GetService(const std::string& service_path,
    222                                         std::string* profile_path,
    223                                         base::DictionaryValue* properties) {
    224   properties->Clear();
    225   for (ProfileMap::const_iterator iter = profiles_.begin();
    226        iter != profiles_.end(); ++iter) {
    227     const ProfileProperties* profile = iter->second;
    228     const base::DictionaryValue* entry;
    229     if (!profile->entries.GetDictionaryWithoutPathExpansion(
    230             service_path, &entry)) {
    231       continue;
    232     }
    233     *profile_path = iter->first;
    234     properties->MergeDictionary(entry);
    235     return true;
    236   }
    237   return false;
    238 }
    239 
    240 void FakeShillProfileClient::ClearProfiles() {
    241   STLDeleteValues(&profiles_);
    242 }
    243 
    244 FakeShillProfileClient::ProfileProperties* FakeShillProfileClient::GetProfile(
    245     const dbus::ObjectPath& profile_path,
    246     const ErrorCallback& error_callback) {
    247   ProfileMap::const_iterator found = profiles_.find(profile_path.value());
    248   if (found == profiles_.end()) {
    249     if (!error_callback.is_null())
    250       error_callback.Run("Error.InvalidProfile", "Invalid profile");
    251     return NULL;
    252   }
    253 
    254   return found->second;
    255 }
    256 
    257 }  // namespace chromeos
    258