[Presentation API] OffscreenPresentationManager should only interact with top level receiver frame

content/browser/presentation/presentation_service_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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <iterator>
@@ skipping 594 matching lines @@
 
   PresentationInfo expected(presentation_url1_, kPresentationId);
   EXPECT_CALL(mock_delegate_, RegisterOffscreenPresentationConnectionRaw(
                                   _, _, InfoEquals(expected), _));
 
   service_impl_->SetPresentationConnection(
       presentation_info, std::move(connection), std::move(request));
 }
 
 TEST_F(PresentationServiceImplTest, ReceiverPresentationServiceDelegate) {
-  MockReceiverPresentationServiceDelegate mock_receiver_delegate;
-  EXPECT_CALL(mock_receiver_delegate, AddObserver(_, _, _)).Times(1);
+  EXPECT_CALL(mock_receiver_delegate_, AddObserver(_, _, _)).Times(1);
 
   PresentationServiceImpl service_impl(main_rfh(), contents(), nullptr,
-                                       &mock_receiver_delegate);
+                                       &mock_receiver_delegate_);
 
   ReceiverConnectionAvailableCallback callback;
-  EXPECT_CALL(mock_receiver_delegate,
+  EXPECT_CALL(mock_receiver_delegate_,
               RegisterReceiverConnectionAvailableCallback(_))
       .WillOnce(SaveArg<0>(&callback));
 
   blink::mojom::PresentationServiceClientPtr client_ptr;
   client_binding_.reset(
       new mojo::Binding<blink::mojom::PresentationServiceClient>(
           &mock_client_, mojo::MakeRequest(&client_ptr)));
   service_impl.controller_delegate_ = nullptr;
   service_impl.SetClient(std::move(client_ptr));
   EXPECT_FALSE(callback.is_null());
 
   PresentationInfo presentation_info(presentation_url1_, kPresentationId);
 
   // Client gets notified of receiver connections.
   blink::mojom::PresentationConnectionPtr controller_connection;
   MockPresentationConnection mock_presentation_connection;
   mojo::Binding<blink::mojom::PresentationConnection> connection_binding(
       &mock_presentation_connection, mojo::MakeRequest(&controller_connection));
   blink::mojom::PresentationConnectionPtr receiver_connection;
   EXPECT_CALL(mock_client_,
               OnReceiverConnectionAvailable(InfoEquals(presentation_info)));
   callback.Run(presentation_info, std::move(controller_connection),
                mojo::MakeRequest(&receiver_connection));
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_CALL(mock_receiver_delegate, RemoveObserver(_, _)).Times(1);
+  EXPECT_CALL(mock_receiver_delegate_, RemoveObserver(_, _)).Times(1);
+}
+
+TEST_F(PresentationServiceImplTest, ReceiverDelegateOnSubFrame) {
+  EXPECT_CALL(mock_receiver_delegate_, AddObserver(_, _, _)).Times(1);
+
+  PresentationServiceImpl service_impl(main_rfh(), contents(), nullptr,
+                                       &mock_receiver_delegate_);
+  service_impl.is_main_frame_ = false;
+
+  ReceiverConnectionAvailableCallback callback;
+  EXPECT_CALL(mock_receiver_delegate_,
+              RegisterReceiverConnectionAvailableCallback(_))
+      .Times(0);
+
+  blink::mojom::PresentationServiceClientPtr client_ptr;
+  client_binding_.reset(
+      new mojo::Binding<blink::mojom::PresentationServiceClient>(
+          &mock_client_, mojo::MakeRequest(&client_ptr)));
+  service_impl.controller_delegate_ = nullptr;
+  service_impl.SetClient(std::move(client_ptr));
+
+  EXPECT_CALL(mock_receiver_delegate_, Reset(_, _)).Times(0);
+  service_impl.Reset();
+
+  EXPECT_CALL(mock_receiver_delegate_, RemoveObserver(_, _)).Times(1);
 }
 
 }  // namespace content