[MediaRouter] Update JoinRoute behavior to allow non-local routes.

chrome/browser/media/router/media_router_base.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_base.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 
 namespace media_router {
 
 // A MediaRoutesObserver that maintains state about the current set of media
 // routes.
 class MediaRouterBase::InternalMediaRoutesObserver
     : public MediaRoutesObserver {
  public:
   explicit InternalMediaRoutesObserver(MediaRouter* router)
-      : MediaRoutesObserver(router), has_local_route(false) {}
+      : MediaRoutesObserver(router), has_route(false) {}
   ~InternalMediaRoutesObserver() override {}
 
   // MediaRoutesObserver
   void OnRoutesUpdated(
       const std::vector<MediaRoute>& routes,
       const std::vector<MediaRoute::Id>& joinable_route_ids) override {
     off_the_record_route_ids.clear();
-    has_local_route = false;
+    has_route = !routes.empty();

[imcheng, 2016/05/12 00:22:20]

nit: add a TODO here to optimize this to only check for joinable routexs.

As a side note, I wonder if |joinable_route_ids| can be reused for this purpose.
Currently, if there is no MediaSource associated with a routes query, we return
an empty joinable route id list. Perhaps that could be changed to return routes
that are joinable via any means, but I will have go back and check if it will
break the UI.

[mark a. foltz, 2016/05/12 18:38:43]

Done.
Filed crbug.com/611486 and added to TODO.

     for (const auto& route : routes) {
-      has_local_route |= route.is_local();
       if (route.off_the_record())
         off_the_record_route_ids.push_back(route.media_route_id());
     }
   }
 
-  bool has_local_route;
+  bool has_route;
   std::vector<MediaRoute::Id> off_the_record_route_ids;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InternalMediaRoutesObserver);
 };
 
 MediaRouterBase::~MediaRouterBase() {
   CHECK(!internal_routes_observer_);
 }
 
@@ skipping 47 matching lines @@
   if (!callbacks)
     return;
 
   content::PresentationConnectionStateChangeInfo info(
       content::PRESENTATION_CONNECTION_STATE_CLOSED);
   info.close_reason = reason;
   info.message = message;
   callbacks->Notify(info);
 }
 
-bool MediaRouterBase::HasLocalRoute() const {
-  return internal_routes_observer_->has_local_route;
+bool MediaRouterBase::HasJoinableRoute() const {
+  return internal_routes_observer_->has_route;
 }
 
 void MediaRouterBase::Initialize() {
   DCHECK(!initialized_);
   // The observer calls virtual methods on MediaRouter; it must be created
   // outside of the ctor
   internal_routes_observer_.reset(new InternalMediaRoutesObserver(this));
   initialized_ = true;
 }
 
 void MediaRouterBase::OnPresentationConnectionStateCallbackRemoved(
     const MediaRoute::Id& route_id) {
   auto* callbacks = presentation_connection_state_callbacks_.get(route_id);
   if (callbacks && callbacks->empty())
     presentation_connection_state_callbacks_.erase(route_id);
 }
 
 void MediaRouterBase::Shutdown() {
   // The observer calls virtual methods on MediaRouter; it must be destroyed
   // outside of the dtor
   internal_routes_observer_.reset();
 }
 
 }  // namespace media_router