Add DiscoveryNetworkMonitor implementation

chrome/browser/extensions/api/dial/dial_api.cc

 // Copyright (c) 2012 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/extensions/api/dial/dial_api.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 28 matching lines @@
 
 // The maximum number of devices retained at once in the registry.
 const size_t kDialMaxDevices = 256;
 
 }  // namespace
 
 DialAPI::DialAPI(Profile* profile)
     : RefcountedKeyedService(
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)),
       profile_(profile) {
-  EventRouter::Get(profile)->RegisterObserver(
-      this, api::dial::OnDeviceList::kEventName);
+  auto* event_router = EventRouter::Get(profile);
+  event_router->RegisterObserver(this, api::dial::OnDeviceList::kEventName);
+  event_router->RegisterObserver(this,
+                                 api::dial::OnNetworkIdChanged::kEventName);
 }
 
 DialAPI::~DialAPI() {}
 
 DialRegistry* DialAPI::dial_registry() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!dial_registry_.get()) {
     dial_registry_.reset(new DialRegistry(
         TimeDelta::FromSeconds(kDialRefreshIntervalSecs),
         TimeDelta::FromSeconds(kDialExpirationSecs), kDialMaxDevices));
     dial_registry_->RegisterObserver(this);
     if (test_device_data_) {
       dial_registry_->AddDeviceForTest(*test_device_data_);
     }
   }
   return dial_registry_.get();
 }
 
 void DialAPI::OnListenerAdded(const EventListenerInfo& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&DialAPI::NotifyListenerAddedOnIOThread, this));
+  if (details.event_name == api::dial::OnNetworkIdChanged::kEventName) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&DialAPI::NetworkIdListenerAddedOnIOThread, this));
+  } else {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&DialAPI::NotifyListenerAddedOnIOThread, this));
+  }
 }
 
 void DialAPI::OnListenerRemoved(const EventListenerInfo& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&DialAPI::NotifyListenerRemovedOnIOThread, this));
+  if (details.event_name == api::dial::OnNetworkIdChanged::kEventName) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&DialAPI::NetworkIdListenerRemovedOnIOThread, this));

[mark a. foltz, 2017/04/26 22:25:11]

What if multiple event listeners are added?  Do you need to keep a counter?

[btolsch, 2017/05/03 22:03:08]

From testing and looking at the code it wasn't clear that would happen.  After
looking at other EventRouter::Observer implementations though, I guess it can. 
I added a counter here to check for the first and last listener.

+  } else {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&DialAPI::NotifyListenerRemovedOnIOThread, this));
+  }
+}
+
+void DialAPI::NetworkIdListenerAddedOnIOThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  VLOG(2) << "Network Id event listener added.";
+  DiscoveryNetworkMonitor::GetInstance()->AddObserver(this);
+}
+
+void DialAPI::NetworkIdListenerRemovedOnIOThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  VLOG(2) << "Network Id event listener removed.";
+  DiscoveryNetworkMonitor::GetInstance()->RemoveObserver(this);
 }
 
 void DialAPI::NotifyListenerAddedOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(2) << "DIAL device event listener added.";
   dial_registry()->OnListenerAdded();
 }
 
 void DialAPI::NotifyListenerRemovedOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(2) << "DIAL device event listener removed";
   dial_registry()->OnListenerRemoved();
 }
 
 void DialAPI::OnDialDeviceEvent(const DialRegistry::DeviceList& devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&DialAPI::SendEventOnUIThread, this, devices));
 }
 
 void DialAPI::OnDialError(const DialRegistry::DialErrorCode code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&DialAPI::SendErrorOnUIThread, this, code));
 }
 
+void DialAPI::OnNetworksChanged(const DiscoveryNetworkMonitor& manager) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&DialAPI::SendNetworkIdChangedOnUIThread,
+                                     this, manager.GetNetworkId()));
+}
+
 void DialAPI::SendEventOnUIThread(const DialRegistry::DeviceList& devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::vector<api::dial::DialDevice> args;
   for (const DialDeviceData& device : devices) {
     api::dial::DialDevice api_device;
     device.FillDialDevice(&api_device);
     args.push_back(std::move(api_device));
   }
   std::unique_ptr<base::ListValue> results =
@@ skipping 30 matching lines @@
   }
 
   std::unique_ptr<base::ListValue> results =
       api::dial::OnError::Create(dial_error);
   std::unique_ptr<Event> event(new Event(events::DIAL_ON_ERROR,
                                          api::dial::OnError::kEventName,
                                          std::move(results)));
   EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
 }
 
+void DialAPI::SendNetworkIdChangedOnUIThread(const std::string& network_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  std::unique_ptr<base::ListValue> results =
+      api::dial::OnNetworkIdChanged::Create(network_id);
+  std::unique_ptr<Event> event(
+      new Event(events::DIAL_ON_NETWORK_ID_CHANGED,
+                api::dial::OnNetworkIdChanged::kEventName, std::move(results)));
+  EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
+}
+
 void DialAPI::ShutdownOnUIThread() {}
 
 void DialAPI::SetDeviceForTest(
     const api::dial::DialDeviceData& device_data,
     const api::dial::DialDeviceDescriptionData& device_description) {
   test_device_data_ = base::MakeUnique<DialDeviceData>(device_data);
   test_device_description_ =
       base::MakeUnique<DialDeviceDescriptionData>(device_description);
 }
 
@@ skipping 87 matching lines @@
 
 void DialFetchDeviceDescriptionFunction::OnFetchError(
     const std::string& message) {
   // Destroy the DeviceDescriptionFetcher since it still contains a reference
   // to |this| in its un-invoked callback.
   device_description_fetcher_.reset();
   SetError(message);
   SendResponse(false);
 }
 
+DialGetNetworkIdFunction::DialGetNetworkIdFunction() {}
+
+DialGetNetworkIdFunction::~DialGetNetworkIdFunction() {}
+
+bool DialGetNetworkIdFunction::RunAsync() {
+  auto* network_monitor = DiscoveryNetworkMonitor::GetInstance();
+  // If we are the first to call the DiscoveryNetworkMonitor, it will have no
+  // network state.  Force a refresh to be sure the network ID is populated.
+  network_monitor->Refresh(
+      base::Bind(&DialGetNetworkIdFunction::NetworkInfoReadyCallback, this));
+  return true;
+}
+
+void DialGetNetworkIdFunction::NetworkInfoReadyCallback() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&DialGetNetworkIdFunction::GetNetworkIdOnIOThread, this));
+}
+
+void DialGetNetworkIdFunction::GetNetworkIdOnIOThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  const auto* network_monitor = DiscoveryNetworkMonitor::GetInstance();
+  std::string network_id(network_monitor->GetNetworkId());
+
+  SetResult(base::MakeUnique<base::Value>(
+      network_id.size() == 0 ? std::string("unknown") : network_id));

[mark a. foltz, 2017/04/26 22:25:11]

Can the NetworkMonitor return "unknown" in place of the empty string, rather
than translating here?

[btolsch, 2017/05/03 22:03:08]

Yes, it already doesn't return an empty string so this was unnecessary.  Done.

+  SendResponse(true);
+}
+
 }  // namespace extensions