[NTP Snippets] Remove scheduled re-scheduling

components/ntp_snippets/ntp_snippets_service_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 "components/ntp_snippets/ntp_snippets_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 242 matching lines @@
       int id, const GURL& url, net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* d) override {
     return base::MakeUnique<net::FakeURLFetcher>(
         url, d, /*response_data=*/std::string(), net::HTTP_NOT_FOUND,
         net::URLRequestStatus::FAILED);
   }
 };
 
 class MockScheduler : public NTPSnippetsScheduler {
  public:
-  MOCK_METHOD3(Schedule,
+  MOCK_METHOD2(Schedule,
                bool(base::TimeDelta period_wifi,
-                    base::TimeDelta period_fallback,
-                    base::Time reschedule_time));
+                    base::TimeDelta period_fallback));
   MOCK_METHOD0(Unschedule, bool());
 };
 
 class MockImageFetcher : public ImageFetcher {
  public:
   MOCK_METHOD1(SetImageFetcherDelegate, void(ImageFetcherDelegate*));
   MOCK_METHOD1(SetDataUseServiceName, void(DataUseServiceName));
   MOCK_METHOD3(
       StartOrQueueNetworkRequest,
       void(const std::string&,
@@ skipping 198 matching lines @@
 
   base::ScopedTempDir database_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPSnippetsServiceTest);
 };
 
 TEST_F(NTPSnippetsServiceTest, ScheduleOnStart) {
   // We should get two |Schedule| calls: The first when initialization
   // completes, the second one after the automatic (since the service doesn't
   // have any data yet) fetch finishes.
-  EXPECT_CALL(mock_scheduler(), Schedule(_, _, _)).Times(2);
+  EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   auto service = MakeSnippetsService();
 
   // When we have no snippets are all, loading the service initiates a fetch.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ("OK", service->snippets_fetcher()->last_status());
 }
 
 TEST_F(NTPSnippetsServiceTest, RescheduleAfterSuccessfulFetch) {
   // We should get two |Schedule| calls: The first when initialization
   // completes, the second one after the automatic (since the service doesn't
   // have any data yet) fetch finishes.
-  EXPECT_CALL(mock_scheduler(), Schedule(_, _, _)).Times(2);
+  EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   auto service = MakeSnippetsService();
   base::RunLoop().RunUntilIdle();
 
   // A successful fetch should trigger another |Schedule|.
-  EXPECT_CALL(mock_scheduler(), Schedule(_, _, _));
+  EXPECT_CALL(mock_scheduler(), Schedule(_, _));
   LoadFromJSONString(service.get(), GetTestJson({GetSnippet()}));
 }
 
 TEST_F(NTPSnippetsServiceTest, DontRescheduleAfterFailedFetch) {
   // We should get two |Schedule| calls: The first when initialization
   // completes, the second one after the automatic (since the service doesn't
   // have any data yet) fetch finishes.
-  EXPECT_CALL(mock_scheduler(), Schedule(_, _, _)).Times(2);
+  EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   auto service = MakeSnippetsService();
   base::RunLoop().RunUntilIdle();
 
   // A failed fetch should NOT trigger another |Schedule|.
-  EXPECT_CALL(mock_scheduler(), Schedule(_, _, _)).Times(0);
+  EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(0);
   LoadFromJSONString(service.get(), GetTestJson({GetInvalidSnippet()}));
 }
 
 TEST_F(NTPSnippetsServiceTest, DontRescheduleBeforeInit) {
   // We should get two |Schedule| calls: The first when initialization
   // completes, the second one after the automatic (since the service doesn't
   // have any data yet) fetch finishes.
-  EXPECT_CALL(mock_scheduler(), Schedule(_, _, _)).Times(2);
+  EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   // The |RescheduleFetching| call shouldn't do anything (in particular not
   // result in an |Unschedule|), since the service isn't initialized yet.
   EXPECT_CALL(mock_scheduler(), Unschedule()).Times(0);
   auto service = MakeSnippetsServiceWithoutInitialization();
   service->RescheduleFetching();
   WaitForSnippetsServiceInitialization();
 
   // Now that initialization has finished, |RescheduleFetching| should work.
-  EXPECT_CALL(mock_scheduler(), Schedule(_, _, _));
+  EXPECT_CALL(mock_scheduler(), Schedule(_, _));
   service->RescheduleFetching();
 }
 
 TEST_F(NTPSnippetsServiceTest, RescheduleOnStateChange) {
   {
     InSequence s;
     // Initial startup.
-    EXPECT_CALL(mock_scheduler(), Schedule(_, _, _)).Times(2);
+    EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
     // Service gets disabled.
     EXPECT_CALL(mock_scheduler(), Unschedule());
     // Service gets enabled again.
-    EXPECT_CALL(mock_scheduler(), Schedule(_, _, _)).Times(2);
+    EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   }
   auto service = MakeSnippetsService();
   ASSERT_TRUE(service->ready());
   base::RunLoop().RunUntilIdle();
 
   service->OnDisabledReasonChanged(DisabledReason::EXPLICITLY_DISABLED);
   ASSERT_FALSE(service->ready());
   base::RunLoop().RunUntilIdle();
 
   service->OnDisabledReasonChanged(DisabledReason::NONE);
@@ skipping 489 matching lines @@
              end = base::Time::FromTimeT(456);
   base::Callback<bool(const GURL& url)> filter;
   service->ClearHistory(begin, end, filter);
 
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
   EXPECT_THAT(service->GetDismissedSnippetsForTesting(articles_category()),
               IsEmpty());
 }
 
 }  // namespace ntp_snippets