[Presentation API] 1-UA presentation support + presenter APIs.

chrome/browser/media/router/presentation_service_delegate_impl_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/media/router/presentation_service_delegate_impl.h"
 
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/media_source.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mock_screen_availability_listener.h"
+#include "chrome/browser/media/router/offscreen_presentation_manager.h"
+#include "chrome/browser/media/router/offscreen_presentation_manager_factory.h"
+#include "chrome/browser/media/router/receiver_presentation_service_delegate_impl.h"
 #include "chrome/browser/media/router/route_request_result.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/presentation_screen_availability_listener.h"
 #include "content/public/browser/presentation_session.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media_router {
 
+using OffscreenPresentationConnection =
+    OffscreenPresentationManager::OffscreenPresentationConnection;
+
 class MockDelegateObserver
     : public content::PresentationServiceDelegate::Observer {
  public:
   MOCK_METHOD0(OnDelegateDestroyed, void());
   MOCK_METHOD1(OnDefaultPresentationStarted,
                void(const content::PresentationSessionInfo&));
 };
 
 class MockDefaultPresentationRequestObserver
     : public PresentationServiceDelegateImpl::
           DefaultPresentationRequestObserver {
  public:
   MOCK_METHOD1(OnDefaultPresentationChanged, void(const PresentationRequest&));
   MOCK_METHOD0(OnDefaultPresentationRemoved, void());
 };
 
 class MockCreatePresentationConnnectionCallbacks {
  public:
   MOCK_METHOD1(OnCreateConnectionSuccess,
                void(const content::PresentationSessionInfo& connection));
   MOCK_METHOD1(OnCreateConnectionError,
                void(const content::PresentationError& error));
 };
 
 class PresentationServiceDelegateImplTest
     : public ChromeRenderViewHostTestHarness {
  public:
-  PresentationServiceDelegateImplTest() : delegate_impl_(nullptr) {}
+  PresentationServiceDelegateImplTest()
+      : delegate_impl_(nullptr),
+        receiver_web_contents_(nullptr),
+        receiver_delegate_impl_(nullptr),
+        receiver_render_process_id_(0),
+        receiver_routing_id_(0) {}
 
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     content::WebContents* wc = GetWebContents();
     ASSERT_TRUE(wc);
     PresentationServiceDelegateImpl::CreateForWebContents(wc);
     delegate_impl_ = PresentationServiceDelegateImpl::FromWebContents(wc);
     delegate_impl_->SetMediaRouterForTest(&router_);
   }
 
+  void TearDown() override {
+    delete receiver_web_contents_;
+    ChromeRenderViewHostTestHarness::TearDown();
+  }
+
   MOCK_METHOD1(OnDefaultPresentationStarted,
                void(const content::PresentationSessionInfo& session_info));
+  MOCK_METHOD1(OnReceiverConnectionAvailable,
+               void(const content::PresentationSessionInfo&));
 
  protected:
   virtual content::WebContents* GetWebContents() { return web_contents(); }
+  virtual bool IsOffTheRecord() { return false; }
 
-  void RunDefaultPresentationUrlCallbackTest(bool off_the_record) {
+  void RunDefaultPresentationUrlCallbackTest() {
     content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
     ASSERT_TRUE(main_frame);
     int render_process_id = main_frame->GetProcess()->GetID();
     int routing_id = main_frame->GetRoutingID();
 
     auto callback = base::Bind(
         &PresentationServiceDelegateImplTest::OnDefaultPresentationStarted,
         base::Unretained(this));
     std::string presentation_url1("http://foo.fakeUrl");
     delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id,
@@ skipping 10 matching lines @@
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
 
     // Should not trigger callback since request doesn't match.
     std::string presentation_url2("http://bar.fakeUrl");
     PresentationRequest different_request(
         RenderFrameHostId(100, 200), presentation_url2,
         GURL("http://anotherFrameUrl.fakeUrl"));
     MediaRoute* media_route = new MediaRoute(
         "differentRouteId", MediaSourceForPresentationUrl(presentation_url2),
         "mediaSinkId", "", true, "", true);
-    media_route->set_off_the_record(off_the_record);
+    media_route->set_off_the_record(IsOffTheRecord());
     result = RouteRequestResult::FromSuccess(base::WrapUnique(media_route),
                                              "differentPresentationId");
     delegate_impl_->OnRouteResponse(different_request, *result);
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
 
     // Should trigger callback since request matches.
     EXPECT_CALL(*this, OnDefaultPresentationStarted(_)).Times(1);
     MediaRoute* media_route2 = new MediaRoute(
         "routeId", MediaSourceForPresentationUrl(presentation_url1),
         "mediaSinkId", "", true, "", true);
-    media_route2->set_off_the_record(off_the_record);
+    media_route2->set_off_the_record(IsOffTheRecord());
     result = RouteRequestResult::FromSuccess(base::WrapUnique(media_route2),
                                              "presentationId");
     delegate_impl_->OnRouteResponse(request, *result);
   }
 
+  void RunOffscreenPresentationTest() {
+    content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
+    ASSERT_TRUE(main_frame);
+    int render_process_id = main_frame->GetProcess()->GetID();
+    int routing_id = main_frame->GetRoutingID();
+
+    const std::string kPresentationUrl("http://url1.fakeUrl");
+    const std::string kPresentationId("pid");
+    content::PresentationSessionInfo connection(kPresentationUrl,
+                                                kPresentationId);
+    content::PresentationSessionInfo receiver_connection("", kPresentationId);
+
+    // |receiver_delegate_impl_| listens for new receiver presentations with
+    // |kPresentationId|.
+    CreateReceiverDelegate(kPresentationId);
+    ASSERT_TRUE(receiver_delegate_impl_);
+
+    // This should have created a presentation connection in
+    // |receiver_delegate_impl_|.
+    // Get current receiver connections and continue to listen for new
+    // connections.
+    CreateOffscreenPresentationRoute(render_process_id, routing_id,
+                                     kPresentationUrl, kPresentationId,
+                                     "routeId1", "sinkId1");
+    std::vector<content::PresentationSessionInfo> receiver_connections =
+        receiver_delegate_impl_->GetReceiverConnections(
+            receiver_render_process_id_, receiver_routing_id_,
+            base::Bind(&PresentationServiceDelegateImplTest::
+                           OnReceiverConnectionAvailable,
+                       base::Unretained(this)));
+    ASSERT_EQ(1u, receiver_connections.size());
+    EXPECT_EQ(receiver_connection.presentation_url,
+              receiver_connections[0].presentation_url);
+    EXPECT_EQ(receiver_connection.presentation_id,
+              receiver_connections[0].presentation_id);
+
+    EXPECT_CALL(*this,
+                OnReceiverConnectionAvailable(
+                    PresentationConnectionInfoEquals(receiver_connection)));
+    CreateOffscreenPresentationRoute(render_process_id + 1, routing_id + 1,
+                                     kPresentationUrl, kPresentationId,
+                                     "routeId2", "sinkId2");
+
+    MockPresentationMessagesCallback controller_messages_callback;
+    MockPresentationMessagesCallback receiver_messages_callback;
+
+    // The controller of the presentation will listen for messages from both
+    // |router_| and the receiver.
+    EXPECT_CALL(router_, RegisterPresentationSessionMessagesObserver(_));
+    delegate_impl_->ListenForSessionMessages(
+        render_process_id, routing_id, connection,
+        base::Bind(&MockPresentationMessagesCallback::OnMessagesReceived,
+                   base::Unretained(&controller_messages_callback)));
+    receiver_delegate_impl_->ListenForSessionMessages(
+        receiver_render_process_id_, receiver_routing_id_, receiver_connection,
+        base::Bind(&MockPresentationMessagesCallback::OnMessagesReceived,
+                   base::Unretained(&receiver_messages_callback)));
+
+    // Send messages from controller to receiver and vice versa.
+    std::string message_text("controller to receiver");
+    std::unique_ptr<content::PresentationSessionMessage> message(
+        new content::PresentationSessionMessage(
+            content::PresentationMessageType::TEXT));
+    message->message = message_text;
+    EXPECT_CALL(controller_messages_callback, OnMessageSent(true));
+    EXPECT_CALL(receiver_messages_callback, DoOnMessagesReceived(message_text));
+    delegate_impl_->SendMessage(
+        render_process_id, routing_id, connection, std::move(message),
+        base::Bind(&MockPresentationMessagesCallback::OnMessageSent,
+                   base::Unretained(&controller_messages_callback)));
+
+    message_text = "receiver to controller";
+    message.reset(new content::PresentationSessionMessage(
+        content::PresentationMessageType::TEXT));
+    message->message = message_text;
+    EXPECT_CALL(receiver_messages_callback, OnMessageSent(true));
+    EXPECT_CALL(controller_messages_callback,
+                DoOnMessagesReceived(message_text));
+    receiver_delegate_impl_->SendMessage(
+        receiver_render_process_id_, receiver_routing_id_, receiver_connection,
+        std::move(message),
+        base::Bind(&MockPresentationMessagesCallback::OnMessageSent,
+                   base::Unretained(&receiver_messages_callback)));
+
+    MockPresentationConnectionStateChangedCallback
+        controller_state_change_callback;
+    MockPresentationConnectionStateChangedCallback
+        receiver_state_change_callback;
+
+    // The controller of the offscreen presentation will listen for state change
+    // from both |router_| and the receiver.
+    content::PresentationConnectionStateChangedCallback state_change_callback =
+        base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                   base::Unretained(&controller_state_change_callback));
+    EXPECT_CALL(router_, OnAddPresentationConnectionStateChangedCallbackInvoked(
+                             Equals(state_change_callback)));
+    delegate_impl_->ListenForConnectionStateChange(
+        render_process_id, routing_id, connection, state_change_callback);
+    receiver_delegate_impl_->ListenForConnectionStateChange(
+        receiver_render_process_id_, receiver_routing_id_, receiver_connection,
+        base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                   base::Unretained(&receiver_state_change_callback)));
+
+    // Calling Reset() on |receiver_delegate_impl_| will destroy the receiver
+    // connection, which causes state change on the controller.
+    content::PresentationConnectionStateChangeInfo info(
+        content::PRESENTATION_CONNECTION_STATE_CLOSED);
+    info.close_reason = content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY;
+    EXPECT_CALL(controller_state_change_callback,
+                Run(StateChageInfoEquals(info)));
+    receiver_delegate_impl_->Reset(receiver_render_process_id_,
+                                   receiver_routing_id_);
+
+    EXPECT_CALL(router_, UnregisterPresentationSessionMessagesObserver(_));
+  }
+
+  void CreateReceiverDelegate(const std::string& presentation_id) {
+    content::WebContents* receiver_wc = GetReceiverWebContents();
+    ReceiverPresentationServiceDelegateImpl::CreateForWebContents(
+        receiver_wc, presentation_id);
+    receiver_delegate_impl_ =
+        ReceiverPresentationServiceDelegateImpl::FromWebContents(receiver_wc);
+
+    content::RenderFrameHost* main_frame =
+        GetReceiverWebContents()->GetMainFrame();
+    ASSERT_TRUE(main_frame);
+    receiver_render_process_id_ = main_frame->GetProcess()->GetID();
+    receiver_routing_id_ = main_frame->GetRoutingID();
+  }
+
+  content::WebContents* GetReceiverWebContents() {
+    if (!receiver_web_contents_) {
+      Profile* otr_profile = profile()->GetOffTheRecordProfile();
+      receiver_web_contents_ =
+          content::WebContentsTester::CreateTestWebContents(otr_profile,
+                                                            nullptr);
+    }
+    return receiver_web_contents_;
+  }
+
+  void CreateOffscreenPresentationRoute(int render_process_id,
+                                        int routing_id,
+                                        const std::string& presentation_url,
+                                        const std::string& presentation_id,
+                                        const MediaRoute::Id& route_id,
+                                        const MediaSink::Id& sink_id) {
+    // Use JoinRoute to create a route with a fixed presentation ID.
+    std::vector<MediaRouteResponseCallback> route_response_callbacks;
+    EXPECT_CALL(router_, JoinRoute(_, _, _, _, _, _, IsOffTheRecord()))
+        .WillOnce(SaveArg<4>(&route_response_callbacks));
+    MockCreatePresentationConnnectionCallbacks mock_create_connection_callbacks;
+    delegate_impl_->JoinSession(
+        render_process_id, routing_id, presentation_url, presentation_id,
+        base::Bind(&MockCreatePresentationConnnectionCallbacks::
+                       OnCreateConnectionSuccess,
+                   base::Unretained(&mock_create_connection_callbacks)),
+        base::Bind(&MockCreatePresentationConnnectionCallbacks::
+                       OnCreateConnectionError,
+                   base::Unretained(&mock_create_connection_callbacks)));
+
+    EXPECT_CALL(mock_create_connection_callbacks, OnCreateConnectionSuccess(_))
+        .Times(1);
+    std::unique_ptr<MediaRoute> route(new MediaRoute(
+        route_id, MediaSourceForPresentationUrl(presentation_url), sink_id,
+        "description", true, "", true));
+    route->set_off_the_record(IsOffTheRecord());
+    route->set_is_offscreen_presentation(true);
+    std::unique_ptr<RouteRequestResult> result =
+        RouteRequestResult::FromSuccess(std::move(route), presentation_id);
+    for (const auto& route_response_callback : route_response_callbacks)
+      route_response_callback.Run(*result);
+  }
+
   PresentationServiceDelegateImpl* delegate_impl_;
   MockMediaRouter router_;
+
+  content::WebContents* receiver_web_contents_;
+  ReceiverPresentationServiceDelegateImpl* receiver_delegate_impl_;
+  int receiver_render_process_id_;
+  int receiver_routing_id_;
 };
 
 class PresentationServiceDelegateImplIncognitoTest
     : public PresentationServiceDelegateImplTest {
  public:
   PresentationServiceDelegateImplIncognitoTest() :
       incognito_web_contents_(nullptr) {}
 
  protected:
   content::WebContents* GetWebContents() override {
     if (!incognito_web_contents_) {
       Profile* incognito_profile = profile()->GetOffTheRecordProfile();
       incognito_web_contents_ =
           content::WebContentsTester::CreateTestWebContents(incognito_profile,
                                                             nullptr);
     }
     return incognito_web_contents_;
   }
 
+  bool IsOffTheRecord() override { return true; }
+
   void TearDown() override {
     // We must delete the incognito WC first, as that triggers observers which
     // require RenderViewHost, etc., that in turn are deleted by
     // RenderViewHostTestHarness::TearDown().
     delete incognito_web_contents_;
     PresentationServiceDelegateImplTest::TearDown();
   }
 
   content::WebContents* incognito_web_contents_;
 };
@@ skipping 139 matching lines @@
             request2.render_frame_host_id());
   EXPECT_EQ(frame_url, request2.frame_url());
 
   // Remove default presentation URL.
   delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id, "",
                                             callback);
   EXPECT_FALSE(delegate_impl_->HasDefaultPresentationRequest());
 }
 
 TEST_F(PresentationServiceDelegateImplTest, DefaultPresentationUrlCallback) {
-  RunDefaultPresentationUrlCallbackTest(false);
+  RunDefaultPresentationUrlCallbackTest();
 }
 
 TEST_F(PresentationServiceDelegateImplIncognitoTest,
        DefaultPresentationUrlCallback) {
-  RunDefaultPresentationUrlCallbackTest(true);
+  RunDefaultPresentationUrlCallbackTest();
 }
 
 TEST_F(PresentationServiceDelegateImplTest,
        DefaultPresentationRequestObserver) {
   auto callback = base::Bind(
       &PresentationServiceDelegateImplTest::OnDefaultPresentationStarted,
       base::Unretained(this));
 
   StrictMock<MockDefaultPresentationRequestObserver> observer;
   delegate_impl_->AddDefaultPresentationRequestObserver(&observer);
@@ skipping 34 matching lines @@
   EXPECT_TRUE(request2.Equals(observed_request2));
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
 
   // Remove default presentation URL.
   EXPECT_CALL(observer, OnDefaultPresentationRemoved()).Times(1);
   delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id, "",
                                             callback);
 }
 
-TEST_F(PresentationServiceDelegateImplTest, ListenForConnnectionStateChange) {
+TEST_F(PresentationServiceDelegateImplTest, ListenForConnectionStateChange) {
   GURL frame_url("http://www.google.com");
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int routing_id = main_frame->GetRoutingID();
 
   // Set up a PresentationConnection so we can listen to it.
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
@@ skipping 15 matching lines @@
   EXPECT_CALL(mock_create_connection_callbacks, OnCreateConnectionSuccess(_))
       .Times(1);
   std::unique_ptr<RouteRequestResult> result = RouteRequestResult::FromSuccess(
       base::WrapUnique(new MediaRoute(
           "routeId", MediaSourceForPresentationUrl(kPresentationUrl),
           "mediaSinkId", "description", true, "", true)),
       kPresentationId);
   for (const auto& route_response_callback : route_response_callbacks)
     route_response_callback.Run(*result);
 
-  MockPresentationConnectionStateChangedCallback mock_callback;
+  MockPresentationConnectionStateChangedCallback mock_state_change_callback;
   content::PresentationConnectionStateChangedCallback callback =
       base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
-                 base::Unretained(&mock_callback));
+                 base::Unretained(&mock_state_change_callback));
   content::PresentationSessionInfo connection(kPresentationUrl,
                                               kPresentationId);
   EXPECT_CALL(router_, OnAddPresentationConnectionStateChangedCallbackInvoked(
                            Equals(callback)));
   delegate_impl_->ListenForConnectionStateChange(render_process_id, routing_id,
                                                  connection, callback);
 }
 
+TEST_F(PresentationServiceDelegateImplIncognitoTest, OffscreenPresentation) {
+  RunOffscreenPresentationTest();
+}
+
+TEST_F(PresentationServiceDelegateImplTest, OffscreenPresentation) {
+  RunOffscreenPresentationTest();
+}
+
 TEST_F(PresentationServiceDelegateImplTest, Reset) {
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_))
       .WillRepeatedly(Return(true));
 
   std::string presentation_url1("http://url1.fakeUrl");
   MediaSource source = MediaSourceForPresentationUrl(presentation_url1);
   MockScreenAvailabilityListener listener1(presentation_url1);
 
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
@@ skipping 36 matching lines @@
   int render_process_id = main_frame->GetProcess()->GetID();
   int render_frame_id = main_frame->GetRoutingID();
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).WillOnce(Return(false));
   EXPECT_CALL(listener, OnScreenAvailabilityNotSupported());
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener));
 }
 
 }  // namespace media_router