[Media Router] Return NotFoundError on dialog exit if appropriate

chrome/browser/ui/webui/media_router/media_router_ui_unittest.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/ui/webui/media_router/media_router_ui.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/media/router/create_presentation_connection_request.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/route_request_result.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/webui/media_router/media_router_webui_message_handler.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_web_ui.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using testing::_;
 using testing::AnyNumber;
+using testing::Invoke;
 using testing::SaveArg;
 using testing::Return;
 
 namespace media_router {
 
+class PresentationRequestCallbacks {
+public:
+  explicit PresentationRequestCallbacks(
+      const content::PresentationError& expected_error)
+      : expected_error_(expected_error) {}
+
+  void Success(const content::PresentationSessionInfo&, const MediaRoute::Id&) {
+  }
+
+  void Error(const content::PresentationError& error) {
+    EXPECT_EQ(expected_error_.error_type, error.error_type);
+    EXPECT_EQ(expected_error_.message, error.message);
+  }
+
+private:
+  content::PresentationError expected_error_;
+};
+
 class MockRoutesUpdatedCallback {
  public:
   MOCK_METHOD2(OnRoutesUpdated,
                void(const std::vector<MediaRoute>& routes,
                     const std::vector<MediaRoute::Id>& joinable_route_ids));
 };
 
 class MediaRouterUITest : public ::testing::Test {
  public:
   ~MediaRouterUITest() override {
     EXPECT_CALL(mock_router_, UnregisterMediaSinksObserver(_))
         .Times(AnyNumber());
     EXPECT_CALL(mock_router_, UnregisterMediaRoutesObserver(_))
         .Times(AnyNumber());
   }
 
   void CreateMediaRouterUI(Profile* profile) {
     initiator_.reset(content::WebContents::Create(
         content::WebContents::CreateParams(profile)));
     SessionTabHelper::CreateForWebContents(initiator_.get());
     web_contents_.reset(content::WebContents::Create(
         content::WebContents::CreateParams(profile)));
     web_ui_.set_web_contents(web_contents_.get());
     media_router_ui_.reset(new MediaRouterUI(&web_ui_));
     message_handler_.reset(
         new MediaRouterWebUIMessageHandler(media_router_ui_.get()));
     EXPECT_CALL(mock_router_, RegisterMediaSinksObserver(_))
-        .WillRepeatedly(Return(true));
+        .WillRepeatedly(Invoke([this](MediaSinksObserver* observer) {
+          this->media_sinks_observers_.push_back(observer);
+          return true;
+        }));
     EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_))
         .Times(AnyNumber());
     media_router_ui_->InitForTest(&mock_router_, initiator_.get(),
-                                  message_handler_.get());
+                                  message_handler_.get(),
+                                  std::move(create_session_request_));
     message_handler_->SetWebUIForTest(&web_ui_);
   }
 
  protected:
   MockMediaRouter mock_router_;
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<content::WebContents> initiator_;
   content::TestWebUI web_ui_;
   std::unique_ptr<content::WebContents> web_contents_;
+  std::unique_ptr<CreatePresentationConnectionRequest> create_session_request_;
   std::unique_ptr<MediaRouterUI> media_router_ui_;
   std::unique_ptr<MediaRouterWebUIMessageHandler> message_handler_;
+  std::vector<MediaSinksObserver*> media_sinks_observers_;
 };
 
 TEST_F(MediaRouterUITest, RouteCreationTimeoutForTab) {
   CreateMediaRouterUI(&profile_);
   std::vector<MediaRouteResponseCallback> callbacks;
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(60), false))
       .WillOnce(SaveArg<4>(&callbacks));
   media_router_ui_->CreateRoute("sinkId", MediaCastMode::TAB_MIRROR);
@@ skipping 308 matching lines @@
   EXPECT_EQ("", MediaRouterUI::GetExtensionName(url, registry.get()));
 }
 
 TEST_F(MediaRouterUITest, GetExtensionNameEmptyWhenNotExtensionURL) {
   GURL url = GURL("https://www.google.com");
   std::unique_ptr<extensions::ExtensionRegistry> registry =
       base::WrapUnique(new extensions::ExtensionRegistry(nullptr));
 
   EXPECT_EQ("", MediaRouterUI::GetExtensionName(url, registry.get()));
 }
+
+TEST_F(MediaRouterUITest, NotFoundErrorOnCloseWithNoSinks) {
+  content::PresentationError expected_error(
+      content::PresentationErrorType::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
+      "No screens found.");
+  PresentationRequestCallbacks request_callbacks(expected_error);
+  create_session_request_.reset(new CreatePresentationConnectionRequest(
+      RenderFrameHostId(0, 0), std::string("http://google.com/presentation"),
+      GURL("http://google.com"),
+      base::Bind(&PresentationRequestCallbacks::Success,
+                 base::Unretained(&request_callbacks)),
+      base::Bind(&PresentationRequestCallbacks::Error,
+                 base::Unretained(&request_callbacks))));
+  CreateMediaRouterUI(&profile_);
+  // Destroying the UI should return the expected error from above to the error
+  // callback.
+  media_router_ui_.reset();
+}
+
+TEST_F(MediaRouterUITest, NotFoundErrorOnCloseWithNoCompatibleSinks) {
+  content::PresentationError expected_error(
+      content::PresentationErrorType::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
+      "No screens found.");
+  PresentationRequestCallbacks request_callbacks(expected_error);
+  std::string presentation_url("http://google.com/presentation");
+  create_session_request_.reset(new CreatePresentationConnectionRequest(
+      RenderFrameHostId(0, 0), presentation_url, GURL("http://google.com"),
+      base::Bind(&PresentationRequestCallbacks::Success,
+                 base::Unretained(&request_callbacks)),
+      base::Bind(&PresentationRequestCallbacks::Error,
+                 base::Unretained(&request_callbacks))));
+  CreateMediaRouterUI(&profile_);
+
+  // Send a sink to the UI that is compatible with sources other than the
+  // presentation url to cause a NotFoundError.
+  std::vector<MediaSink> sinks;
+  sinks.emplace_back("sink id", "sink name", MediaSink::GENERIC);
+  std::vector<GURL> origins;
+  for (auto& observer : media_sinks_observers_) {
+    if (observer->source().id() != presentation_url) {
+      observer->OnSinksUpdated(sinks, origins);
+    }
+  }
+  // Destroying the UI should return the expected error from above to the error
+  // callback.
+  media_router_ui_.reset();
+}
+
+TEST_F(MediaRouterUITest, AbortErrorOnClose) {
+  content::PresentationError expected_error(
+      content::PresentationErrorType::
+          PRESENTATION_ERROR_SESSION_REQUEST_CANCELLED,
+      "Dialog closed.");
+  PresentationRequestCallbacks request_callbacks(expected_error);
+  std::string presentation_url("http://google.com/presentation");
+  create_session_request_.reset(new CreatePresentationConnectionRequest(
+      RenderFrameHostId(0, 0), presentation_url, GURL("http://google.com"),
+      base::Bind(&PresentationRequestCallbacks::Success,
+                 base::Unretained(&request_callbacks)),
+      base::Bind(&PresentationRequestCallbacks::Error,
+                 base::Unretained(&request_callbacks))));
+  CreateMediaRouterUI(&profile_);
+
+  // Send a sink to the UI that is compatible with the presentation url to avoid
+  // a NotFoundError.
+  std::vector<MediaSink> sinks;
+  sinks.emplace_back("sink id", "sink name", MediaSink::GENERIC);
+  std::vector<GURL> origins;
+  for (auto& observer : media_sinks_observers_) {
+    if (observer->source().id() == presentation_url) {
+      observer->OnSinksUpdated(sinks, origins);
+    }
+  }
+  // Destroying the UI should return the expected error from above to the error
+  // callback.
+  media_router_ui_.reset();
+}
 }  // namespace media_router