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"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/login/login_state.h"
+#include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_activation_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #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::DeviceState;
 using chromeos::NetworkHandler;
+using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 using chromeos::ShillManagerClient;
 using extensions::NetworkingPrivateDelegate;
 
+namespace private_api = extensions::core_api::networking_private;
+
 namespace {
 
 chromeos::NetworkStateHandler* GetStateHandler() {
   return NetworkHandler::Get()->network_state_handler();
 }
 
 chromeos::ManagedNetworkConfigurationHandler* GetManagedConfigurationHandler() {
   return NetworkHandler::Get()->managed_network_configuration_handler();
 }
 
@@ skipping 24 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 AppendDeviceState(
+    const std::string& type,
+    const DeviceState* device,
+    NetworkingPrivateDelegate::DeviceStateList* device_state_list) {
+  DCHECK(!type.empty());
+  NetworkTypePattern pattern =
+      chromeos::onc::NetworkTypePatternFromOncType(type);
+  NetworkStateHandler::TechnologyState technology_state =
+      GetStateHandler()->GetTechnologyState(pattern);
+  private_api::DeviceStateType state = private_api::DEVICE_STATE_TYPE_NONE;
+  switch (technology_state) {
+    case NetworkStateHandler::TECHNOLOGY_UNAVAILABLE:
+      if (!device)
+        return;
+      // If we have a DeviceState entry but the technology is not available,
+      // assume the technology is not initialized.
+      state = private_api::DEVICE_STATE_TYPE_UNINITIALIZED;
+      break;
+    case NetworkStateHandler::TECHNOLOGY_AVAILABLE:
+      state = private_api::DEVICE_STATE_TYPE_DISABLED;
+      break;
+    case NetworkStateHandler::TECHNOLOGY_UNINITIALIZED:
+      state = private_api::DEVICE_STATE_TYPE_UNINITIALIZED;
+      break;
+    case NetworkStateHandler::TECHNOLOGY_ENABLING:
+      state = private_api::DEVICE_STATE_TYPE_ENABLING;
+      break;
+    case NetworkStateHandler::TECHNOLOGY_ENABLED:
+      state = private_api::DEVICE_STATE_TYPE_ENABLED;
+      break;
+  }
+  DCHECK(state != private_api::DEVICE_STATE_TYPE_NONE);

[pneubeck (no reviews), 2015/04/09 09:41:22]

DCHECK_NE( , )

[stevenjb, 2015/04/09 16:20:25]

Done.

+  scoped_ptr<private_api::DeviceStateProperties> properties(
+      new private_api::DeviceStateProperties);
+  properties->type = private_api::ParseNetworkType(type);
+  properties->state = state;
+  if (device && state == private_api::DEVICE_STATE_TYPE_ENABLED)
+    properties->scanning.reset(new bool(device->scanning()));
+  device_state_list->push_back(properties.Pass());
+}
+
 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::DeviceStateList>
+NetworkingPrivateChromeOS::GetDeviceStateList() {
+  std::set<std::string> technologies_found;
+  NetworkStateHandler::DeviceStateList devices;
+  NetworkHandler::Get()->network_state_handler()->GetDeviceList(&devices);
+
+  scoped_ptr<DeviceStateList> device_state_list(new DeviceStateList);
+  for (const DeviceState* device : devices) {
+    std::string onc_type =
+        chromeos::network_util::TranslateShillTypeToONC(device->type());
+    AppendDeviceState(onc_type, device, device_state_list.get());
+    technologies_found.insert(onc_type);
+  }
+
+  // For any technologies that we do not have a DeviceState entry for, append
+  // an entry if the technolog is available.
+  const char* technology_types[] = {::onc::network_type::kEthernet,

[pneubeck (no reviews), 2015/04/09 09:41:22]

NetworkTypePattern is copyable, so you should be able to avoid the
  NetworkTypePattern -> ONC -> NetworkTypePattern
roundtrip by using NetworkTypePattern instead of const char* in this function
then only translate from NetworkTypePattern -> ONC in AppendDeviceState.

[stevenjb, 2015/04/09 16:20:25]

I don't follow. In line 390 we do shill -> ONC, here we just use ONC. In
AppendDeviceState we need both ONC and Pattern. I think this is simplest.

+                                    ::onc::network_type::kWiFi,
+                                    ::onc::network_type::kWimax,
+                                    ::onc::network_type::kCellular};
+  for (size_t i = 0; i < arraysize(technology_types); ++i) {

[pneubeck (no reviews), 2015/04/09 09:41:22]

for (const char* technology : technology_types) {
}

[stevenjb, 2015/04/09 16:20:25]

Huh, I didn't know that worked with arrays. Done.

+    std::string technology(technology_types[i]);
+    if (technologies_found.count(technology) > 0)

[pneubeck (no reviews), 2015/04/09 09:41:22]

from stl_util.h

ContainsValue(technologies_found, technology)

[stevenjb, 2015/04/09 16:20:25]

Done.

+      continue;
+    AppendDeviceState(technology, nullptr /* device */,
+                      device_state_list.get());
+  }
+  return device_state_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