Update mojo sdk to rev 7214b7ec7d27563b2666afad86cf1c5895c56c18

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 300 matching lines @@
   // has not been deleted.
   SimulateScreenAvailabilityChange(presentation_url, true);
   SaveQuitClosureAndRunLoop();
   EXPECT_EQ(1, callback_count_);
 }
 
 TEST_F(PresentationServiceImplTest, GetScreenAvailabilityTwice) {
   std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
       presentation_url,
-      base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
-          base::Unretained(this)),
+      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(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this),
           false));
 
   // Cannot use GetScreenAvailabilityAndWait 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(1, callback_count_);
+  EXPECT_EQ(2, callback_count_);
 }
 
 TEST_F(PresentationServiceImplTest, DelegateFails) {
   std::string presentation_url("http://fooUrl");
   GetScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(&PresentationServiceImplTest::ShouldNotBeCalled,
           base::Unretained(this)),
       false);
 
@@ skipping 12 matching lines @@
   // Now there should be a callback registered with the DPU.
   GetScreenAvailabilityAndWait(
       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_NE(nullptr, it->second->GetCallback());
+  EXPECT_TRUE(it->second->HasPendingCallbacks());
 
   std::string url2("http://barUrl");
   // Sets different DPU.
   // Adds listener for url2 and removes listener for url1.
   // Also, the callback from url1 is transferred to url2.
   EXPECT_CALL(
       mock_delegate_,
       AddScreenAvailabilityListener(_, _, _))
       .WillOnce(Return(true));
   EXPECT_CALL(
       mock_delegate_,
       RemoveScreenAvailabilityListener(_, _, _))
       .Times(1);
   EXPECT_CALL(mock_delegate_,
       SetDefaultPresentationUrl(_, _, Eq(url2), Eq(dpu_id)))
       .Times(1);
   service_impl_->SetDefaultPresentationURL(url2, dpu_id);
   EXPECT_EQ(url2, service_impl_->default_presentation_url_);
 
   it = contexts.find(url2);
   ASSERT_TRUE(it != contexts.end());
-  EXPECT_NE(nullptr, it->second->GetCallback());
+  EXPECT_TRUE(it->second->HasPendingCallbacks());
 }
 
 TEST_F(PresentationServiceImplTest, SetSameDefaultPresentationUrl) {
   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_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
@@ skipping 18 matching lines @@
   GetScreenAvailabilityAndWait(
       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_NE(nullptr, it->second->GetCallback());
+  EXPECT_TRUE(it->second->HasPendingCallbacks());
 
   // Clears the default presentation URL. Transfers the listener from url to
   // "1-UA" mode.
   EXPECT_CALL(
       mock_delegate_,
       AddScreenAvailabilityListener(_, _, _))
       .WillOnce(Return(true));
   EXPECT_CALL(
       mock_delegate_,
       RemoveScreenAvailabilityListener(_, _, _))
@@ skipping 122 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