Presentation API: reject screen availability observing on Android low ram devices.

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 <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 52 matching lines @@
 }  // namespace
 
 class MockPresentationServiceDelegate : public PresentationServiceDelegate {
  public:
   MOCK_METHOD3(AddObserver,
       void(int render_process_id,
            int render_frame_id,
            PresentationServiceDelegate::Observer* observer));
   MOCK_METHOD2(RemoveObserver,
       void(int render_process_id, int render_frame_id));
-  MOCK_METHOD3(AddScreenAvailabilityListener,
-      bool(
-          int render_process_id,
-          int routing_id,
-          PresentationScreenAvailabilityListener* listener));
+
+  bool AddScreenAvailabilityListener(
+      int render_process_id,
+      int routing_id,
+      PresentationScreenAvailabilityListener* listener) override {
+    if (!screen_availability_listening_supported_)
+      listener->OnScreenAvailabilityNotSupported();
+
+    return AddScreenAvailabilityListener();
+  }
+  MOCK_METHOD0(AddScreenAvailabilityListener, bool());
+
   MOCK_METHOD3(RemoveScreenAvailabilityListener,
       void(
           int render_process_id,
           int routing_id,
           PresentationScreenAvailabilityListener* listener));
   MOCK_METHOD2(Reset,
       void(
           int render_process_id,
           int routing_id));
   MOCK_METHOD3(SetDefaultPresentationUrl,
@@ skipping 37 matching lines @@
                    scoped_ptr<PresentationSessionMessage> message_request,
                    const SendMessageCallback& send_message_cb) override {
     SendMessageRawPtr(render_process_id, render_frame_id, session,
                       message_request.release(), send_message_cb);
   }
   MOCK_METHOD3(
       ListenForSessionStateChange,
       void(int render_process_id,
            int render_frame_id,
            const content::SessionStateChangedCallback& state_changed_cb));
+
+  void set_screen_availability_listening_supported(bool value) {
+    screen_availability_listening_supported_ = value;
+  }
+
+ private:
+  bool screen_availability_listening_supported_ = true;
 };
 
 class MockPresentationServiceClient :
     public presentation::PresentationServiceClient {
  public:
   MOCK_METHOD2(OnScreenAvailabilityUpdated,
       void(const mojo::String& url, bool available));
   void OnSessionStateChanged(
       presentation::PresentationSessionInfoPtr session_info,
       presentation::PresentationSessionState new_state) override {
     OnSessionStateChanged(*session_info, new_state);
   }
   MOCK_METHOD2(OnSessionStateChanged,
                void(const presentation::PresentationSessionInfo& session_info,
                     presentation::PresentationSessionState new_state));
-  void OnScreenAvailabilityNotSupported(const mojo::String& url) override {
-    NOTIMPLEMENTED();
-  }
+
+  MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const mojo::String& url));
 
   void OnSessionMessagesReceived(
       presentation::PresentationSessionInfoPtr session_info,
       mojo::Array<presentation::SessionMessagePtr> messages) override {
     messages_received_ = messages.Pass();
     MessagesReceived();
   }
   MOCK_METHOD0(MessagesReceived, void());
 
   mojo::Array<presentation::SessionMessagePtr> messages_received_;
@@ skipping 28 matching lines @@
     RenderViewHostImplTestHarness::TearDown();
   }
 
   void ListenForScreenAvailabilityAndWait(
       const mojo::String& url, 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(_, _, _))
+    EXPECT_CALL(mock_delegate_, AddScreenAvailabilityListener())
         .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             Return(delegate_success)));
     service_ptr_->ListenForScreenAvailability(url);
     run_loop.Run();
 
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
   }
 
   void RunLoopFor(base::TimeDelta duration) {
@@ skipping 612 matching lines @@
 
   EXPECT_CALL(mock_client_,
               OnSessionStateChanged(
                   Equals(session_info),
                   presentation::PRESENTATION_SESSION_STATE_CONNECTED));
   service_impl_->OnSessionStateChanged(
       content::PresentationSessionInfo(kPresentationUrl, kPresentationId),
       content::PRESENTATION_SESSION_STATE_CONNECTED);
 }
 
+TEST_F(PresentationServiceImplTest, ScreenAvailabilityNotSupported) {
+  mock_delegate_.set_screen_availability_listening_supported(false);
+  EXPECT_CALL(mock_client_,
+              OnScreenAvailabilityNotSupported(Eq(kPresentationUrl)));
+
+  ListenForScreenAvailabilityAndWait(kPresentationUrl, false);
+}
+
 }  // namespace content