[PresentationAPI] renamed GetScreenAvailability to ListenForScreenAvailability for consistency

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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/browser/presentation/presentation_service_impl.h"
 #include "content/public/browser/presentation_service_delegate.h"
 #include "content/public/browser/presentation_session.h"
@@ skipping 73 matching lines @@
   void TearDown() override {
     service_ptr_.reset();
 
     EXPECT_CALL(mock_delegate_, RemoveObserver(Eq(service_impl_.get())))
         .Times(1);
     service_impl_.reset();
 
     RenderViewHostImplTestHarness::TearDown();
   }
 
-  void GetScreenAvailabilityAndWait(
+  void ListenForScreenAvailabilityAndWait(
       const std::string& presentation_url,
       const base::Callback<void(const std::string&, bool)>& callback,
       bool delegate_success) {
     base::RunLoop run_loop;
     // This will call to |service_impl_| via mojo. Process the message
     // using RunLoop.
     // The callback shouldn't be invoked since there is no availability
     // result yet.
     EXPECT_CALL(mock_delegate_, AddScreenAvailabilityListener(_, _, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             Return(delegate_success)));
-    service_ptr_->GetScreenAvailability(presentation_url, callback);
+    service_ptr_->ListenForScreenAvailability(presentation_url, callback);
     run_loop.Run();
 
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
   }
 
   void ExpectListenerDoesNotExist(const std::string& presentation_url) {
     const auto& contexts = service_impl_->availability_contexts_;
     auto it = contexts.find(presentation_url);
     EXPECT_TRUE(it == contexts.end());
   }
@@ skipping 65 matching lines @@
       run_loop_quit_closure_.Run();
   }
 
   MockPresentationServiceDelegate mock_delegate_;
   scoped_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<presentation::PresentationService> service_ptr_;
   base::Closure run_loop_quit_closure_;
   int callback_count_;
 };
 
-TEST_F(PresentationServiceImplTest, GetScreenAvailability) {
+TEST_F(PresentationServiceImplTest, ListenForScreenAvailability) {
   std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this), true),
       true);
 
   // Different presentation URL.
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       "http://barUrl",
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
   // Result now available; callback will be invoked with availability result.
   SimulateScreenAvailabilityChange(presentation_url, true);
   SaveQuitClosureAndRunLoop();
 
   EXPECT_EQ(1, callback_count_);
 
   // Result updated but callback not invoked since it's been erased.
   SimulateScreenAvailabilityChange(presentation_url, false);
 
   // Register another callback which should immediately invoke callback
   // since updated result is available.
-  service_ptr_->GetScreenAvailability(
+  service_ptr_->ListenForScreenAvailability(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
           false));
   SaveQuitClosureAndRunLoop();
   EXPECT_EQ(2, callback_count_);
 }
 
 TEST_F(PresentationServiceImplTest, Reset) {
   std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
   ExpectReset();
   service_impl_->Reset();
   ExpectCleanState();
 
   EXPECT_EQ(0, callback_count_);
 }
 
 TEST_F(PresentationServiceImplTest, DidNavigateThisFrame) {
   std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
   ExpectReset();
   service_impl_->DidNavigateAnyFrame(
       contents()->GetMainFrame(),
       content::LoadCommittedDetails(),
       content::FrameNavigateParams());
   ExpectCleanState();
 }
 
 TEST_F(PresentationServiceImplTest, DidNavigateNotThisFrame) {
   std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
           true),
       true);
 
   // TODO(imcheng): How to get a different RenderFrameHost?
   service_impl_->DidNavigateAnyFrame(
       nullptr,
       content::LoadCommittedDetails(),
       content::FrameNavigateParams());
 
   // Availability is reported and callback is invoked since it was not
   // removed.
   SimulateScreenAvailabilityChange(presentation_url, true);
   SaveQuitClosureAndRunLoop();
   EXPECT_EQ(1, callback_count_);
 }
 
 TEST_F(PresentationServiceImplTest, ThisRenderFrameDeleted) {
   std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       true);
 
   ExpectReset();
   service_impl_->RenderFrameDeleted(contents()->GetMainFrame());
   ExpectCleanState();
 }
 
 TEST_F(PresentationServiceImplTest, NotThisRenderFrameDeleted) {
     std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
           true),
       true);
 
   // TODO(imcheng): How to get a different RenderFrameHost?
   service_impl_->RenderFrameDeleted(nullptr);
 
   // Availability is reported and callback should be invoked since listener
   // has not been deleted.
   SimulateScreenAvailabilityChange(presentation_url, true);
   SaveQuitClosureAndRunLoop();
   EXPECT_EQ(1, callback_count_);
 }
 
-TEST_F(PresentationServiceImplTest, GetScreenAvailabilityTwice) {
+TEST_F(PresentationServiceImplTest, ListenForScreenAvailabilityTwice) {
   std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
           false),
       true);
 
   // Second call should overwrite the callback from first call.
   // It shouldn't result in an extra call to delegate.
-  service_ptr_->GetScreenAvailability(
+  service_ptr_->ListenForScreenAvailability(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
           false));
 
-  // Cannot use GetScreenAvailabilityAndWait here since the mock delegate
+  // Cannot use ListenForScreenAvailabilityAndWait here since the mock delegate
   // won't be triggered again to quit the RunLoop.
   RunLoopFor(base::TimeDelta::FromMilliseconds(50));
 
   // Result now available; callback will be invoked with availability result.
   SimulateScreenAvailabilityChange(presentation_url, false);
   SaveQuitClosureAndRunLoop();
 
   EXPECT_EQ(2, callback_count_);
 }
 
 TEST_F(PresentationServiceImplTest, DelegateFails) {
   std::string presentation_url("http://fooUrl");
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       false);
 
   ExpectListenerDoesNotExist(presentation_url);
 }
 
 TEST_F(PresentationServiceImplTest, SetDefaultPresentationUrl) {
   std::string url1("http://fooUrl");
   std::string dpu_id("dpuId");
   EXPECT_CALL(mock_delegate_,
       SetDefaultPresentationUrl(_, _, Eq(url1), Eq(dpu_id)))
       .Times(1);
   service_impl_->SetDefaultPresentationURL(url1, dpu_id);
   EXPECT_EQ(url1, service_impl_->default_presentation_url_);
 
   // Now there should be a callback registered with the DPU.
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       url1,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this), true),
       true);
   const auto& contexts = service_impl_->availability_contexts_;
   auto it = contexts.find(url1);
   ASSERT_TRUE(it != contexts.end());
   EXPECT_TRUE(it->second->HasPendingCallbacks());
 
@@ skipping 39 matching lines @@
 TEST_F(PresentationServiceImplTest, ClearDefaultPresentationUrl) {
   std::string url("http://fooUrl");
   std::string dpu_id("dpuId");
   EXPECT_CALL(mock_delegate_,
       SetDefaultPresentationUrl(_, _, Eq(url), Eq(dpu_id)))
       .Times(1);
   service_impl_->SetDefaultPresentationURL(url, dpu_id);
   EXPECT_EQ(url, service_impl_->default_presentation_url_);
 
   // Now there should be a callback registered with the DPU.
-  GetScreenAvailabilityAndWait(
+  ListenForScreenAvailabilityAndWait(
       url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this), true),
       true);
 
   const auto& contexts = service_impl_->availability_contexts_;
   auto it = contexts.find(url);
   ASSERT_TRUE(it != contexts.end());
   EXPECT_TRUE(it->second->HasPendingCallbacks());
@@ skipping 132 matching lines @@
   // Running the callback means the first request is done. It should now
   // move on to the queued request.
   EXPECT_CALL(mock_delegate_, StartSession(
       _, _, Eq(presentation_url2), Eq(presentation_id2), _, _))
       .Times(1);
   success_cb.Run(PresentationSessionInfo(presentation_url1, presentation_id1));
   SaveQuitClosureAndRunLoop();
 }
 
 }  // namespace content