Implement OnGetNetworks for net.mojom

components/arc/net/arc_net_host_impl.cc

Index: components/arc/net/arc_net_host_impl.cc
diff --git a/components/arc/net/arc_net_host_impl.cc b/components/arc/net/arc_net_host_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..36edf424b61cf90939f31953870201eb742c944a
--- /dev/null
+++ b/components/arc/net/arc_net_host_impl.cc
@@ -0,0 +1,109 @@
+// 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 <vector>
+
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/time/time.h"
+#include "chromeos/network/network_util.h"
+#include "chromeos/network/onc/onc_utils.h"
+#include "components/arc/arc_bridge_service.h"
+#include "components/onc/onc_constants.h"
+#include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
+
+namespace {
+
+const int kGetNetworksListLimit = 100;
+
+}  // namespace
+
+namespace arc {
+
+ArcNetHostImpl::ArcNetHostImpl(ArcBridgeService* arc_bridge_service)
+    : arc_bridge_service_(arc_bridge_service),
+      origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      binding_(this),
+      weak_factory_(this) {
+  arc_bridge_service->AddObserver(this);
+  if (arc_bridge_service->net_instance())
+    OnNetInstanceReady();
+}
+
+ArcNetHostImpl::~ArcNetHostImpl() {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  arc_bridge_service_->RemoveObserver(this);
+}
+
+void ArcNetHostImpl::OnNetInstanceReady() {
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+
+  NetHostPtr host;
+  binding_.Bind(GetProxy(&host));
+  arc_bridge_service_->net_instance()->Init(std::move(host));
+}
+
+bool ArcNetHostImpl::SendNetworks(int request_id,
+                                        NetworkDataPtr data) {
+  arc_bridge_service_->net_instance()->SendNetworks(request_id,
+                                                    std::move(data));
+  return true;
+}
+
+void ArcNetHostImpl::OnGetNetworks(int request_id,
+                                   bool configured_only,
+                                   bool visible_only) {
+  NetworkDataPtr data = NetworkData::New();
+  data->status = NETWORK_RESULT_SUCCESS;
+
+  // Retrieve list of nearby wifi networks
+  chromeos::NetworkTypePattern network_pattern =
+      chromeos::onc::NetworkTypePatternFromOncType(onc::network_type::kWiFi);
+  scoped_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.
+  for (base::Value* value : *network_properties_list) {
+      WifiConfigurationPtr wc = WifiConfiguration::New();
+
+      base::DictionaryValue* network_dict = nullptr;
+      value->GetAsDictionary(&network_dict);
+      DCHECK(network_dict);
+
+      std::string tmp;
+      network_dict->GetString(onc::network_config::kName, &tmp);
+      wc->ssid = tmp;
+
+      base::DictionaryValue* wifi_dict = nullptr;
+      network_dict->GetDictionary(onc::network_config::kWiFi, &wifi_dict);
+      DCHECK(wifi_dict);
+
+      wifi_dict->GetInteger(onc::wifi::kFrequency, &wc->frequency);
+      wifi_dict->GetInteger(onc::wifi::kSignalStrength,
+                            &wc->signal_strength);
+      wifi_dict->GetString(onc::wifi::kSecurity, &tmp);
+      wc->security = tmp;
+      wifi_dict->GetString(onc::wifi::kBSSID, &tmp);
+      wc->bssid = tmp;
+
+      data->networks.push_back(std::move(wc));
+  }
+
+  SendNetworks(request_id, std::move(data));
+}
+
+scoped_ptr<arc::NetHost> ArcNetHostImpl::CreateNetHost(
+    ArcBridgeService* arc_bridge_service) {
+  return make_scoped_ptr(new ArcNetHostImpl(arc_bridge_service));
+}
+
+}  // namespace arc