Elim 'Translated' from Managed ONC dictionary

chrome/browser/ui/webui/options/chromeos/internet_options_handler.cc

 // Copyright (c) 2012 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/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 45 matching lines @@
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/chromeos/network/network_icon.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace chromeos {
 namespace options {
 
 namespace {
 
-// The key in a Managed Value dictionary for translated values.
-// TODO(stevenjb): Consider making this part of the ONC spec.
-const char kTranslatedKey[] = "Translated";
-
 // Keys for the network description dictionary passed to the web ui. Make sure
 // to keep the strings in sync with what the JavaScript side uses.
 const char kNetworkInfoKeyIconURL[] = "iconURL";
 const char kNetworkInfoKeyServicePath[] = "servicePath";
 const char kNetworkInfoKeyPolicyManaged[] = "policyManaged";
 
 // These are keys for getting IP information from the web ui.
 const char kIpConfigAddress[] = "address";
 const char kIpConfigPrefixLength[] = "prefixLength";
 const char kIpConfigNetmask[] = "netmask";
@@ skipping 302 matching lines @@
     recommended = onc::IsRecommendedValue(onc, onc_key);
   }
   SetManagedValueDictionaryEx(settings_dict_key,
                               value,
                               onc_source,
                               recommended,
                               default_value,
                               settings_dict);
 }
 
-// Creates a GetManagedProperties style dictionary with an Active value and
-// a Translated value, and adds it to |settings|.
-// Note(stevenjb): This is bridge code until we use GetManagedProperties to
-// retrieve Shill properties and include Translated values.
-void SetTranslatedDictionary(const char* settings_dict_key,
-                             const std::string& value,
-                             const std::string& translated_value,
-                             base::DictionaryValue* settings_dict) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  settings_dict->Set(settings_dict_key, dict);
-  dict->SetString(::onc::kAugmentationActiveSetting, value);
-  dict->SetString(kTranslatedKey, translated_value);
-}
-
 // Fills |dictionary| with the configuration details of |vpn|. |onc| is required
 // for augmenting the policy-managed information.
 void PopulateVPNDetails(const NetworkState* vpn,
                         const base::DictionaryValue& shill_properties,
                         base::DictionaryValue* dictionary) {
   // Name and Remembered are set in PopulateConnectionDetails().
   // Provider properties are stored in the "Provider" dictionary.
   const base::DictionaryValue* shill_provider_properties = NULL;
   if (!shill_properties.GetDictionaryWithoutPathExpansion(
           shill::kProviderProperty, &shill_provider_properties)) {
     LOG(ERROR) << "No provider properties for VPN: " << vpn->path();
     return;
   }
-  base::DictionaryValue* vpn_dictionary = new base::DictionaryValue;
-  dictionary->Set(::onc::network_config::kVPN, vpn_dictionary);
+  base::DictionaryValue* vpn_dictionary;
+  if (!dictionary->GetDictionary(
+          ::onc::network_config::kVPN, &vpn_dictionary)) {
+    vpn_dictionary = new base::DictionaryValue;
+    dictionary->Set(::onc::network_config::kVPN, vpn_dictionary);
+  }
 
   std::string shill_provider_type;
   if (!shill_provider_properties->GetStringWithoutPathExpansion(
           shill::kTypeProperty, &shill_provider_type)) {
     LOG(ERROR) << "Shill VPN has no Provider.Type: " << vpn->path();
     return;
   }
   std::string onc_provider_type;
   onc::TranslateStringToONC(
       onc::kVPNTypeTable, shill_provider_type, &onc_provider_type);
-  SetTranslatedDictionary(
-      ::onc::vpn::kType,
-      onc_provider_type,
-      internet_options_strings::ProviderTypeString(shill_provider_type,
-                                                   *shill_provider_properties),
-      vpn_dictionary);
+  vpn_dictionary->SetString(::onc::vpn::kType, onc_provider_type);
 
   std::string provider_type_key;
   std::string username;
   if (shill_provider_type == shill::kProviderOpenVpn) {
     provider_type_key = ::onc::vpn::kOpenVPN;
     shill_provider_properties->GetStringWithoutPathExpansion(
         shill::kOpenVPNUserProperty, &username);
   } else {
     provider_type_key = ::onc::vpn::kL2TP;
     shill_provider_properties->GetStringWithoutPathExpansion(
@@ skipping 1109 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos