arc: enable use_new_wrapper_types for net.mojom

components/arc/net/arc_net_host_impl.cc

 // Copyright 2015 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 "components/arc/net/arc_net_host_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 82 matching lines @@
   dict->GetBoolean(onc::wifi::kHiddenSSID, &wifi->hidden_ssid);
 
   wifi->security = TranslateONCWifiSecurityType(dict);
 
   // Optional; defaults to 0.
   dict->GetInteger(onc::wifi::kSignalStrength, &wifi->signal_strength);
 
   return wifi;
 }
 
-mojo::Array<mojo::String> TranslateStringArray(const base::ListValue* list) {
-  mojo::Array<mojo::String> strings = mojo::Array<mojo::String>::New(0);
+std::vector<std::string> TranslateStringArray(const base::ListValue* list) {
+  std::vector<std::string> strings;

[Luis Héctor Chávez, 2016/12/14 22:55:35]

nit: maybe strings.reserve(list->GetSize())? Same in all other cases.

[abhishekbh, 2016/12/14 23:07:47]

I'd rather keep this CL simple. Also, the first push should allocate a big
enough array for most cases. Maybe we can address this in a separate CL. I do
agree with going for performant code wherever possible.

[Luis Héctor Chávez, 2016/12/14 23:09:08]

separate CL is also fine by me.

 
   for (size_t i = 0; i < list->GetSize(); i++) {
     std::string value;
     list->GetString(i, &value);
     DCHECK(!value.empty());
-    strings.push_back(static_cast<mojo::String>(value));
+    strings.push_back(value);
   }
 
   return strings;
 }
 
-mojo::Array<arc::mojom::IPConfigurationPtr> TranslateONCIPConfigs(
+std::vector<arc::mojom::IPConfigurationPtr> TranslateONCIPConfigs(
     const base::ListValue* list) {
-  mojo::Array<arc::mojom::IPConfigurationPtr> configs =
-      mojo::Array<arc::mojom::IPConfigurationPtr>::New(0);
+  std::vector<arc::mojom::IPConfigurationPtr> configs;
 
   for (size_t i = 0; i < list->GetSize(); i++) {
     const base::DictionaryValue* ip_dict = nullptr;
     arc::mojom::IPConfigurationPtr configuration =
         arc::mojom::IPConfiguration::New();
 
     list->GetDictionary(i, &ip_dict);
     DCHECK(ip_dict);
 
     // crbug.com/625229 - Gateway is not always present (but it should be).
@@ skipping 233 matching lines @@
       chromeos::onc::NetworkTypePatternFromOncType(onc::network_type::kWiFi);
   std::unique_ptr<base::ListValue> network_properties_list =
       chromeos::network_util::TranslateNetworkListToONC(
           network_pattern, configured_only, visible_only,
           kGetNetworksListLimit);
 
   // Extract info for each network and add it to the list.
   // Even if there's no WiFi, an empty (size=0) list must be returned and not a
   // null one. The explicitly sized New() constructor ensures the non-null
   // property.
-  mojo::Array<mojom::WifiConfigurationPtr> networks =
-      mojo::Array<mojom::WifiConfigurationPtr>::New(0);
+  std::vector<mojom::WifiConfigurationPtr> networks;
   for (const auto& value : *network_properties_list) {
     mojom::WifiConfigurationPtr wc = mojom::WifiConfiguration::New();
 
     base::DictionaryValue* network_dict = nullptr;
     value->GetAsDictionary(&network_dict);
     DCHECK(network_dict);
 
     // kName is a post-processed version of kHexSSID.
     std::string tmp;
     network_dict->GetString(onc::network_config::kName, &tmp);
@@ skipping 62 matching lines @@
 void ArcNetHostImpl::CreateNetwork(mojom::WifiConfigurationPtr cfg,
                                    const CreateNetworkCallback& callback) {
   if (!IsDeviceOwner()) {
     callback.Run("");
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
   std::unique_ptr<base::DictionaryValue> wifi_dict(new base::DictionaryValue);
 
-  if (cfg->hexssid.is_null() || !cfg->details) {
+  if (!cfg->hexssid.has_value() || !cfg->details) {
     callback.Run("");
     return;
   }
   mojom::ConfiguredNetworkDetailsPtr details =
       std::move(cfg->details->get_configured());
   if (!details) {
     callback.Run("");
     return;
   }
 
   properties->SetStringWithoutPathExpansion(onc::network_config::kType,
                                             onc::network_config::kWiFi);
   wifi_dict->SetStringWithoutPathExpansion(onc::wifi::kHexSSID,
-                                           cfg->hexssid.get());
+                                           cfg->hexssid.value());
   wifi_dict->SetBooleanWithoutPathExpansion(onc::wifi::kAutoConnect,
                                             details->autoconnect);
-  if (cfg->security.get().empty()) {
+  if (cfg->security.empty()) {
     wifi_dict->SetStringWithoutPathExpansion(onc::wifi::kSecurity,
                                              onc::wifi::kSecurityNone);
   } else {
     wifi_dict->SetStringWithoutPathExpansion(onc::wifi::kSecurity,
-                                             cfg->security.get());
-    if (!details->passphrase.is_null()) {
+                                             cfg->security);
+    if (details->passphrase.has_value()) {
       wifi_dict->SetStringWithoutPathExpansion(onc::wifi::kPassphrase,
-                                               details->passphrase.get());
+                                               details->passphrase.value());
     }
   }
   properties->SetWithoutPathExpansion(onc::network_config::kWiFi,
                                       std::move(wifi_dict));
 
   std::string user_id_hash = chromeos::LoginState::Get()->primary_user_hash();
   GetManagedConfigurationHandler()->CreateConfiguration(
       user_id_hash, *properties,
       base::Bind(&ArcNetHostImpl::CreateNetworkSuccessCallback,
                  weak_factory_.GetWeakPtr(), callback),
@@ skipping 11 matching lines @@
   }
 
   if (cached_guid_ == guid) {
     *path = cached_service_path_;
     return true;
   } else {
     return false;
   }
 }
 
-void ArcNetHostImpl::ForgetNetwork(const mojo::String& guid,
+void ArcNetHostImpl::ForgetNetwork(const std::string& guid,
                                    const ForgetNetworkCallback& callback) {
   if (!IsDeviceOwner()) {
     callback.Run(mojom::NetworkResult::FAILURE);
     return;
   }
 
   std::string path;
   if (!GetNetworkPathFromGuid(guid, &path)) {
     callback.Run(mojom::NetworkResult::FAILURE);
     return;
   }
 
   cached_guid_.clear();
   GetManagedConfigurationHandler()->RemoveConfiguration(
       path, base::Bind(&ForgetNetworkSuccessCallback, callback),
       base::Bind(&ForgetNetworkFailureCallback, callback));
 }
 
-void ArcNetHostImpl::StartConnect(const mojo::String& guid,
+void ArcNetHostImpl::StartConnect(const std::string& guid,
                                   const StartConnectCallback& callback) {
   std::string path;
   if (!GetNetworkPathFromGuid(guid, &path)) {
     callback.Run(mojom::NetworkResult::FAILURE);
     return;
   }
 
   GetNetworkConnectionHandler()->ConnectToNetwork(
       path, base::Bind(&StartConnectSuccessCallback, callback),
       base::Bind(&StartConnectFailureCallback, callback), false);
 }
 
-void ArcNetHostImpl::StartDisconnect(const mojo::String& guid,
+void ArcNetHostImpl::StartDisconnect(const std::string& guid,
                                      const StartDisconnectCallback& callback) {
   std::string path;
   if (!GetNetworkPathFromGuid(guid, &path)) {
     callback.Run(mojom::NetworkResult::FAILURE);
     return;
   }
 
   GetNetworkConnectionHandler()->DisconnectNetwork(
       path, base::Bind(&StartDisconnectSuccessCallback, callback),
       base::Bind(&StartDisconnectFailureCallback, callback));
@@ skipping 101 matching lines @@
   net_instance->WifiEnabledStateChanged(is_enabled);
 }
 
 void ArcNetHostImpl::OnShuttingDown() {
   DCHECK(observing_network_state_);
   GetStateHandler()->RemoveObserver(this, FROM_HERE);
   observing_network_state_ = false;
 }
 
 }  // namespace arc