Remove base::StringValue

extensions/browser/api/networking_private/networking_private_chromeos.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/networking_private/networking_private_chromeos.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 262 matching lines @@
   return ::onc::proxy::kDirect;
 }
 
 void SetManualProxy(base::DictionaryValue* manual,
                     ProxyPrefs::ConfigState state,
                     const std::string& key,
                     const UIProxyConfig::ManualProxy& proxy) {
   base::DictionaryValue* dict = EnsureDictionaryValue(key, manual);
   base::DictionaryValue* host_dict =
       EnsureDictionaryValue(::onc::proxy::kHost, dict);
-  SetProxyEffectiveValue(host_dict, state,
-                         base::MakeUnique<base::StringValue>(
-                             proxy.server.host_port_pair().host()));
+  SetProxyEffectiveValue(
+      host_dict, state,
+      base::MakeUnique<base::Value>(proxy.server.host_port_pair().host()));
   uint16_t port = proxy.server.host_port_pair().port();
   base::DictionaryValue* port_dict =
       EnsureDictionaryValue(::onc::proxy::kPort, dict);
   SetProxyEffectiveValue(port_dict, state, base::MakeUnique<base::Value>(port));
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 476 matching lines @@
   // Ensure that the ProxySettings dictionary exists.
   base::DictionaryValue* proxy_settings =
       EnsureDictionaryValue(::onc::network_config::kProxySettings, dictionary);
   VLOG(2) << " PROXY: " << *proxy_settings;
 
   // Ensure that the ProxySettings.Type dictionary exists and set the Type
   // value to the value from |ui_proxy_config_service|.
   base::DictionaryValue* proxy_type_dict =
       EnsureDictionaryValue(::onc::network_config::kType, proxy_settings);
   SetProxyEffectiveValue(proxy_type_dict, state,
-                         base::WrapUnique<base::Value>(new base::StringValue(
+                         base::WrapUnique<base::Value>(new base::Value(
                              GetProxySettingsType(config.mode))));
 
   // Update any appropriate sub dictionary based on the new type.
   switch (config.mode) {
     case UIProxyConfig::MODE_SINGLE_PROXY: {
       // Use the same proxy value (config.single_proxy) for all proxies.
       base::DictionaryValue* manual =
           EnsureDictionaryValue(::onc::proxy::kManual, proxy_settings);
       SetManualProxy(manual, state, ::onc::proxy::kHttp, config.single_proxy);
       SetManualProxy(manual, state, ::onc::proxy::kHttps, config.single_proxy);
       SetManualProxy(manual, state, ::onc::proxy::kFtp, config.single_proxy);
       SetManualProxy(manual, state, ::onc::proxy::kSocks, config.single_proxy);
       break;
     }
     case UIProxyConfig::MODE_PROXY_PER_SCHEME: {
       base::DictionaryValue* manual =
           EnsureDictionaryValue(::onc::proxy::kManual, proxy_settings);
       SetManualProxy(manual, state, ::onc::proxy::kHttp, config.http_proxy);
       SetManualProxy(manual, state, ::onc::proxy::kHttps, config.https_proxy);
       SetManualProxy(manual, state, ::onc::proxy::kFtp, config.ftp_proxy);
       SetManualProxy(manual, state, ::onc::proxy::kSocks, config.socks_proxy);
       break;
     }
     case UIProxyConfig::MODE_PAC_SCRIPT: {
       base::DictionaryValue* pac =
           EnsureDictionaryValue(::onc::proxy::kPAC, proxy_settings);
-      SetProxyEffectiveValue(
-          pac, state, base::WrapUnique<base::Value>(new base::StringValue(
-                          config.automatic_proxy.pac_url.spec())));
+      SetProxyEffectiveValue(pac, state,
+                             base::WrapUnique<base::Value>(new base::Value(
+                                 config.automatic_proxy.pac_url.spec())));
       break;
     }
     case UIProxyConfig::MODE_DIRECT:
     case UIProxyConfig::MODE_AUTO_DETECT:
       break;
   }
 
   VLOG(2) << " NEW PROXY: " << *proxy_settings;
 }
 
 void NetworkingPrivateChromeOS::ConnectFailureCallback(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
   // TODO(stevenjb): Temporary workaround to show the configuration UI.
   // Eventually the caller (e.g. Settings) should handle any failures and
   // show its own configuration UI. crbug.com/380937.
   if (ui_delegate()->HandleConnectFailed(guid, error_name)) {
     success_callback.Run();
     return;
   }
   failure_callback.Run(error_name);
 }
 
 }  // namespace extensions