This adds a private extension API to use for simple networking

chrome/browser/chromeos/extensions/networking_private_api.cc

+// Copyright (c) 2013 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 "chrome/browser/chromeos/extensions/networking_private_api.h"
+
+#include "base/bind_helpers.h"
+#include "chrome/browser/extensions/extension_function_registry.h"
+#include "chrome/common/extensions/api/networking_private.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_manager_client.h"
+#include "chromeos/dbus/shill_service_client.h"
+#include "chromeos/network/onc/onc_constants.h"
+#include "chromeos/network/onc/onc_signature.h"
+#include "chromeos/network/onc/onc_translation_tables.h"
+#include "chromeos/network/onc/onc_translator.h"
+#include "dbus/object_path.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+using namespace chromeos;
+namespace api = extensions::api::networking_private;
+
+namespace {
+
+// An error returned when no valid services were found.
+const char kInvalidResponseError[] = "Error.invalidResponse";

[not at google - send to devlin, 2013/02/01 19:09:42]

These errors are printed in the extension's console so it's nice to make them
descriptive. It's also fine to use StringPrintf or something to include some
more info about the error, if you think that'd be useful for debugging
extensions.

+
+// This creates a new ONC dictionary that only contains the information we're
+// interested in passing on to JavaScript.
+scoped_ptr<api::NetworkProperties> CreateFilteredResult(
+    const base::DictionaryValue& properties) {
+  scoped_ptr<base::DictionaryValue> onc_properties(
+      onc::TranslateShillServiceToONCPart(
+          properties,
+          &onc::kNetworkConfigurationSignature));
+
+  // Now we filter it so we only include properties that we care about for this
+  // interface.
+  static const char* const desired_fields[] = {
+      onc::network_config::kWiFi,
+      onc::network_config::kName,
+      onc::network_config::kGUID,
+      onc::network_config::kType,
+      onc::network_config::kConnectionState,
+  };
+
+  scoped_ptr<api::NetworkProperties> filtered_result(
+      new api::NetworkProperties);
+  for (size_t i = 0; i < arraysize(desired_fields); ++i) {
+    base::Value* value;
+    if (onc_properties->Get(desired_fields[i], &value))
+      filtered_result->additional_properties.Set(desired_fields[i],
+                                                 value->DeepCopy());
+  }
+
+  return filtered_result.Pass();
+}
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// NetworkingPrivateGetPropertiesFunction

[not at google - send to devlin, 2013/02/01 19:09:42]

I find these big comments distracting. Of course, I may be in the minority.

+
+NetworkingPrivateGetPropertiesFunction::
+  ~NetworkingPrivateGetPropertiesFunction() {
+}
+
+bool NetworkingPrivateGetPropertiesFunction::RunImpl() {
+  scoped_ptr<api::GetProperties::Params> params =
+      api::GetProperties::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  // TODO(gspencer): Currently we're using the service path as the
+  // |network_guid|. Eventually this should be using the real GUID.
+  DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
+      dbus::ObjectPath(params->network_guid),
+      base::Bind(&NetworkingPrivateGetPropertiesFunction::ResultCallback,
+                 this));
+  return true;
+}
+
+void NetworkingPrivateGetPropertiesFunction::ResultCallback(
+    DBusMethodCallStatus call_status,
+    const base::DictionaryValue& result) {
+  scoped_ptr<api::NetworkProperties> filtered_result(
+      CreateFilteredResult(result));
+  results_ = api::GetProperties::Results::Create(*filtered_result);
+  SendResponse(true);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NetworkingPrivateGetVisibleNetworksFunction::ResultList
+class NetworkingPrivateGetVisibleNetworksFunction::ResultList
+    : public base::RefCounted<ResultList> {
+ public:
+  explicit ResultList(int count);
+
+  int count() const { return count_; }
+  void decrement() { --count_; }
+  scoped_ptr<base::ListValue> GetResults() {
+    return api::GetVisibleNetworks::Results::Create(list_);
+  }
+  void Append(api::NetworkProperties* value);
+
+ private:
+  friend class base::RefCounted<ResultList>;
+  ~ResultList();
+
+  std::vector<linked_ptr<api::NetworkProperties> > list_;
+  int count_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResultList);
+};
+
+NetworkingPrivateGetVisibleNetworksFunction::ResultList::ResultList(int count)
+    : count_(count) {
+}
+
+NetworkingPrivateGetVisibleNetworksFunction::ResultList::~ResultList() {
+}
+
+void NetworkingPrivateGetVisibleNetworksFunction::ResultList::Append(
+    api::NetworkProperties* value) {
+  list_.push_back(linked_ptr<api::NetworkProperties>(value));

[not at google - send to devlin, 2013/02/01 19:09:42]

implement these methods inline?

+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NetworkingPrivateGetVisibleNetworksFunction
+
+NetworkingPrivateGetVisibleNetworksFunction::
+~NetworkingPrivateGetVisibleNetworksFunction() {
+}
+
+bool NetworkingPrivateGetVisibleNetworksFunction::RunImpl() {
+  scoped_ptr<api::GetVisibleNetworks::Params> params =
+      api::GetVisibleNetworks::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  DBusThreadManager::Get()->GetShillManagerClient()->GetProperties(base::Bind(
+      &NetworkingPrivateGetVisibleNetworksFunction::ManagerPropertiesCallback,
+      this,
+      api::GetVisibleNetworks::Params::ToString(params->type)));
+  return true;
+}
+
+// For each of the available services, fire off a request for its properties.
+void NetworkingPrivateGetVisibleNetworksFunction::ManagerPropertiesCallback(
+    const std::string& network_type,
+    DBusMethodCallStatus call_status,
+    const base::DictionaryValue& result) {
+  const base::ListValue* available_services;
+  if (!result.GetList(flimflam::kServicesProperty, &available_services)) {
+    LOG(ERROR)
+        << "ShillManagerClient::GetProperties returned malformed service list.";
+    error_ = kInvalidResponseError;
+    SendResponse(false);
+    return;
+  }
+  scoped_refptr<ResultList> result_list(
+      new ResultList(available_services->GetSize()));
+  // If there just are no services, return an empty list.
+  if (available_services->GetSize() == 0) {
+    results_ = result_list->GetResults();
+    SendResponse(true);
+    return;
+  }
+  for (base::ListValue::const_iterator iter = available_services->begin();
+       iter != available_services->end(); ++iter) {
+    std::string service_path;
+    if (!(*iter)->GetAsString(&service_path)) {
+      LOG(ERROR)
+          << "ShillManagerClient::GetProperties returned malformed service.";
+      result_list->decrement();
+      continue;
+    }
+
+    DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
+        dbus::ObjectPath(service_path),
+        base::Bind(
+            &NetworkingPrivateGetVisibleNetworksFunction::
+                ServicePropertiesCallback,
+            this,
+            service_path,
+            network_type,
+            result_list));
+  }
+  // All of the service paths were malformed, so we fail.
+  if (result_list->count() == 0) {
+    error_ = kInvalidResponseError;
+    SendResponse(false);
+  }
+}
+
+// If this network is of the appropriate type, add it to the results and
+// decrement the count.  If the count hits zero, then send the result.
+void NetworkingPrivateGetVisibleNetworksFunction::ServicePropertiesCallback(
+    const std::string& service_path,
+    const std::string& network_type,
+    scoped_refptr<ResultList> result_list,
+    DBusMethodCallStatus call_status,
+    const base::DictionaryValue& result) {
+  if (call_status == DBUS_METHOD_CALL_SUCCESS) {
+    scoped_ptr<api::NetworkProperties> filtered_result(
+        CreateFilteredResult(result));
+
+    std::string onc_type;
+    if (filtered_result->additional_properties.GetString(
+            onc::network_config::kType, &onc_type) &&
+        (onc_type == network_type ||
+         network_type == onc::network_type::kAllTypes)) {
+          // TODO(gspencer): For now the "guid" we send back is going to look

[not at google - send to devlin, 2013/02/01 19:09:42]

too much indent

+          // remarkably like the service path. Once this code starts using the
+          // NetworkStateHandler instead of Shill directly, we should remove
+          // this line so that we're sending back the actual GUID. The
+          // JavaScript shouldn't care: this ID is opaque to it, and it
+          // shouldn't store it anywhere.
+          filtered_result->additional_properties.SetString(
+              onc::network_config::kGUID, service_path);
+
+          result_list->Append(filtered_result.release());
+    }
+  }
+  // We must decrement the count each time we get a callback, regardless of the
+  // outcome, or we'll never send a response.
+  result_list->decrement();
+  if (result_list->count() == 0) {
+    results_ = result_list->GetResults();
+    SendResponse(true);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NetworkingPrivateRequestConnectFunction
+
+NetworkingPrivateRequestConnectFunction::
+  ~NetworkingPrivateRequestConnectFunction() {
+}
+
+void  NetworkingPrivateRequestConnectFunction::ConnectRequestSuccess() {
+  SendResponse(true);
+}
+
+void NetworkingPrivateRequestConnectFunction::ConnectRequestFailed(
+    const std::string& errorName,
+    const std::string& errorMessage) {
+  error_ = errorName;
+  SendResponse(false);
+}
+
+bool NetworkingPrivateRequestConnectFunction::RunImpl() {
+  scoped_ptr<api::RequestConnect::Params> params =
+      api::RequestConnect::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  // TODO(gspencer): For now, the "guid" we receive from the JavaScript is going
+  // to be the service path.  Fix this so it actually looks up the service path
+  // from the GUID once we're using the NetworkStateHandler.
+  std::string service_path = params->network_guid;
+
+  DBusThreadManager::Get()->GetShillServiceClient()->Connect(
+      dbus::ObjectPath(service_path),
+      base::Bind(
+          &NetworkingPrivateRequestConnectFunction::ConnectRequestSuccess,
+          this),
+      base::Bind(&NetworkingPrivateRequestConnectFunction::ConnectRequestFailed,
+                 this));
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NetworkingPrivateRequestDisconnectFunction
+
+NetworkingPrivateRequestDisconnectFunction::
+  ~NetworkingPrivateRequestDisconnectFunction() {
+}
+
+void  NetworkingPrivateRequestDisconnectFunction::DisconnectRequestSuccess() {
+  SendResponse(true);
+}
+
+void NetworkingPrivateRequestDisconnectFunction::DisconnectRequestFailed(
+    const std::string& errorName,
+    const std::string& errorMessage) {

[not at google - send to devlin, 2013/02/01 19:09:42]

errorName/errorMessage -> error_name/error_message

+  error_ = errorName;
+  SendResponse(false);
+}
+
+bool NetworkingPrivateRequestDisconnectFunction::RunImpl() {
+  scoped_ptr<api::RequestDisconnect::Params> params =
+      api::RequestDisconnect::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  // TODO(gspencer): Currently the |network_guid| parameter is storing the
+  // service path.  Convert to using the actual guid when we start using
+  // the NetworkStateHandler.
+  DBusThreadManager::Get()->GetShillServiceClient()->Connect(
+      dbus::ObjectPath(params->network_guid),
+      base::Bind(
+          &NetworkingPrivateRequestDisconnectFunction::DisconnectRequestSuccess,
+          this),
+      base::Bind(
+          &NetworkingPrivateRequestDisconnectFunction::DisconnectRequestFailed,
+          this));
+  return true;
+}