| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/offline_pages/background/pick_request_task.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 #include <set> | |
| 9 | |
| 10 #include "base/bind.h" | |
| 11 #include "base/test/test_simple_task_runner.h" | |
| 12 #include "base/threading/thread_task_runner_handle.h" | |
| 13 #include "components/offline_pages/background/device_conditions.h" | |
| 14 #include "components/offline_pages/background/offliner_policy.h" | |
| 15 #include "components/offline_pages/background/request_coordinator.h" | |
| 16 #include "components/offline_pages/background/request_coordinator_event_logger.h
" | |
| 17 #include "components/offline_pages/background/request_notifier.h" | |
| 18 #include "components/offline_pages/background/request_queue_in_memory_store.h" | |
| 19 #include "components/offline_pages/background/request_queue_store.h" | |
| 20 #include "components/offline_pages/background/save_page_request.h" | |
| 21 #include "testing/gtest/include/gtest/gtest.h" | |
| 22 | |
| 23 namespace offline_pages { | |
| 24 | |
| 25 namespace { | |
| 26 // Data for request 1. | |
| 27 const int64_t kRequestId1 = 17; | |
| 28 const GURL kUrl1("https://google.com"); | |
| 29 const ClientId kClientId1("bookmark", "1234"); | |
| 30 // Data for request 2. | |
| 31 const int64_t kRequestId2 = 42; | |
| 32 const GURL kUrl2("http://nytimes.com"); | |
| 33 const ClientId kClientId2("bookmark", "5678"); | |
| 34 const bool kUserRequested = true; | |
| 35 const int kAttemptCount = 1; | |
| 36 const int kMaxStartedTries = 5; | |
| 37 const int kMaxCompletedTries = 1; | |
| 38 | |
| 39 // Constants for policy values - These settings represent the default values. | |
| 40 const bool kPreferUntried = false; | |
| 41 const bool kPreferEarlier = true; | |
| 42 const bool kPreferRetryCount = true; | |
| 43 const int kBackgroundProcessingTimeBudgetSeconds = 170; | |
| 44 | |
| 45 // Default request | |
| 46 const SavePageRequest kEmptyRequest(0UL, | |
| 47 GURL(""), | |
| 48 ClientId("", ""), | |
| 49 base::Time(), | |
| 50 true); | |
| 51 } // namespace | |
| 52 | |
| 53 // Helper class needed by the PickRequestTask | |
| 54 class RequestNotifierStub : public RequestNotifier { | |
| 55 public: | |
| 56 RequestNotifierStub() | |
| 57 : last_expired_request_(kEmptyRequest), total_expired_requests_(0) {} | |
| 58 | |
| 59 void NotifyAdded(const SavePageRequest& request) override {} | |
| 60 void NotifyChanged(const SavePageRequest& request) override {} | |
| 61 | |
| 62 void NotifyCompleted(const SavePageRequest& request, | |
| 63 BackgroundSavePageResult status) override { | |
| 64 last_expired_request_ = request; | |
| 65 last_request_expiration_status_ = status; | |
| 66 total_expired_requests_++; | |
| 67 } | |
| 68 | |
| 69 const SavePageRequest& last_expired_request() { | |
| 70 return last_expired_request_; | |
| 71 } | |
| 72 | |
| 73 RequestCoordinator::BackgroundSavePageResult | |
| 74 last_request_expiration_status() { | |
| 75 return last_request_expiration_status_; | |
| 76 } | |
| 77 | |
| 78 int32_t total_expired_requests() { return total_expired_requests_; } | |
| 79 | |
| 80 private: | |
| 81 BackgroundSavePageResult last_request_expiration_status_; | |
| 82 SavePageRequest last_expired_request_; | |
| 83 int32_t total_expired_requests_; | |
| 84 }; | |
| 85 | |
| 86 class PickRequestTaskTest : public testing::Test { | |
| 87 public: | |
| 88 PickRequestTaskTest(); | |
| 89 | |
| 90 ~PickRequestTaskTest() override; | |
| 91 | |
| 92 void SetUp() override; | |
| 93 | |
| 94 void PumpLoop(); | |
| 95 | |
| 96 void AddRequestDone(ItemActionStatus status); | |
| 97 | |
| 98 void RequestPicked(const SavePageRequest& request, bool cleanup_needed); | |
| 99 | |
| 100 void RequestNotPicked(const bool non_user_requested_tasks_remaining, | |
| 101 bool cleanup_needed); | |
| 102 | |
| 103 void RequestCountCallback(size_t total_count, size_t available_count); | |
| 104 | |
| 105 void QueueRequests(const SavePageRequest& request1, | |
| 106 const SavePageRequest& request2); | |
| 107 | |
| 108 // Reset the factory and the task using the current policy. | |
| 109 void MakePickRequestTask(); | |
| 110 | |
| 111 RequestNotifierStub* GetNotifier() { return notifier_.get(); } | |
| 112 | |
| 113 PickRequestTask* task() { return task_.get(); } | |
| 114 | |
| 115 void TaskCompletionCallback(Task* completed_task); | |
| 116 | |
| 117 protected: | |
| 118 void InitializeStoreDone(bool success); | |
| 119 | |
| 120 std::unique_ptr<RequestQueueStore> store_; | |
| 121 std::unique_ptr<RequestNotifierStub> notifier_; | |
| 122 std::unique_ptr<SavePageRequest> last_picked_; | |
| 123 std::unique_ptr<OfflinerPolicy> policy_; | |
| 124 RequestCoordinatorEventLogger event_logger_; | |
| 125 std::set<int64_t> disabled_requests_; | |
| 126 std::unique_ptr<PickRequestTask> task_; | |
| 127 bool request_queue_not_picked_called_; | |
| 128 bool cleanup_needed_; | |
| 129 size_t total_request_count_; | |
| 130 size_t available_request_count_; | |
| 131 bool task_complete_called_; | |
| 132 | |
| 133 private: | |
| 134 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
| 135 base::ThreadTaskRunnerHandle task_runner_handle_; | |
| 136 }; | |
| 137 | |
| 138 PickRequestTaskTest::PickRequestTaskTest() | |
| 139 : task_runner_(new base::TestSimpleTaskRunner), | |
| 140 task_runner_handle_(task_runner_) {} | |
| 141 | |
| 142 PickRequestTaskTest::~PickRequestTaskTest() {} | |
| 143 | |
| 144 void PickRequestTaskTest::SetUp() { | |
| 145 DeviceConditions conditions; | |
| 146 store_.reset(new RequestQueueInMemoryStore()); | |
| 147 policy_.reset(new OfflinerPolicy()); | |
| 148 notifier_.reset(new RequestNotifierStub()); | |
| 149 MakePickRequestTask(); | |
| 150 request_queue_not_picked_called_ = false; | |
| 151 total_request_count_ = 9999; | |
| 152 available_request_count_ = 9999; | |
| 153 task_complete_called_ = false; | |
| 154 last_picked_.reset(); | |
| 155 cleanup_needed_ = false; | |
| 156 | |
| 157 store_->Initialize(base::Bind(&PickRequestTaskTest::InitializeStoreDone, | |
| 158 base::Unretained(this))); | |
| 159 PumpLoop(); | |
| 160 } | |
| 161 | |
| 162 void PickRequestTaskTest::PumpLoop() { | |
| 163 task_runner_->RunUntilIdle(); | |
| 164 } | |
| 165 | |
| 166 void PickRequestTaskTest::TaskCompletionCallback(Task* completed_task) { | |
| 167 task_complete_called_ = true; | |
| 168 } | |
| 169 | |
| 170 void PickRequestTaskTest::AddRequestDone(ItemActionStatus status) {} | |
| 171 | |
| 172 void PickRequestTaskTest::RequestPicked(const SavePageRequest& request, | |
| 173 const bool cleanup_needed) { | |
| 174 last_picked_.reset(new SavePageRequest(request)); | |
| 175 cleanup_needed_ = cleanup_needed; | |
| 176 } | |
| 177 | |
| 178 void PickRequestTaskTest::RequestNotPicked( | |
| 179 const bool non_user_requested_tasks_remaining, | |
| 180 const bool cleanup_needed) { | |
| 181 request_queue_not_picked_called_ = true; | |
| 182 } | |
| 183 | |
| 184 void PickRequestTaskTest::RequestCountCallback(size_t total_count, | |
| 185 size_t available_count) { | |
| 186 total_request_count_ = total_count; | |
| 187 available_request_count_ = available_count; | |
| 188 } | |
| 189 | |
| 190 // Test helper to queue the two given requests. | |
| 191 void PickRequestTaskTest::QueueRequests(const SavePageRequest& request1, | |
| 192 const SavePageRequest& request2) { | |
| 193 DeviceConditions conditions; | |
| 194 std::set<int64_t> disabled_requests; | |
| 195 // Add test requests on the Queue. | |
| 196 store_->AddRequest(request1, base::Bind(&PickRequestTaskTest::AddRequestDone, | |
| 197 base::Unretained(this))); | |
| 198 store_->AddRequest(request2, base::Bind(&PickRequestTaskTest::AddRequestDone, | |
| 199 base::Unretained(this))); | |
| 200 | |
| 201 // Pump the loop to give the async queue the opportunity to do the adds. | |
| 202 PumpLoop(); | |
| 203 } | |
| 204 | |
| 205 void PickRequestTaskTest::MakePickRequestTask() { | |
| 206 DeviceConditions conditions; | |
| 207 task_.reset(new PickRequestTask( | |
| 208 store_.get(), policy_.get(), | |
| 209 base::Bind(&PickRequestTaskTest::RequestPicked, base::Unretained(this)), | |
| 210 base::Bind(&PickRequestTaskTest::RequestNotPicked, | |
| 211 base::Unretained(this)), | |
| 212 base::Bind(&PickRequestTaskTest::RequestCountCallback, | |
| 213 base::Unretained(this)), | |
| 214 conditions, disabled_requests_)); | |
| 215 task_->SetTaskCompletionCallbackForTesting( | |
| 216 task_runner_.get(), | |
| 217 base::Bind(&PickRequestTaskTest::TaskCompletionCallback, | |
| 218 base::Unretained(this))); | |
| 219 } | |
| 220 | |
| 221 void PickRequestTaskTest::InitializeStoreDone(bool success) { | |
| 222 ASSERT_TRUE(success); | |
| 223 } | |
| 224 | |
| 225 TEST_F(PickRequestTaskTest, PickFromEmptyQueue) { | |
| 226 task()->Run(); | |
| 227 PumpLoop(); | |
| 228 | |
| 229 // Pump the loop again to give the async queue the opportunity to return | |
| 230 // results from the Get operation, and for the picker to call the "QueueEmpty" | |
| 231 // callback. | |
| 232 PumpLoop(); | |
| 233 | |
| 234 EXPECT_TRUE(request_queue_not_picked_called_); | |
| 235 EXPECT_EQ(0UL, total_request_count_); | |
| 236 EXPECT_EQ(0UL, available_request_count_); | |
| 237 EXPECT_TRUE(task_complete_called_); | |
| 238 } | |
| 239 | |
| 240 TEST_F(PickRequestTaskTest, ChooseRequestWithHigherRetryCount) { | |
| 241 // Set up policy to prefer higher retry count. | |
| 242 policy_.reset(new OfflinerPolicy( | |
| 243 kPreferUntried, kPreferEarlier, kPreferRetryCount, kMaxStartedTries, | |
| 244 kMaxCompletedTries + 1, kBackgroundProcessingTimeBudgetSeconds)); | |
| 245 MakePickRequestTask(); | |
| 246 | |
| 247 base::Time creation_time = base::Time::Now(); | |
| 248 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 249 kUserRequested); | |
| 250 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
| 251 kUserRequested); | |
| 252 request2.set_completed_attempt_count(kAttemptCount); | |
| 253 | |
| 254 QueueRequests(request1, request2); | |
| 255 | |
| 256 task()->Run(); | |
| 257 PumpLoop(); | |
| 258 | |
| 259 EXPECT_EQ(kRequestId2, last_picked_->request_id()); | |
| 260 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 261 EXPECT_EQ(2UL, total_request_count_); | |
| 262 EXPECT_EQ(2UL, available_request_count_); | |
| 263 EXPECT_TRUE(task_complete_called_); | |
| 264 } | |
| 265 | |
| 266 TEST_F(PickRequestTaskTest, ChooseRequestWithSameRetryCountButEarlier) { | |
| 267 base::Time creation_time1 = | |
| 268 base::Time::Now() - base::TimeDelta::FromSeconds(10); | |
| 269 base::Time creation_time2 = base::Time::Now(); | |
| 270 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time1, | |
| 271 kUserRequested); | |
| 272 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time2, | |
| 273 kUserRequested); | |
| 274 | |
| 275 QueueRequests(request1, request2); | |
| 276 | |
| 277 task()->Run(); | |
| 278 PumpLoop(); | |
| 279 | |
| 280 EXPECT_EQ(kRequestId1, last_picked_->request_id()); | |
| 281 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 282 EXPECT_TRUE(task_complete_called_); | |
| 283 } | |
| 284 | |
| 285 TEST_F(PickRequestTaskTest, ChooseEarlierRequest) { | |
| 286 // We need a custom policy object prefering recency to retry count. | |
| 287 policy_.reset(new OfflinerPolicy( | |
| 288 kPreferUntried, kPreferEarlier, !kPreferRetryCount, kMaxStartedTries, | |
| 289 kMaxCompletedTries, kBackgroundProcessingTimeBudgetSeconds)); | |
| 290 MakePickRequestTask(); | |
| 291 | |
| 292 base::Time creation_time1 = | |
| 293 base::Time::Now() - base::TimeDelta::FromSeconds(10); | |
| 294 base::Time creation_time2 = base::Time::Now(); | |
| 295 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time1, | |
| 296 kUserRequested); | |
| 297 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time2, | |
| 298 kUserRequested); | |
| 299 request2.set_completed_attempt_count(kAttemptCount); | |
| 300 | |
| 301 QueueRequests(request1, request2); | |
| 302 | |
| 303 task()->Run(); | |
| 304 PumpLoop(); | |
| 305 | |
| 306 EXPECT_EQ(kRequestId1, last_picked_->request_id()); | |
| 307 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 308 EXPECT_TRUE(task_complete_called_); | |
| 309 } | |
| 310 | |
| 311 TEST_F(PickRequestTaskTest, ChooseSameTimeRequestWithHigherRetryCount) { | |
| 312 // We need a custom policy object preferring recency to retry count. | |
| 313 policy_.reset(new OfflinerPolicy( | |
| 314 kPreferUntried, kPreferEarlier, !kPreferRetryCount, kMaxStartedTries, | |
| 315 kMaxCompletedTries + 1, kBackgroundProcessingTimeBudgetSeconds)); | |
| 316 MakePickRequestTask(); | |
| 317 | |
| 318 base::Time creation_time = base::Time::Now(); | |
| 319 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 320 kUserRequested); | |
| 321 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
| 322 kUserRequested); | |
| 323 request2.set_completed_attempt_count(kAttemptCount); | |
| 324 | |
| 325 QueueRequests(request1, request2); | |
| 326 | |
| 327 task()->Run(); | |
| 328 PumpLoop(); | |
| 329 | |
| 330 EXPECT_EQ(kRequestId2, last_picked_->request_id()); | |
| 331 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 332 EXPECT_TRUE(task_complete_called_); | |
| 333 } | |
| 334 | |
| 335 TEST_F(PickRequestTaskTest, ChooseRequestWithLowerRetryCount) { | |
| 336 // We need a custom policy object preferring lower retry count. | |
| 337 policy_.reset(new OfflinerPolicy( | |
| 338 !kPreferUntried, kPreferEarlier, kPreferRetryCount, kMaxStartedTries, | |
| 339 kMaxCompletedTries + 1, kBackgroundProcessingTimeBudgetSeconds)); | |
| 340 MakePickRequestTask(); | |
| 341 | |
| 342 base::Time creation_time = base::Time::Now(); | |
| 343 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 344 kUserRequested); | |
| 345 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
| 346 kUserRequested); | |
| 347 request2.set_completed_attempt_count(kAttemptCount); | |
| 348 | |
| 349 QueueRequests(request1, request2); | |
| 350 | |
| 351 task()->Run(); | |
| 352 PumpLoop(); | |
| 353 | |
| 354 EXPECT_EQ(kRequestId1, last_picked_->request_id()); | |
| 355 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 356 EXPECT_TRUE(task_complete_called_); | |
| 357 } | |
| 358 | |
| 359 TEST_F(PickRequestTaskTest, ChooseLaterRequest) { | |
| 360 // We need a custom policy preferring recency over retry, and later requests. | |
| 361 policy_.reset(new OfflinerPolicy( | |
| 362 kPreferUntried, !kPreferEarlier, !kPreferRetryCount, kMaxStartedTries, | |
| 363 kMaxCompletedTries, kBackgroundProcessingTimeBudgetSeconds)); | |
| 364 MakePickRequestTask(); | |
| 365 | |
| 366 base::Time creation_time1 = | |
| 367 base::Time::Now() - base::TimeDelta::FromSeconds(10); | |
| 368 base::Time creation_time2 = base::Time::Now(); | |
| 369 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time1, | |
| 370 kUserRequested); | |
| 371 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time2, | |
| 372 kUserRequested); | |
| 373 | |
| 374 QueueRequests(request1, request2); | |
| 375 | |
| 376 task()->Run(); | |
| 377 PumpLoop(); | |
| 378 | |
| 379 EXPECT_EQ(kRequestId2, last_picked_->request_id()); | |
| 380 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 381 EXPECT_TRUE(task_complete_called_); | |
| 382 } | |
| 383 | |
| 384 TEST_F(PickRequestTaskTest, ChooseNonExpiredRequest) { | |
| 385 base::Time creation_time = base::Time::Now(); | |
| 386 base::Time expired_time = | |
| 387 creation_time - base::TimeDelta::FromSeconds( | |
| 388 policy_->GetRequestExpirationTimeInSeconds() + 60); | |
| 389 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 390 kUserRequested); | |
| 391 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, expired_time, | |
| 392 kUserRequested); | |
| 393 | |
| 394 QueueRequests(request1, request2); | |
| 395 | |
| 396 task()->Run(); | |
| 397 PumpLoop(); | |
| 398 | |
| 399 EXPECT_EQ(kRequestId1, last_picked_->request_id()); | |
| 400 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 401 EXPECT_EQ(2UL, total_request_count_); | |
| 402 EXPECT_EQ(1UL, available_request_count_); | |
| 403 EXPECT_TRUE(task_complete_called_); | |
| 404 EXPECT_TRUE(cleanup_needed_); | |
| 405 } | |
| 406 | |
| 407 TEST_F(PickRequestTaskTest, ChooseRequestThatHasNotExceededStartLimit) { | |
| 408 base::Time creation_time1 = | |
| 409 base::Time::Now() - base::TimeDelta::FromSeconds(1); | |
| 410 base::Time creation_time2 = base::Time::Now(); | |
| 411 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time1, | |
| 412 kUserRequested); | |
| 413 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time2, | |
| 414 kUserRequested); | |
| 415 | |
| 416 // With default policy settings, we should choose the earlier request. | |
| 417 // However, we will make the earlier reqeust exceed the limit. | |
| 418 request1.set_started_attempt_count(policy_->GetMaxStartedTries()); | |
| 419 | |
| 420 QueueRequests(request1, request2); | |
| 421 | |
| 422 task()->Run(); | |
| 423 PumpLoop(); | |
| 424 | |
| 425 EXPECT_EQ(kRequestId2, last_picked_->request_id()); | |
| 426 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 427 EXPECT_EQ(2UL, total_request_count_); | |
| 428 EXPECT_EQ(1UL, available_request_count_); | |
| 429 EXPECT_TRUE(task_complete_called_); | |
| 430 EXPECT_TRUE(cleanup_needed_); | |
| 431 } | |
| 432 | |
| 433 TEST_F(PickRequestTaskTest, ChooseRequestThatHasNotExceededCompletionLimit) { | |
| 434 base::Time creation_time1 = | |
| 435 base::Time::Now() - base::TimeDelta::FromSeconds(1); | |
| 436 base::Time creation_time2 = base::Time::Now(); | |
| 437 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time1, | |
| 438 kUserRequested); | |
| 439 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time2, | |
| 440 kUserRequested); | |
| 441 | |
| 442 // With default policy settings, we should choose the earlier request. | |
| 443 // However, we will make the earlier reqeust exceed the limit. | |
| 444 request1.set_completed_attempt_count(policy_->GetMaxCompletedTries()); | |
| 445 | |
| 446 QueueRequests(request1, request2); | |
| 447 | |
| 448 task()->Run(); | |
| 449 PumpLoop(); | |
| 450 | |
| 451 EXPECT_EQ(kRequestId2, last_picked_->request_id()); | |
| 452 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 453 EXPECT_TRUE(task_complete_called_); | |
| 454 EXPECT_TRUE(cleanup_needed_); | |
| 455 } | |
| 456 | |
| 457 TEST_F(PickRequestTaskTest, ChooseRequestThatIsNotDisabled) { | |
| 458 policy_.reset(new OfflinerPolicy( | |
| 459 kPreferUntried, kPreferEarlier, kPreferRetryCount, kMaxStartedTries, | |
| 460 kMaxCompletedTries + 1, kBackgroundProcessingTimeBudgetSeconds)); | |
| 461 | |
| 462 // put request 2 on disabled list, ensure request1 picked instead, | |
| 463 // even though policy would prefer 2. | |
| 464 disabled_requests_.insert(kRequestId2); | |
| 465 MakePickRequestTask(); | |
| 466 | |
| 467 base::Time creation_time = base::Time::Now(); | |
| 468 SavePageRequest request1(kRequestId1, kUrl1, kClientId1, creation_time, | |
| 469 kUserRequested); | |
| 470 SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time, | |
| 471 kUserRequested); | |
| 472 request2.set_completed_attempt_count(kAttemptCount); | |
| 473 | |
| 474 // Add test requests on the Queue. | |
| 475 QueueRequests(request1, request2); | |
| 476 | |
| 477 task()->Run(); | |
| 478 PumpLoop(); | |
| 479 | |
| 480 // Pump the loop again to give the async queue the opportunity to return | |
| 481 // results from the Get operation, and for the picker to call the "picked" | |
| 482 // callback. | |
| 483 PumpLoop(); | |
| 484 | |
| 485 EXPECT_EQ(kRequestId1, last_picked_->request_id()); | |
| 486 EXPECT_FALSE(request_queue_not_picked_called_); | |
| 487 EXPECT_EQ(2UL, total_request_count_); | |
| 488 EXPECT_EQ(1UL, available_request_count_); | |
| 489 EXPECT_TRUE(task_complete_called_); | |
| 490 } | |
| 491 | |
| 492 } // namespace offline_pages | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2489443002:
Move all components/offline_pages/ files into component/offline_pages/core (Closed)
