[Local Screen Casting] Show page origin in route details view

This change adds the presentation page origin (www.example.com) to the
route details view for local screen casting. The details view also
shows the page title.

Screenshot:
https://drive.google.com/open?id=1linGuorVH62K9bx83iXTWHBJ8EbEmLRH

Bug: 799265
Change-Id: Ieaeb5feab2b429e9e643df0449b5ee9b082e2512
Reviewed-on: https://chromium-review.googlesource.com/910031
Commit-Queue: Takumi Fujimoto <takumif@chromium.org>
Reviewed-by: mark a. foltz <mfoltz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#536669}

chrome/app/media_router_strings.grdp

@@ -195,9 +195,6 @@
   <message name="IDS_MEDIA_ROUTER_DESTINATION_MISSING" desc="Link to display when no Cast destinations are found which, on click, opens a page to the Chromecast help center explaining possible reasons why none are detected.">
     No Cast destinations found. Need help?
   </message>
-  <message name="IDS_MEDIA_ROUTER_WIRED_DISPLAY_SINK_NAME" desc="Name shown for a wired display that can be used as a Cast destination.">
-    Display <ph name="DISPLAY_ID">$1<ex>1</ex></ph>
-  </message>
 
   <!-- Sink Search -->
   <message name="IDS_MEDIA_ROUTER_SEARCH_LABEL" desc="Label for search input in sink list.">
@@ -212,4 +209,12 @@
 video files, instead of all files.">
     Audio/Video
   </message>
+
+  <!-- Wired Display Media Route Provider -->
+  <message name="IDS_MEDIA_ROUTER_WIRED_DISPLAY_ROUTE_DESCRIPTION" desc="Description shown to indicate that a website is being presented to another display.">
+    Presenting (<ph name="PAGE_ORIGIN">$1<ex>example.com</ex></ph>)
+  </message>
+  <message name="IDS_MEDIA_ROUTER_WIRED_DISPLAY_SINK_NAME" desc="Name shown for a wired display that can be used as a Cast destination.">
+    Display <ph name="DISPLAY_ID">$1<ex>1</ex></ph>
+  </message>
 </grit-part>

chrome/browser/media/router/providers/wired_display/wired_display_media_route_provider.cc

@@ -10,8 +10,8 @@
 #include <vector>
 
 #include "base/i18n/number_formatting.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/media/router/media_router_feature.h"
-#include "chrome/browser/media/router/providers/wired_display/wired_display_presentation_receiver.h"
 #include "chrome/browser/media/router/providers/wired_display/wired_display_presentation_receiver_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/media_router/media_source_helper.h"
@@ -75,6 +75,14 @@ std::string WiredDisplayMediaRouteProvider::GetSinkIdForDisplay(
   return "wired_display_" + std::to_string(display.id());
 }
 
+// static
+std::string WiredDisplayMediaRouteProvider::GetRouteDescription(
+    const std::string& media_source) {
+  return l10n_util::GetStringFUTF8(
+      IDS_MEDIA_ROUTER_WIRED_DISPLAY_ROUTE_DESCRIPTION,
+      base::UTF8ToUTF16(url::Origin::Create(GURL(media_source)).host()));
+}
+
 WiredDisplayMediaRouteProvider::WiredDisplayMediaRouteProvider(
     mojom::MediaRouteProviderRequest request,
     mojom::MediaRouterPtr media_router,
@@ -113,15 +121,17 @@ void WiredDisplayMediaRouteProvider::CreateRoute(
   TerminatePresentationsOnDisplay(*display);
   // Use |presentation_id| as the route ID. This MRP creates only one route per
   // presentation ID.
-  MediaRoute route(presentation_id, MediaSource(media_source), sink_id, "",
-                   true, true);
+  MediaRoute route(presentation_id, MediaSource(media_source), sink_id,
+                   GetRouteDescription(media_source), true, true);
   route.set_local_presentation(true);
   route.set_incognito(profile_->IsOffTheRecord());
-  Presentation presentation =
-      CreatePresentation(presentation_id, *display, route);
+  route.set_controller_type(RouteControllerType::kGeneric);
 
-  presentation.receiver->Start(presentation_id, GURL(media_source));
-  presentations_.emplace(presentation_id, std::move(presentation));
+  Presentation& presentation =
+      presentations_.emplace(presentation_id, route).first->second;
+  presentation.set_receiver(
+      CreatePresentationReceiver(presentation_id, &presentation, *display));
+  presentation.receiver()->Start(presentation_id, GURL(media_source));
   std::move(callback).Run(route, base::nullopt, RouteRequestResult::OK);
   NotifyRouteObservers();
 }
@@ -167,7 +177,7 @@ void WiredDisplayMediaRouteProvider::TerminateRoute(
 
   // The presentation will be removed from |presentations_| in the termination
   // callback of its receiver.
-  it->second.receiver->Terminate();
+  it->second.receiver()->Terminate();
   std::move(callback).Run(base::nullopt, RouteRequestResult::OK);
 }
 
@@ -206,7 +216,7 @@ void WiredDisplayMediaRouteProvider::StartObservingMediaRoutes(
   route_queries_.insert(media_source);
   std::vector<MediaRoute> route_list;
   for (const auto& presentation : presentations_)
-    route_list.push_back(presentation.second.route);
+    route_list.push_back(presentation.second.route());
   media_router_->OnRoutesUpdated(kProviderId, route_list, media_source, {});
 }
 
@@ -259,7 +269,14 @@ void WiredDisplayMediaRouteProvider::CreateMediaRouteController(
     mojom::MediaStatusObserverPtr observer,
     CreateMediaRouteControllerCallback callback) {
   // Local screens do not support media controls.
-  std::move(callback).Run(false);
+  auto it = presentations_.find(route_id);
+  if (it == presentations_.end()) {
+    std::move(callback).Run(false);
+    return;
+  }
+  it->second.SetMojoConnections(std::move(media_controller),
+                                std::move(observer));
+  std::move(callback).Run(true);
 }
 
 void WiredDisplayMediaRouteProvider::OnDidProcessDisplayChanges() {
@@ -293,19 +310,47 @@ Display WiredDisplayMediaRouteProvider::GetPrimaryDisplay() const {
 }
 
 WiredDisplayMediaRouteProvider::Presentation::Presentation(
-    const MediaRoute& route,
-    std::unique_ptr<WiredDisplayPresentationReceiver> receiver)
-    : route(route), receiver(std::move(receiver)) {}
+    const MediaRoute& route)
+    : route_(route) {}
 
 WiredDisplayMediaRouteProvider::Presentation::Presentation(
     Presentation&& other) = default;
 
 WiredDisplayMediaRouteProvider::Presentation::~Presentation() = default;
 
+void WiredDisplayMediaRouteProvider::Presentation::UpdatePresentationTitle(
+    const std::string& title) {
+  if (status_.title == title)
+    return;
+
+  status_.title = title;
+  if (media_status_observer_)
+    media_status_observer_->OnMediaStatusUpdated(status_);
+}
+
+void WiredDisplayMediaRouteProvider::Presentation::SetMojoConnections(
+    mojom::MediaControllerRequest media_controller,
+    mojom::MediaStatusObserverPtr observer) {
+  // This provider does not support media controls, so we do not bind
+  // |media_controller| to a controller implementation.
+  media_controller_request_ = std::move(media_controller);
+
+  media_status_observer_ = std::move(observer);
+  media_status_observer_->OnMediaStatusUpdated(status_);
+  media_status_observer_.set_connection_error_handler(base::BindOnce(
+      &WiredDisplayMediaRouteProvider::Presentation::ResetMojoConnections,
+      base::Unretained(this)));
+}
+
+void WiredDisplayMediaRouteProvider::Presentation::ResetMojoConnections() {
+  media_controller_request_ = nullptr;
+  media_status_observer_ = nullptr;
+}
+
 void WiredDisplayMediaRouteProvider::NotifyRouteObservers() const {
   std::vector<MediaRoute> route_list;
   for (const auto& presentation : presentations_)
-    route_list.push_back(presentation.second.route);
+    route_list.push_back(presentation.second.route());
   for (const auto& route_query : route_queries_)
     media_router_->OnRoutesUpdated(kProviderId, route_list, route_query, {});
 }
@@ -368,36 +413,18 @@ void WiredDisplayMediaRouteProvider::RemovePresentationById(
   NotifyRouteObservers();
 }
 
-void WiredDisplayMediaRouteProvider::UpdateRouteDescription(
+std::unique_ptr<WiredDisplayPresentationReceiver>
+WiredDisplayMediaRouteProvider::CreatePresentationReceiver(
     const std::string& presentation_id,
-    const std::string& title) {
-  auto it = presentations_.find(presentation_id);
-  if (it == presentations_.end())
-    return;
-
-  MediaRoute& route = it->second.route;
-  if (title == route.description())
-    return;
-
-  route.set_description(title);
-  NotifyRouteObservers();
-}
-
-WiredDisplayMediaRouteProvider::Presentation
-WiredDisplayMediaRouteProvider::CreatePresentation(
-    const std::string& presentation_id,
-    const Display& display,
-    const MediaRoute& route) {
-  std::unique_ptr<WiredDisplayPresentationReceiver> receiver =
-      WiredDisplayPresentationReceiverFactory::Create(
-          profile_, display.bounds(),
-          base::BindOnce(
-              &WiredDisplayMediaRouteProvider::RemovePresentationById,
-              base::Unretained(this), presentation_id),
-          base::BindRepeating(
-              &WiredDisplayMediaRouteProvider::UpdateRouteDescription,
-              base::Unretained(this), presentation_id));
-  return Presentation(route, std::move(receiver));
+    Presentation* presentation,
+    const Display& display) {
+  return WiredDisplayPresentationReceiverFactory::Create(
+      profile_, display.bounds(),
+      base::BindOnce(&WiredDisplayMediaRouteProvider::RemovePresentationById,
+                     base::Unretained(this), presentation_id),
+      base::BindRepeating(&WiredDisplayMediaRouteProvider::Presentation::
+                              UpdatePresentationTitle,
+                          base::Unretained(presentation)));
 }
 
 void WiredDisplayMediaRouteProvider::TerminatePresentationsOnDisplay(
@@ -407,9 +434,9 @@ void WiredDisplayMediaRouteProvider::TerminatePresentationsOnDisplay(
   // |presentations_| because that might invoke a callback to delete the
   // presentation from |presentations_|.
   for (const auto& presentation : presentations_) {
-    if (presentation.second.route.media_sink_id() ==
+    if (presentation.second.route().media_sink_id() ==
         GetSinkIdForDisplay(display)) {
-      presentations_to_terminate.push_back(presentation.second.receiver.get());
+      presentations_to_terminate.push_back(presentation.second.receiver());
     }
   }
   for (auto* presentation_to_terminate : presentations_to_terminate)

chrome/browser/media/router/providers/wired_display/wired_display_media_route_provider.h

@@ -15,7 +15,9 @@
 #include "base/containers/flat_map.h"
 #include "base/containers/flat_set.h"
 #include "chrome/browser/media/router/discovery/media_sink_discovery_metrics.h"
+#include "chrome/browser/media/router/providers/wired_display/wired_display_presentation_receiver.h"
 #include "chrome/common/media_router/media_route_provider_helper.h"
+#include "chrome/common/media_router/media_status.h"
 #include "chrome/common/media_router/mojo/media_router.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "ui/display/display.h"
@@ -37,6 +39,8 @@ class WiredDisplayMediaRouteProvider : public mojom::MediaRouteProvider,
 
   static std::string GetSinkIdForDisplay(const display::Display& display);
 
+  static std::string GetRouteDescription(const std::string& media_source);
+
   WiredDisplayMediaRouteProvider(mojom::MediaRouteProviderRequest request,
                                  mojom::MediaRouterPtr media_router,
                                  Profile* profile);
@@ -110,17 +114,45 @@ class WiredDisplayMediaRouteProvider : public mojom::MediaRouteProvider,
   virtual display::Display GetPrimaryDisplay() const;
 
  private:
-  struct Presentation {
+  class Presentation {
    public:
-    Presentation(const MediaRoute& route,
-                 std::unique_ptr<WiredDisplayPresentationReceiver> receiver);
+    explicit Presentation(const MediaRoute& route);
     Presentation(Presentation&& other);
     ~Presentation();
 
-    MediaRoute route;
-    std::unique_ptr<WiredDisplayPresentationReceiver> receiver;
+    // Updates the title for the presentation page, and notifies media status
+    // observers if the title changed.
+    void UpdatePresentationTitle(const std::string& title);
+
+    void SetMojoConnections(mojom::MediaControllerRequest media_controller,
+                            mojom::MediaStatusObserverPtr observer);
+
+    // Resets the Mojo connections to media controller and status observer.
+    void ResetMojoConnections();
+
+    const MediaRoute& route() const { return route_; }
+
+    WiredDisplayPresentationReceiver* receiver() const {
+      return receiver_.get();
+    }
+
+    void set_receiver(
+        std::unique_ptr<WiredDisplayPresentationReceiver> receiver) {
+      receiver_ = std::move(receiver);
+    }
 
    private:
+    MediaRoute route_;
+    std::unique_ptr<WiredDisplayPresentationReceiver> receiver_;
+    MediaStatus status_;
+
+    // |media_controller_request| is retained but not used.
+    mojom::MediaControllerRequest media_controller_request_;
+
+    // |media_status_observer|, when set, gets notified whenever |status|
+    // changes.
+    mojom::MediaStatusObserverPtr media_status_observer_;
+
     DISALLOW_COPY_AND_ASSIGN(Presentation);
   };
 
@@ -137,14 +169,10 @@ class WiredDisplayMediaRouteProvider : public mojom::MediaRouteProvider,
   // observers.
   void RemovePresentationById(const std::string& presentation_id);
 
-  // Updates the description for the route associated with |presentation_id|,
-  // and notifies route observers if the description changed.
-  void UpdateRouteDescription(const std::string& presentation_id,
-                              const std::string& title);
-
-  Presentation CreatePresentation(const std::string& presentation_id,
-                                  const display::Display& display,
-                                  const MediaRoute& media_route);
+  std::unique_ptr<WiredDisplayPresentationReceiver> CreatePresentationReceiver(
+      const std::string& presentation_id,
+      Presentation* presentation,
+      const display::Display& display);
 
   // Terminates all presentation receivers on |display|.
   void TerminatePresentationsOnDisplay(const display::Display& display);

chrome/browser/media/router/providers/wired_display/wired_display_media_route_provider_unittest.cc

@@ -7,6 +7,7 @@
 #include "base/run_loop.h"
 #include "chrome/browser/media/router/providers/wired_display/wired_display_presentation_receiver.h"
 #include "chrome/browser/media/router/providers/wired_display/wired_display_presentation_receiver_factory.h"
+#include "chrome/browser/media/router/test/media_router_mojo_test.h"
 #include "chrome/browser/media/router/test/mock_mojo_media_router.h"
 #include "chrome/common/media_router/mojo/media_router.mojom.h"
 #include "chrome/test/base/testing_profile.h"
@@ -310,6 +311,7 @@ TEST_F(WiredDisplayMediaRouteProviderTest, CreateAndTerminateRoute) {
           Invoke([&presentation_id](const base::Optional<MediaRoute>& route) {
             EXPECT_TRUE(route.has_value());
             EXPECT_EQ(route->media_route_id(), presentation_id);
+            EXPECT_EQ(route->description(), "Presenting (www.example.com)");
           })));
   EXPECT_CALL(router_,
               OnRoutesUpdated(kProviderId, _, kPresentationSource, IsEmpty()))
@@ -317,6 +319,7 @@ TEST_F(WiredDisplayMediaRouteProviderTest, CreateAndTerminateRoute) {
           Invoke([&presentation_id](const std::vector<MediaRoute>& routes) {
             EXPECT_EQ(routes.size(), 1u);
             EXPECT_EQ(routes[0].media_route_id(), presentation_id);
+            EXPECT_EQ(routes[0].description(), "Presenting (www.example.com)");
           })));
   EXPECT_CALL(*receiver_creator_.receiver(),
               Start(presentation_id, GURL(kPresentationSource)));
@@ -327,16 +330,6 @@ TEST_F(WiredDisplayMediaRouteProviderTest, CreateAndTerminateRoute) {
       base::BindOnce(&MockCallback::CreateRoute, base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
 
-  const std::string new_description = "New Page Description";
-  EXPECT_CALL(router_, OnRoutesUpdated(kProviderId, _, kPresentationSource, _))
-      .WillOnce(WithArg<1>(
-          Invoke([&new_description](const std::vector<MediaRoute>& routes) {
-            EXPECT_EQ(routes.size(), 1u);
-            EXPECT_EQ(routes[0].description(), new_description);
-          })));
-  receiver_creator_.receiver()->RunTitleChangeCallback(new_description);
-  base::RunLoop().RunUntilIdle();
-
   // Terminate the route.
   EXPECT_CALL(callback, TerminateRoute(base::Optional<std::string>(),
                                        RouteRequestResult::OK));
@@ -353,4 +346,37 @@ TEST_F(WiredDisplayMediaRouteProviderTest, CreateAndTerminateRoute) {
   receiver_creator_.receiver()->RunTerminationCallback();
 }
 
+TEST_F(WiredDisplayMediaRouteProviderTest, SendMediaStatusUpdate) {
+  const std::string presentation_id = "presentationId";
+  const std::string page_title = "Presentation Page Title";
+  MockCallback callback;
+
+  provider_->set_all_displays({secondary_display1_, primary_display_});
+  provider_pointer_->StartObservingMediaRoutes(kPresentationSource);
+  base::RunLoop().RunUntilIdle();
+
+  // Create a route for |presentation_id|.
+  provider_pointer_->CreateRoute(
+      kPresentationSource, GetSinkId(secondary_display1_), presentation_id,
+      url::Origin::Create(GURL(kPresentationSource)), 0,
+      base::TimeDelta::FromSeconds(100), false,
+      base::BindOnce(&MockCallback::CreateRoute, base::Unretained(&callback)));
+  base::RunLoop().RunUntilIdle();
+
+  mojom::MediaControllerPtr media_controller_ptr;
+  mojom::MediaStatusObserverPtr status_observer_ptr;
+  MockMediaStatusObserver status_observer(
+      mojo::MakeRequest(&status_observer_ptr));
+  provider_pointer_->CreateMediaRouteController(
+      presentation_id, mojo::MakeRequest(&media_controller_ptr),
+      std::move(status_observer_ptr), base::BindOnce([](bool success) {}));
+
+  EXPECT_CALL(status_observer, OnMediaStatusUpdated(_))
+      .WillOnce(Invoke([&page_title](const MediaStatus& status) {
+        EXPECT_EQ(status.title, page_title);
+      }));
+  receiver_creator_.receiver()->RunTitleChangeCallback(page_title);
+  base::RunLoop().RunUntilIdle();
+}
+
 }  // namespace media_router

chrome/browser/media/router/test/media_router_mojo_test.cc

@@ -130,6 +130,12 @@ void MockEventPageRequestManager::RunOrDefer(
   RunOrDeferInternal(request, wake_reason);
 }
 
+MockMediaStatusObserver::MockMediaStatusObserver(
+    mojom::MediaStatusObserverRequest request)
+    : binding_(this, std::move(request)) {}
+
+MockMediaStatusObserver::~MockMediaStatusObserver() {}
+
 MockMediaController::MockMediaController()
     : binding_(this), hangouts_binding_(this) {}
 

chrome/browser/media/router/test/media_router_mojo_test.h

@@ -5,7 +5,10 @@
 #ifndef CHROME_BROWSER_MEDIA_ROUTER_TEST_MEDIA_ROUTER_MOJO_TEST_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_TEST_MEDIA_ROUTER_MOJO_TEST_H_
 
+#include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -213,11 +216,22 @@ class MockEventPageRequestManager : public EventPageRequestManager {
   DISALLOW_COPY_AND_ASSIGN(MockEventPageRequestManager);
 };
 
+class MockMediaStatusObserver : public mojom::MediaStatusObserver {
+ public:
+  explicit MockMediaStatusObserver(mojom::MediaStatusObserverRequest request);
+  ~MockMediaStatusObserver() override;
+
+  MOCK_METHOD1(OnMediaStatusUpdated, void(const MediaStatus& status));
+
+ private:
+  mojo::Binding<mojom::MediaStatusObserver> binding_;
+};
+
 class MockMediaController : public mojom::MediaController,
                             mojom::HangoutsMediaRouteController {
  public:
   MockMediaController();
-  ~MockMediaController();
+  ~MockMediaController() override;
 
   void Bind(mojom::MediaControllerRequest request);
   mojom::MediaControllerPtr BindInterfacePtr();