[Offline Pages] Improve RequestCoordinator state tracking.

components/offline_pages/core/background/request_coordinator_unittest.cc

 // Copyright 2016 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/offline_pages/core/background/request_coordinator.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 100 matching lines @@
   bool completed_called_;
   bool changed_called_;
   bool network_progress_called_;
   int64_t network_progress_bytes_;
   RequestCoordinator::BackgroundSavePageResult last_status_;
   SavePageRequest::RequestState state_;
 };
 
 class RequestCoordinatorTest : public testing::Test {
  public:
+  using RequestCoordinatorState = RequestCoordinator::RequestCoordinatorState;
+
   RequestCoordinatorTest();
   ~RequestCoordinatorTest() override;
 
   void SetUp() override;
 
   void PumpLoop();
 
   RequestCoordinator* coordinator() const {
     return coordinator_taco_->request_coordinator();
   }
 
-  bool is_busy() { return coordinator()->is_busy(); }
-
-  bool is_starting() { return coordinator()->is_starting(); }
+  RequestCoordinatorState state() { return coordinator()->state(); }
 
   // Test processing callback function.
   void ProcessingCallbackFunction(bool result) {
     processing_callback_called_ = true;
     processing_callback_result_ = result;
   }
 
   // Callback function which releases a wait for it.
   void WaitingCallbackFunction(bool result) { waiter_.Signal(); }
 
@@ skipping 340 matching lines @@
 
   // Ensure that the forthcoming request does not finish - we simulate it being
   // in progress by asking it to skip making the completion callback.
   EnableOfflinerCallback(false);
 
   // Sending the request to the offliner should make it busy.
   EXPECT_TRUE(coordinator()->StartScheduledProcessing(device_conditions(),
                                                       processing_callback()));
   PumpLoop();
 
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
   // Since the offliner is disabled, this callback should not be called.
   EXPECT_FALSE(processing_callback_called());
 
   // Now trying to start processing should return false since already busy.
   EXPECT_FALSE(coordinator()->StartScheduledProcessing(device_conditions(),
                                                        processing_callback()));
 }
 
 TEST_F(RequestCoordinatorTest, StartImmediateProcessingWithNoRequests) {
   EXPECT_TRUE(coordinator()->StartImmediateProcessing(processing_callback()));
@@ skipping 28 matching lines @@
   // Start processing for this request.
   EXPECT_NE(0, SavePageLater());
 
   // Disable the automatic offliner callback.
   EnableOfflinerCallback(false);
 
   // Sending the request to the offliner should make it busy.
   EXPECT_TRUE(coordinator()->StartImmediateProcessing(processing_callback()));
   PumpLoop();
 
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
   // Since the offliner is disabled, this callback should not be called.
   EXPECT_FALSE(processing_callback_called());
 
   // Now trying to start processing should return false since already busy.
   EXPECT_FALSE(coordinator()->StartImmediateProcessing(processing_callback()));
 
   histograms().ExpectBucketCount("OfflinePages.Background.ImmediateStartStatus",
                                  1 /* BUSY */, 1);
 }
 
@@ skipping 134 matching lines @@
   // Disconnect network.
   SetNetworkConnected(false);
 
   // Call the OfflinerDoneCallback to simulate the page being completed, wait
   // for callbacks.
   SendOfflinerDoneCallback(request, Offliner::RequestStatus::SAVED);
   PumpLoop();
   EXPECT_TRUE(processing_callback_called());
 
   // Verify not busy with 2nd request (since no connection).
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
 
   // Now connect network and verify processing starts.
   SetNetworkConnected(true);
   CallConnectionTypeObserver();
   PumpLoop();
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 }
 
 TEST_F(RequestCoordinatorTest, OfflinerDoneRequestFailed) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
                                          base::Time::Now(), kUserRequested);
   request.set_completed_attempt_count(kMaxCompletedTries - 1);
   SetupForOfflinerDoneCallbackTest(&request);
   // Stop processing before completing the second request on the queue.
   EnableOfflinerCallback(false);
 
   // Add second request to the queue to check handling when first fails.
   AddRequest2();
   PumpLoop();
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(request, Offliner::RequestStatus::LOADING_FAILED);
   PumpLoop();
 
   // For retriable failure, processing should continue to 2nd request so
   // no scheduler callback yet.
   EXPECT_FALSE(processing_callback_called());
 
   // Busy processing 2nd request.
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Now just one request in the queue since failed request removed
   // (max number of attempts exceeded).
   EXPECT_EQ(1UL, last_requests().size());
   // Check that the observer got the notification that we failed (and the
   // subsequent notification that the request was removed) since we exceeded
@@ skipping 21 matching lines @@
   // for callbacks.
   SendOfflinerDoneCallback(request,
                            Offliner::RequestStatus::LOADING_FAILED_NO_RETRY);
   PumpLoop();
 
   // For no retry failure, processing should continue to 2nd request so
   // no scheduler callback yet.
   EXPECT_FALSE(processing_callback_called());
 
   // Busy processing 2nd request.
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Now just one request in the queue since non-retryable failure.
   EXPECT_EQ(1UL, last_requests().size());
   // Check that the observer got the notification that we failed (and the
   // subsequent notification that the request was removed).
   EXPECT_TRUE(observer().completed_called());
@@ skipping 16 matching lines @@
   // for callbacks.
   SendOfflinerDoneCallback(request,
                            Offliner::RequestStatus::LOADING_FAILED_NO_NEXT);
   PumpLoop();
 
   // For no next failure, processing should not continue to 2nd request so
   // expect scheduler callback.
   EXPECT_TRUE(processing_callback_called());
 
   // Not busy for NO_NEXT failure.
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
 
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Both requests still in queue.
   EXPECT_EQ(2UL, last_requests().size());
 }
 
 TEST_F(RequestCoordinatorTest, OfflinerDoneForegroundCancel) {
@@ skipping 43 matching lines @@
   const std::unique_ptr<SavePageRequest>& found_request =
       last_requests().front();
   EXPECT_EQ(0L, found_request->completed_attempt_count());
 }
 
 // If one item completes, and there are no more user requeted items left,
 // we should make a scheduler entry for a non-user requested item.
 TEST_F(RequestCoordinatorTest, RequestNotPickedDisabledItemsRemain) {
   coordinator()->StartScheduledProcessing(device_conditions(),
                                           processing_callback());
-  EXPECT_TRUE(is_starting());
+  EXPECT_TRUE(state() == RequestCoordinatorState::PICKING);
 
   // Call RequestNotPicked, simulating a request on the disabled list.
   CallRequestNotPicked(false, true);
   PumpLoop();
 
-  EXPECT_FALSE(is_starting());
+  EXPECT_FALSE(state() == RequestCoordinatorState::PICKING);
 
   // The scheduler should have been called to schedule the disabled task for
   // 5 minutes from now.
   SchedulerStub* scheduler_stub =
       reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->backup_schedule_called());
   EXPECT_TRUE(scheduler_stub->unschedule_called());
 }
 
 // If one item completes, and there are no more user requeted items left,
 // we should make a scheduler entry for a non-user requested item.
 TEST_F(RequestCoordinatorTest, RequestNotPickedNonUserRequestedItemsRemain) {
   coordinator()->StartScheduledProcessing(device_conditions(),
                                           processing_callback());
-  EXPECT_TRUE(is_starting());
+  EXPECT_TRUE(state() == RequestCoordinatorState::PICKING);
 
   // Call RequestNotPicked, and make sure we pick schedule a task for non user
   // requested conditions, with no tasks on the disabled list.
   CallRequestNotPicked(true, false);
   PumpLoop();
 
-  EXPECT_FALSE(is_starting());
+  EXPECT_FALSE(state() == RequestCoordinatorState::PICKING);
   EXPECT_TRUE(processing_callback_called());
 
   // The scheduler should have been called to schedule the non-user requested
   // task.
   SchedulerStub* scheduler_stub =
       reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->schedule_called());
   EXPECT_TRUE(scheduler_stub->unschedule_called());
   const Scheduler::TriggerConditions* conditions =
       scheduler_stub->trigger_conditions();
@@ skipping 42 matching lines @@
   PumpLoop();
 
   DisableLoading();
   EXPECT_TRUE(coordinator()->StartScheduledProcessing(device_conditions(),
                                                       processing_callback()));
 
   // Let the async callbacks in the request coordinator run.
   PumpLoop();
   EXPECT_TRUE(processing_callback_called());
 
-  EXPECT_FALSE(is_starting());
+  EXPECT_FALSE(state() == RequestCoordinatorState::PICKING);
   EXPECT_EQ(Offliner::LOADING_NOT_ACCEPTED, last_offlining_status());
 }
 
 // TODO(dougarnett): Add StartScheduledProcessing test for QUEUE_UPDATE_FAILED.
 
 // This tests a StopProcessing call before we have actually started the
 // offliner.
 TEST_F(RequestCoordinatorTest,
        StartScheduledProcessingThenStopProcessingImmediately) {
   // Add a request to the queue, wait for callbacks to finish.
   AddRequest1();
   PumpLoop();
 
   EXPECT_TRUE(coordinator()->StartScheduledProcessing(device_conditions(),
                                                       processing_callback()));
-  EXPECT_TRUE(is_starting());
+  EXPECT_TRUE(state() == RequestCoordinatorState::PICKING);
 
   // Now, quick, before it can do much (we haven't called PumpLoop), cancel it.
   coordinator()->StopProcessing(Offliner::REQUEST_COORDINATOR_CANCELED);
 
   // Let the async callbacks in the request coordinator run.
   PumpLoop();
   EXPECT_TRUE(processing_callback_called());
 
-  EXPECT_FALSE(is_starting());
+  EXPECT_FALSE(state() == RequestCoordinatorState::PICKING);
 
   // OfflinerDoneCallback will not end up getting called with status SAVED,
   // since we cancelled the event before it called offliner_->LoadAndSave().
   EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
             last_offlining_status());
 
   // Since offliner was not started, it will not have seen cancel call.
   EXPECT_FALSE(OfflinerWasCanceled());
 }
 
 // This tests a StopProcessing call after the prerenderer has been started.
 TEST_F(RequestCoordinatorTest,
        StartScheduledProcessingThenStopProcessingLater) {
   // Add a request to the queue, wait for callbacks to finish.
   AddRequest1();
   PumpLoop();
 
   // Ensure the start processing request stops before the completion callback.
   EnableOfflinerCallback(false);
 
   EXPECT_TRUE(coordinator()->StartScheduledProcessing(device_conditions(),
                                                       processing_callback()));
-  EXPECT_TRUE(is_starting());
+  EXPECT_TRUE(state() == RequestCoordinatorState::PICKING);
 
   // Let all the async parts of the start processing pipeline run to completion.
   PumpLoop();
 
   // Observer called for starting processing.
   EXPECT_TRUE(observer().changed_called());
   EXPECT_EQ(SavePageRequest::RequestState::OFFLINING, observer().state());
   observer().Clear();
 
   // Since the offliner is disabled, this callback should not be called.
   EXPECT_FALSE(processing_callback_called());
 
   // Coordinator should now be busy.
-  EXPECT_TRUE(is_busy());
-  EXPECT_FALSE(is_starting());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
+  EXPECT_FALSE(state() == RequestCoordinatorState::PICKING);
 
   // Now we cancel it while the prerenderer is busy.
   coordinator()->StopProcessing(Offliner::REQUEST_COORDINATOR_CANCELED);
 
   // Let the async callbacks in the cancel run.
   PumpLoop();
 
   // Observer called for stopped processing.
   EXPECT_TRUE(observer().changed_called());
   EXPECT_EQ(SavePageRequest::RequestState::AVAILABLE, observer().state());
   observer().Clear();
 
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
 
   // OfflinerDoneCallback will not end up getting called with status SAVED,
   // since we cancelled the event before the LoadAndSave completed.
   EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
             last_offlining_status());
 
   // Since offliner was started, it will have seen cancel call.
   EXPECT_TRUE(OfflinerWasCanceled());
 }
 
@@ skipping 111 matching lines @@
           ->GetSinglePageTimeLimitWhenBackgroundScheduledInSeconds() +
       1));
   PumpLoop();
 
   // Wait for timeout to expire.  Use a TaskRunner with a DelayedTaskRunner
   // which won't time out immediately, so the watchdog thread doesn't kill valid
   // tasks too soon.
   WaitForCallback();
   PumpLoop();
 
-  EXPECT_FALSE(is_starting());
-  EXPECT_FALSE(coordinator()->is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::PICKING);
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
   EXPECT_TRUE(OfflinerWasCanceled());
 }
 
 TEST_F(RequestCoordinatorTest,
        WatchdogTimeoutForImmediateProcessingNoLastSnapshot) {
   // Ensure that the new request does not finish - we simulate it being
   // in progress by asking it to skip making the completion callback.
   EnableOfflinerCallback(false);
 
   EXPECT_NE(0, SavePageLater());
   PumpLoop();
 
   // Verify that immediate start from adding the request did happen.
-  EXPECT_TRUE(coordinator()->is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 
   // Advance the mock clock 1 second before the watchdog timeout.
   AdvanceClockBy(base::TimeDelta::FromSeconds(
       coordinator()
           ->policy()
           ->GetSinglePageTimeLimitForImmediateLoadInSeconds() -
       1));
   PumpLoop();
 
   // Verify still busy.
-  EXPECT_TRUE(coordinator()->is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
   EXPECT_FALSE(OfflinerWasCanceled());
 
   // Advance the mock clock past the watchdog timeout now.
   AdvanceClockBy(base::TimeDelta::FromSeconds(2));
   PumpLoop();
 
   // Verify the request timed out.
   EXPECT_TRUE(OfflinerWasCanceled());
 }
 
@@ skipping 43 matching lines @@
   AddRequest2();
   PumpLoop();
 
   // Set up for the call to StartScheduledProcessing.
   EnableOfflinerCallback(false);
 
   // Sending the request to the offliner.
   EXPECT_TRUE(coordinator()->StartScheduledProcessing(device_conditions(),
                                                       waiting_callback()));
   PumpLoop();
-  EXPECT_TRUE(coordinator()->is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 
   // Now lose the network connection.
   SetNetworkConnected(false);
 
   // Complete first request and then TryNextRequest should decide not
   // to pick another request (because of no network connection).
   SendOfflinerDoneCallback(request1, Offliner::RequestStatus::SAVED);
   PumpLoop();
 
   // Not starting nor busy with next request.
-  EXPECT_FALSE(coordinator()->is_starting());
-  EXPECT_FALSE(coordinator()->is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::PICKING);
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
 
   // Get queued requests.
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // We should find one request in the queue.
   EXPECT_EQ(1UL, last_requests().size());
 }
 
@@ skipping 83 matching lines @@
 }
 
 TEST_F(RequestCoordinatorTest,
        SavePageStartsProcessingWhenConnectedAndNotLowEndDevice) {
   // Turn off the callback so that the request stops before processing in
   // PumpLoop.
   EnableOfflinerCallback(false);
   EXPECT_NE(0, SavePageLater());
   PumpLoop();
 
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 }
 
 TEST_F(RequestCoordinatorTest,
        SavePageStartsProcessingWhenConnectedOnLowEndDeviceIfFlagEnabled) {
   // Mark device as low-end device.
   SetIsLowEndDeviceForTest(true);
   EXPECT_FALSE(offline_pages::IsOfflinePagesSvelteConcurrentLoadingEnabled());
 
   // Make a request.
   EXPECT_NE(0, SavePageLater());
   PumpLoop();
 
   // Verify not immediately busy (since low-end device).
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
 
   // Set feature flag to allow concurrent loads.
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       kOfflinePagesSvelteConcurrentLoadingFeature);
   EXPECT_TRUE(offline_pages::IsOfflinePagesSvelteConcurrentLoadingEnabled());
 
   // Turn off the callback so that the request stops before processing in
   // PumpLoop.
   EnableOfflinerCallback(false);
 
   // Make another request.
   RequestCoordinator::SavePageLaterParams params;
   params.url = kUrl2;
   params.client_id = kClientId2;
   params.user_requested = kUserRequested;
   EXPECT_NE(0, coordinator()->SavePageLater(params));
   PumpLoop();
 
   // Verify immediate processing did start this time.
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 }
 
 TEST_F(RequestCoordinatorTest, SavePageDoesntStartProcessingWhenDisconnected) {
   SetNetworkConnected(false);
   EnableOfflinerCallback(false);
   EXPECT_NE(0, SavePageLater());
   PumpLoop();
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
 
   // Now connect network and verify processing starts.
   SetNetworkConnected(true);
   CallConnectionTypeObserver();
   PumpLoop();
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 }
 
 TEST_F(RequestCoordinatorTest,
        SavePageDoesStartProcessingWhenPoorlyConnected) {
   // Set specific network type for 2G with poor effective connection.
   DeviceConditions device_conditions(!kPowerRequired, kBatteryPercentageHigh,
                                      net::NetworkChangeNotifier::CONNECTION_2G);
   SetDeviceConditionsForTest(device_conditions);
   SetEffectiveConnectionTypeForTest(
       net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
 
   // Turn off the callback so that the request stops before processing in
   // PumpLoop.
   EnableOfflinerCallback(false);
 
   EXPECT_NE(0, SavePageLater());
   PumpLoop();
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 }
 
 TEST_F(RequestCoordinatorTest,
        ResumeStartsProcessingWhenConnectedAndNotLowEndDevice) {
   // Start unconnected.
   SetNetworkConnected(false);
 
   // Turn off the callback so that the request stops before processing in
   // PumpLoop.
   EnableOfflinerCallback(false);
 
   // Add a request to the queue.
   AddRequest1();
   PumpLoop();
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
 
   // Pause the request.
   std::vector<int64_t> request_ids;
   request_ids.push_back(kRequestId1);
   coordinator()->PauseRequests(request_ids);
   PumpLoop();
 
   // Resume the request while disconnected.
   coordinator()->ResumeRequests(request_ids);
   PumpLoop();
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
   EXPECT_EQ(1UL, prioritized_requests().size());
 
   // Pause the request again.
   coordinator()->PauseRequests(request_ids);
   PumpLoop();
   EXPECT_EQ(0UL, prioritized_requests().size());
 
   // Now simulate reasonable connection.
   SetNetworkConnected(true);
 
   // Resume the request while connected.
   coordinator()->ResumeRequests(request_ids);
-  EXPECT_FALSE(is_busy());
+  EXPECT_FALSE(state() == RequestCoordinatorState::OFFLINING);
   PumpLoop();
   EXPECT_EQ(1UL, prioritized_requests().size());
 
-  EXPECT_TRUE(is_busy());
+  EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 }
 
 TEST_F(RequestCoordinatorTest, SnapshotOnLastTryForScheduledProcessing) {
   // Build a request to use with the pre-renderer, and put it on the queue.
   offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
                                          base::Time::Now(), kUserRequested);
   // Set request to allow one more completed attempt. So that the next try would
   // be the last retry.
   int max_tries = coordinator()->policy()->GetMaxCompletedTries();
   request.set_completed_attempt_count(max_tries - 1);
@@ skipping 45 matching lines @@
   // Repeat the timeout for MaxCompleteTries - 1 times in order to increase the
   // completed tries on this request.
   int max_tries = coordinator()->policy()->GetMaxCompletedTries();
   for (int i = 0; i < max_tries - 1; i++) {
     PumpLoop();
     // Reset states.
     ResetOfflinerWasCanceled();
     observer().Clear();
 
     // Verify that the request is being processed.
-    EXPECT_TRUE(coordinator()->is_busy());
+    EXPECT_TRUE(state() == RequestCoordinatorState::OFFLINING);
 
     // Advance the mock clock 1 second more than the watchdog timeout.
     AdvanceClockBy(base::TimeDelta::FromSeconds(
         coordinator()
             ->policy()
             ->GetSinglePageTimeLimitForImmediateLoadInSeconds() +
         1));
     PumpLoop();
 
     // Verify the request timed out.
@@ skipping 16 matching lines @@
   PumpLoop();
 
   // The last time would trigger the snapshot on last retry and succeed.
   EXPECT_FALSE(OfflinerWasCanceled());
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::SUCCESS,
             observer().last_status());
   EXPECT_TRUE(observer().completed_called());
 }
 
 }  // namespace offline_pages