Implement networkingPrivate.getDeviceStates

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 11 matching lines @@
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/api/networking_private.h"
 
 using chromeos::NetworkHandler;
+using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 using chromeos::ShillManagerClient;
 using extensions::NetworkingPrivateDelegate;
 
 namespace {
 
 chromeos::NetworkStateHandler* GetStateHandler() {
   return NetworkHandler::Get()->network_state_handler();
 }
 
@@ skipping 28 matching lines @@
     // to avoid complexities with the policy code.
     LOG(ERROR) << "networkingPrivate API call from non primary user: "
                << context_user_hash;
     *error = "Error.NonPrimaryUser";
     return false;
   }
   *user_hash = context_user_hash;
   return true;
 }
 
+void InsertDeviceState(
+    const char* type,
+    extensions::NetworkingPrivateDelegate::DeviceStateMap* devices) {
+  NetworkTypePattern pattern =
+      chromeos::onc::NetworkTypePatternFromOncType(type);
+  NetworkStateHandler::TechnologyState technology_state =
+      GetStateHandler()->GetTechnologyState(pattern);
+  switch (technology_state) {
+    case NetworkStateHandler::TECHNOLOGY_UNAVAILABLE:
+      // No entry for unavaliable network types.

[pneubeck (no reviews), 2015/04/08 10:05:07]

typo: unavaliable -> unavailable

[stevenjb, 2015/04/08 20:27:30]

Done.

+      return;
+    case NetworkStateHandler::TECHNOLOGY_AVAILABLE:
+      (*devices)[type] = ::onc::device_state::kDisabled;
+      return;
+    case NetworkStateHandler::TECHNOLOGY_UNINITIALIZED:
+      (*devices)[type] = ::onc::device_state::kUninitialized;
+      return;
+    case NetworkStateHandler::TECHNOLOGY_ENABLING:
+      (*devices)[type] = ::onc::device_state::kEnabling;
+      return;
+    case NetworkStateHandler::TECHNOLOGY_ENABLED:
+      (*devices)[type] = ::onc::device_state::kEnabled;
+      return;
+  }
+  NOTREACHED();
+}
+
 void NetworkHandlerDictionaryCallback(
     const NetworkingPrivateDelegate::DictionaryCallback& callback,
     const std::string& service_path,
     const base::DictionaryValue& dictionary) {
   scoped_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
   callback.Run(dictionary_copy.Pass());
 }
 
 void NetworkHandlerFailureCallback(
     const NetworkingPrivateDelegate::FailureCallback& callback,
@@ skipping 236 matching lines @@
   if (state_handler->IsTechnologyEnabled(NetworkTypePattern::WiFi()))
     network_list->AppendString(::onc::network_type::kWiFi);
   if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()))
     network_list->AppendString(::onc::network_type::kWimax);
   if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Cellular()))
     network_list->AppendString(::onc::network_type::kCellular);
 
   return network_list.Pass();
 }
 
+scoped_ptr<NetworkingPrivateDelegate::DeviceStateMap>
+NetworkingPrivateChromeOS::GetDeviceStates() {
+  scoped_ptr<DeviceStateMap> device_list(new DeviceStateMap);
+
+  InsertDeviceState(::onc::network_type::kEthernet, device_list.get());

[pneubeck (no reviews), 2015/04/08 10:05:07]

for consideration:

would it make sense to expose the list of available (or all known) network
technologies by NSH instead of explicitly listing the technologies to add?

[stevenjb, 2015/04/08 20:27:30]

See meta comment. I'm actually going to need to change this to iterate this
across all Devices + any available technologies that do not have a device.

+  InsertDeviceState(::onc::network_type::kWiFi, device_list.get());
+  InsertDeviceState(::onc::network_type::kWimax, device_list.get());
+  InsertDeviceState(::onc::network_type::kCellular, device_list.get());
+
+  return device_list.Pass();
+}
+
 bool NetworkingPrivateChromeOS::EnableNetworkType(const std::string& type) {
   NetworkTypePattern pattern =
       chromeos::onc::NetworkTypePatternFromOncType(type);
 
   GetStateHandler()->SetTechnologyEnabled(
       pattern, true, chromeos::network_handler::ErrorCallback());
 
   return true;
 }
 
 bool NetworkingPrivateChromeOS::DisableNetworkType(const std::string& type) {
   NetworkTypePattern pattern =
       chromeos::onc::NetworkTypePatternFromOncType(type);
 
   GetStateHandler()->SetTechnologyEnabled(
       pattern, false, chromeos::network_handler::ErrorCallback());
 
   return true;
 }
 
 bool NetworkingPrivateChromeOS::RequestScan() {
   GetStateHandler()->RequestScan();
   return true;
 }
 
 }  // namespace extensions