Remove third-party VPN combined name

extensions/browser/api/vpn_provider/vpn_service.cc

 // Copyright 2014 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 "extensions/browser/api/vpn_provider/vpn_service.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 22 matching lines @@
 
 namespace {
 
 namespace api_vpn = extensions::core_api::vpn_provider;
 
 std::string GetKey(const std::string& extension_id, const std::string& name) {
   const std::string key = crypto::SHA256HashString(extension_id + name);
   return base::HexEncode(key.data(), key.size());
 }
 
-std::string GetCombinedName(const std::string& extension_name,
-                            const std::string& configuration_name) {
-  // TODO(kaliamoorthi): (crbug.com/434711) Sort out the dependencies and
-  // replace the string concatenation with internationalized version.
-  return extension_name + ": " + configuration_name;
-}
-
 void DoNothingFailureCallback(const std::string& error_name,
                               const std::string& error_message) {
   LOG(ERROR) << error_name << ": " << error_message;
 }
 
 }  // namespace
 
 class VpnService::VpnConfiguration : public ShillThirdPartyVpnObserver {
  public:
   VpnConfiguration(const std::string& extension_id,
@@ skipping 150 matching lines @@
                                                Source source) {
 }
 
 void VpnService::OnGetPropertiesSuccess(
     const std::string& service_path,
     const base::DictionaryValue& dictionary) {
   if (service_path_to_configuration_map_.find(service_path) !=
       service_path_to_configuration_map_.end()) {
     return;
   }
-  const base::DictionaryValue* provider = nullptr;
   std::string vpn_type;
   std::string extension_id;
   std::string type;
-  std::string name;
   std::string configuration_name;
-  if (!dictionary.GetDictionary(shill::kProviderProperty, &provider) ||
-      !dictionary.GetString(shill::kProviderTypeProperty, &vpn_type) ||
+  if (!dictionary.GetString(shill::kProviderTypeProperty, &vpn_type) ||
       !dictionary.GetString(shill::kProviderHostProperty, &extension_id) ||
       !dictionary.GetString(shill::kTypeProperty, &type) ||
-      !dictionary.GetString(shill::kNameProperty, &name) ||
-      !provider->GetString(shill::kConfigurationNameProperty,
-                           &configuration_name) ||
+      !dictionary.GetString(shill::kNameProperty, &configuration_name) ||
       vpn_type != shill::kProviderThirdPartyVpn || type != shill::kTypeVPN) {
     return;
   }
 
   if (!extension_registry_->GetExtensionById(
           extension_id, extensions::ExtensionRegistry::ENABLED)) {
     // Does not belong to this instance of VpnService.
     return;
   }
 
@@ skipping 53 matching lines @@
         std::string("No user profile for unshared network configuration."));
     return;
   }
 
   VpnConfiguration* configuration =
       CreateConfigurationInternal(extension_id, configuration_name, key);
 
   base::DictionaryValue properties;
   properties.SetStringWithoutPathExpansion(shill::kTypeProperty,
                                            shill::kTypeVPN);
-  properties.SetStringWithoutPathExpansion(
-      shill::kNameProperty,  // This value is shown to the user in native UI.
-      GetCombinedName(extension_name, configuration_name));
+  properties.SetStringWithoutPathExpansion(shill::kNameProperty,
+                                           configuration_name);
   properties.SetStringWithoutPathExpansion(shill::kProviderHostProperty,
                                            extension_id);
   properties.SetStringWithoutPathExpansion(shill::kObjectPathSuffixProperty,
                                            configuration->key());
   properties.SetStringWithoutPathExpansion(shill::kProviderTypeProperty,
                                            shill::kProviderThirdPartyVpn);
   properties.SetStringWithoutPathExpansion(shill::kProfileProperty,
                                            profile->path);
-  properties.SetStringWithoutPathExpansion(shill::kConfigurationNameProperty,
-                                           configuration_name);
 
   // Note: This will not create an entry in |policy_util|. TODO(pneubeck):
   // Determine the correct thing to do here, crbug.com/459278.
   std::string guid = base::GenerateGUID();
   properties.SetStringWithoutPathExpansion(shill::kGuidProperty, guid);
 
   network_configuration_handler_->CreateShillConfiguration(
       properties, NetworkConfigurationObserver::SOURCE_EXTENSION_INSTALL,
       base::Bind(&VpnService::OnCreateConfigurationSuccess,
                  weak_factory_.GetWeakPtr(), success, configuration),
@@ skipping 162 matching lines @@
   delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
 }  // namespace chromeos