Elim 'Translated' from Managed ONC dictionary

chromeos/dbus/fake_shill_manager_client.cc

 // Copyright 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/fake_shill_manager_client.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 760 matching lines @@
                                  base::StringValue(shill::kRoamingStateHome));
   }
 
   // VPN
   state = GetInitialStateForType(shill::kTypeVPN, &enabled);
   if (state != kTechnologyUnavailable) {
     // Set the "Provider" dictionary properties. Note: when setting these in
     // Shill, "Provider.Type", etc keys are used, but when reading the values
     // "Provider" . "Type", etc keys are used. Here we are setting the values
     // that will be read (by the UI, tests, etc).
-    base::DictionaryValue provider_properties;
-    provider_properties.SetString(shill::kTypeProperty,
-                                  shill::kProviderOpenVpn);
-    provider_properties.SetString(shill::kHostProperty, "vpn_host");
+    base::DictionaryValue provider_properties_openvpn;
+    provider_properties_openvpn.SetString(shill::kTypeProperty,
+                                          shill::kProviderOpenVpn);
+    provider_properties_openvpn.SetString(shill::kHostProperty, "vpn_host");
 
     services->AddService("/service/vpn1",
                          "vpn1_guid",
                          "vpn1" /* name */,
                          shill::kTypeVPN,
                          state,
                          add_to_visible);
     services->SetServiceProperty(
-        "/service/vpn1", shill::kProviderProperty, provider_properties);
+        "/service/vpn1", shill::kProviderProperty, provider_properties_openvpn);
     profiles->AddService(shared_profile, "/service/vpn1");
 
+    base::DictionaryValue provider_properties_l2tp;
+    provider_properties_l2tp.SetString(shill::kTypeProperty,
+                                       shill::kProviderL2tpIpsec);
+    provider_properties_l2tp.SetString(shill::kHostProperty, "vpn_host2");
+
     services->AddService("/service/vpn2",
                          "vpn2_guid",
                          "vpn2" /* name */,
                          shill::kTypeVPN,
                          shill::kStateIdle,
                          add_to_visible);
     services->SetServiceProperty(
-        "/service/vpn2", shill::kProviderProperty, provider_properties);
+        "/service/vpn2", shill::kProviderProperty, provider_properties_l2tp);
   }
 
   // Additional device states
   for (DevicePropertyMap::iterator iter1 = shill_device_property_map_.begin();
        iter1 != shill_device_property_map_.end(); ++iter1) {
     std::string device_type = iter1->first;
     std::string device_path = devices->GetDevicePathForType(device_type);
     for (ShillPropertyMap::iterator iter2 = iter1->second.begin();
          iter2 != iter1->second.end(); ++iter2) {
       devices->SetDeviceProperty(device_path, iter2->first, *(iter2->second));
@@ skipping 270 matching lines @@
   *enabled = true;
   if ((state == shill::kStatePortal && type != shill::kTypeWifi) ||
       (state == kNetworkActivated && type != shill::kTypeCellular)) {
     LOG(WARNING) << "Invalid state: " << state << " for " << type;
     return shill::kStateIdle;
   }
   return state;
 }
 
 }  // namespace chromeos