[Media Router] Conditionally enable mDNS on Windows.

chrome/browser/media/router/media_router_mojo_impl.cc

 // 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 "chrome/browser/media/router/media_router_mojo_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issues_observer.h"
+#include "chrome/browser/media/router/media_route_provider_util_win.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_router_metrics.h"
 #include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "extensions/browser/process_manager.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
@@ skipping 46 matching lines @@
 MediaRouterMojoImpl::MediaSinksQuery::~MediaSinksQuery() = default;
 
 MediaRouterMojoImpl::MediaRouterMojoImpl(
     extensions::EventPageTracker* event_page_tracker)
     : event_page_tracker_(event_page_tracker),
       instance_id_(base::GenerateGUID()),
       availability_(interfaces::MediaRouter::SinkAvailability::UNAVAILABLE),
       current_wake_reason_(MediaRouteProviderWakeReason::TOTAL_COUNT),
       weak_factory_(this) {
   DCHECK(event_page_tracker_);
+#if defined(OS_WIN)
+  CanFirewallUseLocalPorts(
+      base::Bind(&MediaRouterMojoImpl::EnableMdnsFromFirewallCheck,
+                 weak_factory_.GetWeakPtr()));
+#endif
 }
 
 MediaRouterMojoImpl::~MediaRouterMojoImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 // static
 void MediaRouterMojoImpl::BindToRequest(
     const extensions::Extension* extension,
     content::BrowserContext* context,
@@ skipping 39 matching lines @@
     AttemptWakeEventPage();
   }
 }
 
 void MediaRouterMojoImpl::RegisterMediaRouteProvider(
     interfaces::MediaRouteProviderPtr media_route_provider_ptr,
     const interfaces::MediaRouter::RegisterMediaRouteProviderCallback&
         callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+#if defined(OS_WIN)
+  // The MRPM may have been upgraded or otherwise reload such that we could be
+  // seeing an MRPM that doesn't know mDNS is enabled, even if we've told a
+  // previously registered MRPM it should be enabled. Furthermore, there may be
+  // a pending request to enable mDNS, so don't clear this flag after
+  // ExecutePendingRequests().
+  is_mdns_enabled_ = false;
+#endif
   if (event_page_tracker_->IsEventPageSuspended(
           media_route_provider_extension_id_)) {
     DVLOG_WITH_INSTANCE(1)
         << "RegisterMediaRouteProvider was called while extension is "
            "suspended.";
     media_route_provider_.reset();
     SetWakeReason(MediaRouteProviderWakeReason::REGISTER_MEDIA_ROUTE_PROVIDER);
     AttemptWakeEventPage();
     return;
   }
 
   media_route_provider_ = std::move(media_route_provider_ptr);
   media_route_provider_.set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
   callback.Run(instance_id_);
   ExecutePendingRequests();
   wakeup_attempt_count_ = 0;
+#if defined(OS_WIN)
+  // The MRPM extension already turns on mDNS discovery for platforms other than
+  // Windows. It only relies on this signalling from MR on Windows to avoid
+  // triggering a firewall prompt out of the context of MR from the user's
+  // perspective. This particular call reminds the extension to enable mDNS
+  // discovery when it wakes up, has been upgraded, etc.
+  if (should_enable_mdns_discovery_) {
+    DoEnsureMdnsDiscoveryEnabled();
+  }
+#endif
 }
 
 void MediaRouterMojoImpl::OnIssue(const interfaces::IssuePtr issue) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG_WITH_INSTANCE(1) << "OnIssue " << issue->title;
   const Issue& issue_converted = issue.To<Issue>();
   issue_manager_.AddIssue(issue_converted);
 }
 
 void MediaRouterMojoImpl::OnSinksReceived(
@@ skipping 225 matching lines @@
 void MediaRouterMojoImpl::AddIssue(const Issue& issue) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.AddIssue(issue);
 }
 
 void MediaRouterMojoImpl::ClearIssue(const Issue::Id& issue_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.ClearIssue(issue_id);
 }
 
+void MediaRouterMojoImpl::OnUserInteraction() {
+#if defined(OS_WIN)
+  EnsureMdnsDiscoveryEnabled();
+#endif
+}
+
 bool MediaRouterMojoImpl::RegisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Create an observer list for the media source and add |observer|
   // to it. Fail if |observer| is already registered.
   const std::string& source_id = observer->source().id();
   auto* sinks_query = sinks_queries_.get(source_id);
   bool new_query = false;
   if (!sinks_query) {
@@ skipping 401 matching lines @@
   if (!routes_query || !routes_query->is_active ||
       routes_query->observers.might_have_observers()) {
     return;
   }
 
   DVLOG_WITH_INSTANCE(1) << "MRPM.StopObservingMediaRoutes: " << source_id;
   media_route_provider_->StopObservingMediaRoutes(source_id);
   routes_queries_.erase(source_id);
 }
 
+void MediaRouterMojoImpl::EnsureMdnsDiscoveryEnabled() {

[mark a. foltz, 2016/03/29 00:48:20]

This code should only be called on Windows, so I have a preference to surround
it with #if defined(OS_WIN).  To make it easier to read, put this method
alongside EnableMdnsFromFirewallCheck.

+  if (is_mdns_enabled_)
+    return;
+
+  SetWakeReason(MediaRouteProviderWakeReason::ENABLE_MDNS_DISCOVERY);
+  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoEnsureMdnsDiscoveryEnabled,
+                        base::Unretained(this)));
+  should_enable_mdns_discovery_ = true;
+}
+
+void MediaRouterMojoImpl::DoEnsureMdnsDiscoveryEnabled() {
+  DVLOG_WITH_INSTANCE(1) << "DoEnsureMdnsDiscoveryEnabled";
+  if (!is_mdns_enabled_) {
+    media_route_provider_->EnableMdnsDiscovery();
+    is_mdns_enabled_ = true;
+  }
+}
+
 void MediaRouterMojoImpl::EnqueueTask(const base::Closure& closure) {
   pending_requests_.push_back(closure);
   if (pending_requests_.size() > kMaxPendingRequests) {
     DLOG_WITH_INSTANCE(ERROR) << "Reached max queue size. Dropping oldest "
                               << "request.";
     pending_requests_.pop_front();
   }
   DVLOG_WITH_INSTANCE(2) << "EnqueueTask (queue-length="
                          << pending_requests_.size() << ")";
 }
@@ skipping 87 matching lines @@
   DCHECK(reason != MediaRouteProviderWakeReason::TOTAL_COUNT);
   if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
     current_wake_reason_ = reason;
 }
 
 void MediaRouterMojoImpl::ClearWakeReason() {
   DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
   current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
 }
 
+void MediaRouterMojoImpl::EnableMdnsFromFirewallCheck(
+    bool firewall_can_use_local_ports) {
+  if (firewall_can_use_local_ports)
+    EnsureMdnsDiscoveryEnabled();
+}
+
 }  // namespace media_router