Adding policy support to the new network configuration stack.

chromeos/dbus/shill_service_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_service_client_stub.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 14 matching lines @@
 void ErrorFunction(const std::string& error_name,
                    const std::string& error_message) {
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
 void PassStubListValue(const ShillServiceClient::ListValueCallback& callback,
                        base::ListValue* value) {
   callback.Run(*value);
 }
 
+void PassStubServiceProperties(
+    const ShillServiceClient::DictionaryValueCallback& callback,
+    DBusMethodCallStatus call_status,
+    const base::DictionaryValue* properties) {
+  callback.Run(call_status, *properties);
+}
+
 }  // namespace
 
 ShillServiceClientStub::ShillServiceClientStub() : weak_ptr_factory_(this) {
   SetDefaultProperties();
 }
 
 ShillServiceClientStub::~ShillServiceClientStub() {
   STLDeleteContainerPairSecondPointers(
       observer_list_.begin(), observer_list_.end());
 }
@@ skipping 10 matching lines @@
     const dbus::ObjectPath& service_path,
     ShillPropertyChangedObserver* observer) {
   GetObserverList(service_path).RemoveObserver(observer);
 }
 
 void ShillServiceClientStub::GetProperties(
     const dbus::ObjectPath& service_path,
     const DictionaryValueCallback& callback) {
   if (callback.is_null())
     return;
+
+  base::DictionaryValue* nested_dict = NULL;
+  scoped_ptr<base::DictionaryValue> result_properties;
+  DBusMethodCallStatus call_status;
+  stub_services_.GetDictionaryWithoutPathExpansion(service_path.value(),
+                                                   &nested_dict);
+  if (nested_dict) {
+    result_properties.reset(nested_dict->DeepCopy());
+    // Remove credentials that Shill wouldn't send.
+    result_properties->RemoveWithoutPathExpansion(flimflam::kPassphraseProperty,
+                                                  NULL);
+    call_status = DBUS_METHOD_CALL_SUCCESS;
+  } else {
+    result_properties.reset(new base::DictionaryValue);
+    call_status = DBUS_METHOD_CALL_FAILURE;
+  }
+
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&ShillServiceClientStub::PassStubServiceProperties,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 service_path,
-                 callback));
+      base::Bind(&PassStubServiceProperties,
+                 callback,
+                 call_status,
+                 base::Owned(result_properties.release())));
 }
 
 void ShillServiceClientStub::SetProperty(const dbus::ObjectPath& service_path,
                                          const std::string& name,
                                          const base::Value& value,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
-      service_path.value(), &dict)) {
+          service_path.value(), &dict)) {
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   if (name == flimflam::kStateProperty) {
     // If we connect to a service, then we move it to the top of the list in
     // the manager client.
     std::string state;
     if (value.GetAsString(&state) && state == flimflam::kStateOnline) {
       ShillManagerClient* manager_client =
           DBusThreadManager::Get()->GetShillManagerClient();
@@ skipping 276 matching lines @@
              flimflam::kTypeVPN,
              flimflam::kStateOnline,
              add_to_watchlist);
 
   AddService("stub_vpn2", "vpn2",
              flimflam::kTypeVPN,
              flimflam::kStateOffline,
              add_to_watchlist);
 }
 
-void ShillServiceClientStub::PassStubServiceProperties(
-    const dbus::ObjectPath& service_path,
-    const DictionaryValueCallback& callback) {
-  base::DictionaryValue* dict = NULL;
-  if (!stub_services_.GetDictionaryWithoutPathExpansion(
-      service_path.value(), &dict)) {
-    base::DictionaryValue empty_dictionary;
-    callback.Run(DBUS_METHOD_CALL_FAILURE, empty_dictionary);
-    return;
-  }
-  callback.Run(DBUS_METHOD_CALL_SUCCESS, *dict);
-}
-
 void ShillServiceClientStub::NotifyObserversPropertyChanged(
     const dbus::ObjectPath& service_path,
     const std::string& property) {
   base::DictionaryValue* dict = NULL;
   std::string path = service_path.value();
   if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &dict)) {
     LOG(ERROR) << "Notify for unknown service: " << path;
     return;
   }
   base::Value* value = NULL;
@@ skipping 23 matching lines @@
   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
       observer_list_.find(device_path);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = observer_list;
   return *observer_list;
 }
 
 }  // namespace chromeos