Enable chrome.mdns for Chrome Apps

chrome/browser/extensions/api/mdns/mdns_api.cc

 // Copyright 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/extensions/api/mdns/mdns_api.h"
 
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/profiler/scoped_profile.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/common/extensions/api/mdns.h"
+#include "extensions/browser/extension_registry.h"
 
 namespace extensions {
 
 namespace mdns = api::mdns;
 
 namespace {
 
 // Whitelisted mDNS service types.
 const char kCastServiceType[] = "_googlecast._tcp.local";
 const char kPrivetServiceType[] = "_privet._tcp.local";
 const char kTestServiceType[] = "_testing._tcp.local";
 
-bool IsServiceTypeWhitelisted(const std::string& service_type) {
+bool IsServiceTypeWhitelisted(const std::string& service_type,
+                              bool is_extension) {
+  if (!is_extension) {
+    return true;
+  }
   return service_type == kCastServiceType ||
          service_type == kPrivetServiceType ||
          service_type == kTestServiceType;
 }
 
 }  // namespace
 
 MDnsAPI::MDnsAPI(content::BrowserContext* context) : browser_context_(context) {
   DCHECK(browser_context_);
   EventRouter::Get(context)
@@ skipping 66 matching lines @@
     new_service_types.insert(filter_value);
   }
 
   // Find all the added and removed service types since last update.
   std::set<std::string> added_service_types =
       base::STLSetDifference<std::set<std::string> >(
           new_service_types, service_types_);
   std::set<std::string> removed_service_types =
       base::STLSetDifference<std::set<std::string> >(
           service_types_, new_service_types);
+  service_types_ = new_service_types;
 
   // Update the registry.
   DnsSdRegistry* registry = dns_sd_registry();
+
+  const extensions::ExtensionRegistry* ext_registry =

[not at google - send to devlin, 2014/11/17 23:22:15]

This file is in the extensions namespace, no extensions:: necessary.

[Red Daly, 2014/11/19 21:31:50]

Done.

+      extensions::ExtensionRegistry::Get(details.browser_context);
+  if (!ext_registry) {

[not at google - send to devlin, 2014/11/17 23:22:15]

There should always be an ExtensionRegistry, since the extension system has
started (given we're receiving extension function calls).

[Red Daly, 2014/11/19 21:31:50]

Done.

+    return;
+  }
+  const extensions::Extension* extension = ext_registry->GetExtensionById(

[not at google - send to devlin, 2014/11/17 23:22:15]

Why do you want all extensions, rather than just the enabled ones?

[Red Daly, 2014/11/19 21:31:50]

I assumed the extension is enabled if UpdateMDnsListeners is called for it, so
ENABLED and EVERYTHING would be equivalent.  I've changed to ENABLED here
instead of EVERYTHING.

[Red Daly, 2015/01/26 21:55:33]

I checked and this assumption was incorrect: This method is called for disabled
extensions, too.

+      details.extension_id,
+      extensions::ExtensionRegistry::EVERYTHING);
+  if (!extension) {
+    return;
+  }
+
   for (std::set<std::string>::iterator it = added_service_types.begin();
        it != added_service_types.end(); ++it) {
-    if (IsServiceTypeWhitelisted(*it))
+    if (IsServiceTypeWhitelisted(*it, extension->is_extension()))

[not at google - send to devlin, 2014/11/17 23:22:15]

I don't understand what the fact that an Extension is has anything to do with
whether some service type is whitelisted?

[Red Daly, 2014/11/19 21:31:50]

This change is in response to Mark's earlier comment.  We would like to preserve
the existing service whitelist for extensions but allow apps to discover all
types of services.

       registry->RegisterDnsSdListener(*it);
   }
   for (std::set<std::string>::iterator it = removed_service_types.begin();
        it != removed_service_types.end(); ++it) {
-    if (IsServiceTypeWhitelisted(*it))
+    if (IsServiceTypeWhitelisted(*it, extension->is_extension()))
       registry->UnregisterDnsSdListener(*it);
   }
-
-  service_types_ = new_service_types;
 }
 
 void MDnsAPI::OnDnsSdEvent(const std::string& service_type,
                            const DnsSdRegistry::DnsSdServiceList& services) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<linked_ptr<mdns::MDnsService> > args;
   for (DnsSdRegistry::DnsSdServiceList::const_iterator it = services.begin();
        it != services.end(); ++it) {
     linked_ptr<mdns::MDnsService> mdns_service =
@@ skipping 12 matching lines @@
   event->filter_info.SetServiceType(service_type);
 
   VLOG(1) << "Broadcasting OnServiceList event: " << event.get();
 
   // TODO(justinlin): To avoid having listeners without filters getting all
   // events, modify API to have this event require filters.
   extensions::EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 }
 
 }  // namespace extensions