[MediaRouter,PresentationAPI] ScreenAvailability - part 3

Remove OnScreenAvailabilityNotSupported in favor of
ScreenAvailability::DISABLED.

BUG=723032
TEST=existing/updated tests.

Change-Id: I824e832ad6454adfb4b221fd101b9eb4f65b46a3
Reviewed-on: https://chromium-review.googlesource.com/530324
Commit-Queue: Anton Vayvod <avayvod@chromium.org>
Reviewed-by: mark a. foltz <mfoltz@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#481084}

chrome/browser/media/router/mock_screen_availability_listener.h

@@ -21,8 +21,6 @@ class MockScreenAvailabilityListener
   MOCK_METHOD1(OnScreenAvailabilityChanged,
                void(blink::mojom::ScreenAvailability));
 
-  MOCK_METHOD0(OnScreenAvailabilityNotSupported, void());
-
  private:
   GURL availability_url_;
 };

chrome/browser/media/router/presentation_service_delegate_impl.cc

@@ -219,7 +219,7 @@ bool PresentationFrame::SetScreenAvailabilityListener(
   MediaSource source(GetMediaSourceFromListener(listener));
   if (!IsValidPresentationUrl(source.url())) {
     listener->OnScreenAvailabilityChanged(
-        blink::mojom::ScreenAvailability::UNAVAILABLE);
+        blink::mojom::ScreenAvailability::SOURCE_NOT_SUPPORTED);
     return false;
   }
 
@@ -233,7 +233,8 @@ bool PresentationFrame::SetScreenAvailabilityListener(
 
   if (!sinks_observer->Init()) {
     url_to_sinks_observer_.erase(source.id());
-    listener->OnScreenAvailabilityNotSupported();
+    listener->OnScreenAvailabilityChanged(
+        blink::mojom::ScreenAvailability::DISABLED);
     return false;
   }
 

chrome/browser/media/router/presentation_service_delegate_impl_unittest.cc

@@ -323,8 +323,9 @@ TEST_F(PresentationServiceDelegateImplTest, AddSameListenerTwice) {
 
 TEST_F(PresentationServiceDelegateImplTest, AddListenerForInvalidUrl) {
   MockScreenAvailabilityListener listener(GURL("unsupported-url://foo"));
-  EXPECT_CALL(listener, OnScreenAvailabilityChanged(
-                            blink::mojom::ScreenAvailability::UNAVAILABLE));
+  EXPECT_CALL(listener,
+              OnScreenAvailabilityChanged(
+                  blink::mojom::ScreenAvailability::SOURCE_NOT_SUPPORTED));
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       main_frame_process_id_, main_frame_routing_id_, &listener));
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).Times(0);
@@ -517,7 +518,8 @@ TEST_F(PresentationServiceDelegateImplTest, DelegateObservers) {
 
 TEST_F(PresentationServiceDelegateImplTest, SinksObserverCantRegister) {
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).WillOnce(Return(false));
-  EXPECT_CALL(listener1_, OnScreenAvailabilityNotSupported());
+  EXPECT_CALL(listener1_, OnScreenAvailabilityChanged(
+                              blink::mojom::ScreenAvailability::DISABLED));
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       main_frame_process_id_, main_frame_routing_id_, &listener1_));
 }

content/browser/presentation/presentation_service_impl.cc

@@ -500,11 +500,6 @@ void PresentationServiceImpl::ScreenAvailabilityListenerImpl::
                                                  availability);
 }
 
-void PresentationServiceImpl::ScreenAvailabilityListenerImpl
-::OnScreenAvailabilityNotSupported() {
-  service_->client_->OnScreenAvailabilityNotSupported(availability_url_);
-}
-
 PresentationServiceImpl::NewPresentationCallbackWrapper::
     NewPresentationCallbackWrapper(NewPresentationCallback callback)
     : callback_(std::move(callback)) {}

content/browser/presentation/presentation_service_impl.h

@@ -127,7 +127,6 @@ class CONTENT_EXPORT PresentationServiceImpl
     GURL GetAvailabilityUrl() const override;
     void OnScreenAvailabilityChanged(
         blink::mojom::ScreenAvailability availability) override;
-    void OnScreenAvailabilityNotSupported() override;
 
    private:
     const GURL availability_url_;

content/browser/presentation/presentation_service_impl_unittest.cc

@@ -76,8 +76,9 @@ class MockPresentationServiceDelegate
       int render_process_id,
       int routing_id,
       PresentationScreenAvailabilityListener* listener) override {
-    if (!screen_availability_listening_supported_)
-      listener->OnScreenAvailabilityNotSupported();
+    if (!screen_availability_listening_supported_) {
+      listener->OnScreenAvailabilityChanged(ScreenAvailability::DISABLED);
+    }
 
     return AddScreenAvailabilityListener();
   }
@@ -212,7 +213,6 @@ class MockPresentationServiceClient
                void(const PresentationInfo& connection,
                     PresentationConnectionCloseReason reason,
                     const std::string& message));
-  MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const GURL& url));
   // PresentationConnectionMessage is move-only.
   void OnConnectionMessagesReceived(
       const PresentationInfo& presentation_info,
@@ -345,7 +345,8 @@ TEST_F(PresentationServiceImplTest, ListenForScreenAvailability) {
 TEST_F(PresentationServiceImplTest, ScreenAvailabilityNotSupported) {
   mock_delegate_.set_screen_availability_listening_supported(false);
   EXPECT_CALL(mock_client_,
-              OnScreenAvailabilityNotSupported(presentation_url1_));
+              OnScreenAvailabilityUpdated(presentation_url1_,
+                                          ScreenAvailability::DISABLED));
   ListenForScreenAvailabilityAndWait(presentation_url1_, false);
   base::RunLoop().RunUntilIdle();
 }

content/public/browser/presentation_screen_availability_listener.h

@@ -29,11 +29,6 @@ class CONTENT_EXPORT PresentationScreenAvailabilityListener {
   // changed to |availability|.
   virtual void OnScreenAvailabilityChanged(
       blink::mojom::ScreenAvailability availability) = 0;
-
-  // Called when screen availability monitoring is not supported by the
-  // implementation because of system limitations like running low on battery or
-  // having resource constraints.
-  virtual void OnScreenAvailabilityNotSupported() = 0;
 };
 
 }  // namespace content

content/renderer/presentation/presentation_dispatcher.cc

@@ -439,22 +439,33 @@ void PresentationDispatcher::OnScreenAvailabilityUpdated(
 
   listening_status->last_known_availability = availability;
 
+  static const blink::WebString& not_supported_error =
+      blink::WebString::FromUTF8(
+          "getAvailability() isn't supported at the moment. It can be due to "
+          "a permanent or temporary system limitation. It is recommended to "
+          "try to blindly start a presentation in that case.");
+
   std::set<AvailabilityListener*> modified_listeners;
   for (auto& listener : availability_set_) {
     if (!base::ContainsValue(listener->urls, url))
       continue;
 
     auto screen_availability = GetScreenAvailability(listener->urls);
-    DCHECK(screen_availability != blink::mojom::ScreenAvailability::UNKNOWN &&
-           screen_availability != blink::mojom::ScreenAvailability::DISABLED);
+    DCHECK(screen_availability != blink::mojom::ScreenAvailability::UNKNOWN);
     for (auto* observer : listener->availability_observers)
       observer->AvailabilityChanged(screen_availability);
 
     for (AvailabilityCallbacksMap::iterator iter(
              &listener->availability_callbacks);
          !iter.IsAtEnd(); iter.Advance()) {
-      iter.GetCurrentValue()->OnSuccess(
-          screen_availability == blink::mojom::ScreenAvailability::AVAILABLE);
+      if (screen_availability == blink::mojom::ScreenAvailability::DISABLED) {
+        iter.GetCurrentValue()->OnError(blink::WebPresentationError(
+            blink::WebPresentationError::kErrorTypeAvailabilityNotSupported,
+            not_supported_error));
+      } else {
+        iter.GetCurrentValue()->OnSuccess(
+            screen_availability == blink::mojom::ScreenAvailability::AVAILABLE);
+      }
     }
     listener->availability_callbacks.Clear();
 
@@ -468,63 +479,6 @@ void PresentationDispatcher::OnScreenAvailabilityUpdated(
     TryRemoveAvailabilityListener(listener);
 }
 
-void PresentationDispatcher::OnScreenAvailabilityNotSupported(const GURL& url) {
-  auto* listening_status = GetListeningStatus(url);
-  if (!listening_status)
-    return;
-
-  if (listening_status->listening_state == ListeningState::WAITING)
-    listening_status->listening_state = ListeningState::ACTIVE;
-
-  if (listening_status->last_known_availability ==
-      blink::mojom::ScreenAvailability::DISABLED) {
-    return;
-  }
-
-  listening_status->last_known_availability =
-      blink::mojom::ScreenAvailability::DISABLED;
-
-  const blink::WebString& not_supported_error = blink::WebString::FromUTF8(
-      "getAvailability() isn't supported at the moment. It can be due to "
-      "a permanent or temporary system limitation. It is recommended to "
-      "try to blindly start a presentation in that case.");
-
-  std::set<AvailabilityListener*> modified_listeners;
-  for (auto& listener : availability_set_) {
-    if (!base::ContainsValue(listener->urls, url))
-      continue;
-
-    // ScreenAvailabilityNotSupported should be a browser side setting, which
-    // means all urls in PresentationAvailability should report NotSupported.
-    // It is not possible to change listening status from AVAILABLE or
-    // UNAVAILABLE to DISABLED.
-    auto screen_availability = GetScreenAvailability(listener->urls);
-    DCHECK_EQ(screen_availability, blink::mojom::ScreenAvailability::DISABLED);
-
-    // RemotePlayback is using a listener but doesn't use callbacks.
-    // So update observers even though it's not necessary for Presentation API.
-    for (auto* observer : listener->availability_observers)
-      observer->AvailabilityChanged(screen_availability);
-
-    for (AvailabilityCallbacksMap::iterator iter(
-             &listener->availability_callbacks);
-         !iter.IsAtEnd(); iter.Advance()) {
-      iter.GetCurrentValue()->OnError(blink::WebPresentationError(
-          blink::WebPresentationError::kErrorTypeAvailabilityNotSupported,
-          not_supported_error));
-    }
-    listener->availability_callbacks.Clear();
-
-    for (const auto& availability_url : listener->urls)
-      MaybeStopListeningToURL(availability_url);
-
-    modified_listeners.insert(listener.get());
-  }
-
-  for (auto* listener : modified_listeners)
-    TryRemoveAvailabilityListener(listener);
-}
-
 void PresentationDispatcher::OnDefaultPresentationStarted(
     const PresentationInfo& presentation_info) {
   if (!controller_)

content/renderer/presentation/presentation_dispatcher.h

@@ -158,7 +158,6 @@ class CONTENT_EXPORT PresentationDispatcher
   void WidgetWillClose() override;
 
   // blink::mojom::PresentationServiceClient
-  void OnScreenAvailabilityNotSupported(const GURL& url) override;
   void OnScreenAvailabilityUpdated(
       const GURL& url,
       blink::mojom::ScreenAvailability availability) override;

content/renderer/presentation/presentation_dispatcher_unittest.cc

@@ -273,7 +273,8 @@ class PresentationDispatcherTest : public ::testing::Test {
             url, ScreenAvailability::UNAVAILABLE);
         break;
       case ScreenAvailability::DISABLED:
-        dispatcher_.OnScreenAvailabilityNotSupported(url);
+        dispatcher_.OnScreenAvailabilityUpdated(url,
+                                                ScreenAvailability::DISABLED);
         break;
       case ScreenAvailability::UNKNOWN:
         break;

third_party/WebKit/public/platform/modules/presentation/presentation.mojom

@@ -124,12 +124,6 @@ interface PresentationService {
 interface PresentationServiceClient {
   //////////  This API is implemented by a controlling frame.  /////////////////
 
-  // Called when the client tries to listen for screen availability changes for
-  // presentation of |url| but it is not supported by the device or underlying
-  // platform. This can also be called if the device is currently in a mode
-  // where it can't do screen discoveries (eg. low battery).
-  OnScreenAvailabilityNotSupported(url.mojom.Url url);
-
   // Called when the client is listening for screen availability for
   // presentation of |url| and the state changes. When the client starts to
   // listen for screen availability, this method will always be called to give