Adding a new ManagedNetworkConfigurationHandler.

chrome/browser/chromeos/extensions/networking_private_api.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 "chrome/browser/chromeos/extensions/networking_private_api.h"
 
+#include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/callback.h"
+#include "chrome/browser/chromeos/net/managed_network_configuration_handler.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/common/extensions/api/networking_private.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/onc/onc_constants.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translation_tables.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using namespace chromeos;
 namespace api = extensions::api::networking_private;
 
 namespace {
 
 // An error returned when no valid services were found.
 const char kInvalidResponseError[] = "Error.invalidResponse";
 
-// This creates a new ONC dictionary that only contains the information we're
-// interested in passing on to JavaScript.
+// Filters from the given ONC dictionary the information we're interested in
+// before passing it to JavaScript.
 scoped_ptr<api::NetworkProperties> CreateFilteredResult(
-    const base::DictionaryValue& properties) {
-  scoped_ptr<base::DictionaryValue> onc_properties(
-      onc::TranslateShillServiceToONCPart(
-          properties,
-          &onc::kNetworkConfigurationSignature));
-
-  // Now we filter it so we only include properties that we care about for this
-  // interface.
+    const base::DictionaryValue& onc_dictionary) {
   static const char* const desired_fields[] = {
       onc::network_config::kWiFi,
       onc::network_config::kName,
       onc::network_config::kGUID,
       onc::network_config::kType,
       onc::network_config::kConnectionState,
   };
 
   scoped_ptr<api::NetworkProperties> filtered_result(
       new api::NetworkProperties);
   for (size_t i = 0; i < arraysize(desired_fields); ++i) {
-    base::Value* value;
-    if (onc_properties->Get(desired_fields[i], &value))
-      filtered_result->additional_properties.Set(desired_fields[i],
-                                                 value->DeepCopy());
+    const base::Value* value;
+    if (onc_dictionary.GetWithoutPathExpansion(desired_fields[i], &value)) {
+      filtered_result->additional_properties.SetWithoutPathExpansion(
+          desired_fields[i],
+          value->DeepCopy());
+    }
   }
 
   return filtered_result.Pass();
 }
 
 class ResultList : public base::RefCounted<ResultList> {
  public:
   typedef base::Callback<void(const std::string& error,
                               scoped_ptr<base::ListValue>)> ResultCallback;
 
@@ skipping 70 matching lines @@
             network_type));
   }
 }
 
 void ResultList::ServicePropertiesCallback(
     const std::string& service_path,
     const std::string& network_type,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& result) {
   if (call_status == DBUS_METHOD_CALL_SUCCESS) {
+    scoped_ptr<base::DictionaryValue> onc_properties(
+        onc::TranslateShillServiceToONCPart(
+            result,
+            &onc::kNetworkConfigurationSignature));
+
     scoped_ptr<api::NetworkProperties> filtered_result(
-        CreateFilteredResult(result));
+        CreateFilteredResult(*onc_properties));
 
     std::string onc_type;
     if (filtered_result->additional_properties.GetString(
         onc::network_config::kType, &onc_type) &&
         (onc_type == network_type ||
          network_type == onc::network_type::kAllTypes)) {
       // TODO(gspencer): For now the "GUID" we send back is going to look
       // remarkably like the service path. Once this code starts using the
       // NetworkStateHandler instead of Shill directly, we should remove
       // this line so that we're sending back the actual GUID. The
       // JavaScript shouldn't care: this ID is opaque to it, and it
       // shouldn't store it anywhere.
       filtered_result->additional_properties.SetString(
           onc::network_config::kGUID, service_path);

[Greg Spencer (Chromium), 2013/02/19 22:58:26]

So, when we switched to ManagedNetworkConfigurationHandler, I wanted to switch
to using GUIDs here, but I don't see a change in the code that would translate
the service path into a GUID before sending it to JS.  Was that going to be
another phase?

[pneubeck (no reviews), 2013/02/22 10:22:31]

I thought, when we checked the different calls (create, remove, modify), we
found that using the service_path would be the least pain?
The main "problem" was that the GUID doesn't exist for unconfigured networks.
The ManagedNetworkConfigurationHandler can still obtain the GUID of a configured
network by asking the NetworkStateHandler.

I sent you a document that describes what we discussed two weeks ago. Hopefully
it's understandable :-)

On 2013/02/19 22:58:26, Greg Spencer (Chromium) wrote:

[Greg Spencer (Chromium), 2013/02/23 00:11:29]

Yes, I remember that, but I thought there was one case where it wouldn't work,
but I guess that's where we generate a GUID for the unconfigured networks.  In
any case, your diagram makes sense.  Let's use service path like you have here.

 
       Append(filtered_result.release());
     }
   }
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetPropertiesFunction
 
 NetworkingPrivateGetPropertiesFunction::
   ~NetworkingPrivateGetPropertiesFunction() {
 }
 
 bool NetworkingPrivateGetPropertiesFunction::RunImpl() {
   scoped_ptr<api::GetProperties::Params> params =
       api::GetProperties::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  // TODO(gspencer): Currently we're using the service path as the
-  // |network_guid|. Eventually this should be using the real GUID.
-  DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
-      dbus::ObjectPath(params->network_guid),
-      base::Bind(&NetworkingPrivateGetPropertiesFunction::ResultCallback,
-                 this));
+  if (ManagedNetworkConfigurationHandler::IsInitialized()) {
+    ManagedNetworkConfigurationHandler::Get()->GetProperties(
+        params->network_guid,
+        base::Bind(
+            &NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess,
+            this),
+        base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed,
+                   this));
+  } else {
+    // TODO(gspencer): Currently we're using the service path as the
+    // |network_guid|. Eventually this should be using the real GUID.
+    DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
+        dbus::ObjectPath(params->network_guid),
+        base::Bind(&NetworkingPrivateGetPropertiesFunction::ResultCallback,
+                   this));
+  }
   return true;
 }
 
 void NetworkingPrivateGetPropertiesFunction::ResultCallback(
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& result) {
+  scoped_ptr<base::DictionaryValue> onc_properties(
+      onc::TranslateShillServiceToONCPart(
+          result,
+          &onc::kNetworkConfigurationSignature));
+
   scoped_ptr<api::NetworkProperties> filtered_result(
-      CreateFilteredResult(result));
+      CreateFilteredResult(*onc_properties));
   results_ = api::GetProperties::Results::Create(*filtered_result);
   SendResponse(true);
 }
 
+void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess(
+    const std::string& service_path,
+    const base::DictionaryValue& dictionary) {
+  scoped_ptr<api::NetworkProperties> filtered_result(
+      CreateFilteredResult(dictionary));
+  results_ = api::GetProperties::Results::Create(*filtered_result);
+  SendResponse(true);
+}
+
+void NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed(
+    const std::string& error_name,
+    scoped_ptr<base::DictionaryValue> error_data) {
+  error_ = error_name;
+  SendResponse(false);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetVisibleNetworksFunction
 
 NetworkingPrivateGetVisibleNetworksFunction::
 ~NetworkingPrivateGetVisibleNetworksFunction() {
 }
 
 bool NetworkingPrivateGetVisibleNetworksFunction::RunImpl() {
   scoped_ptr<api::GetVisibleNetworks::Params> params =
       api::GetVisibleNetworks::Params::Create(*args_);
@@ skipping 86 matching lines @@
   DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(params->network_guid),
       base::Bind(
           &NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess,
           this),
       base::Bind(
           &NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed,
           this));
   return true;
 }