Move all components/offline_pages/ files into component/offline_pages/core

components/offline_pages/core/background/request_queue_store_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/background/request_queue_store.h"
+#include "components/offline_pages/core/background/request_queue_store.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "components/offline_pages/background/request_queue.h"
-#include "components/offline_pages/background/request_queue_in_memory_store.h"
-#include "components/offline_pages/background/request_queue_store_sql.h"
-#include "components/offline_pages/background/save_page_request.h"
+#include "components/offline_pages/core/background/request_queue.h"
+#include "components/offline_pages/core/background/request_queue_in_memory_store.h"
+#include "components/offline_pages/core/background/request_queue_store_sql.h"
+#include "components/offline_pages/core/background/save_page_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 using UpdateStatus = RequestQueueStore::UpdateStatus;
 
 namespace {
 const int64_t kRequestId = 42;
 const int64_t kRequestId2 = 44;
 const int64_t kRequestId3 = 47;
@@ skipping 226 matching lines @@
   EXPECT_EQ(kRequestId3, this->last_update_result()->item_statuses[1].first);
   EXPECT_EQ(ItemActionStatus::NOT_FOUND,
             this->last_update_result()->item_statuses[1].second);
   EXPECT_EQ(1UL, this->last_update_result()->updated_items.size());
   EXPECT_EQ(request1, this->last_update_result()->updated_items.at(0));
 }
 
 TYPED_TEST(RequestQueueStoreTest, AddRequest) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
-  SavePageRequest request(
-      kRequestId, kUrl, kClientId, creation_time, kUserRequested);
+  SavePageRequest request(kRequestId, kUrl, kClientId, creation_time,
+                          kUserRequested);
 
   store->AddRequest(request,
                     base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
                                base::Unretained(this)));
   ASSERT_EQ(ItemActionStatus::NOT_FOUND, this->last_add_status());
   this->PumpLoop();
   ASSERT_EQ(ItemActionStatus::SUCCESS, this->last_add_status());
 
   // Verifying get reqeust results after a request was added.
   this->ClearResults();
@@ skipping 20 matching lines @@
                                 base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_EQ(1ul, this->last_requests().size());
 }
 
 TYPED_TEST(RequestQueueStoreTest, UpdateRequest) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
-  SavePageRequest original_request(
-      kRequestId, kUrl, kClientId, creation_time, kUserRequested);
+  SavePageRequest original_request(kRequestId, kUrl, kClientId, creation_time,
+                                   kUserRequested);
   store->AddRequest(original_request,
                     base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
                                base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   base::Time new_creation_time =
       creation_time + base::TimeDelta::FromMinutes(1);
   base::Time activation_time = creation_time + base::TimeDelta::FromHours(6);
   // Try updating an existing request.
@@ skipping 93 matching lines @@
             this->last_update_result()->item_statuses[0].second);
   EXPECT_EQ(kRequestId2, this->last_update_result()->item_statuses[1].first);
   EXPECT_EQ(ItemActionStatus::NOT_FOUND,
             this->last_update_result()->item_statuses[1].second);
   EXPECT_EQ(0UL, this->last_update_result()->updated_items.size());
 }
 
 TYPED_TEST(RequestQueueStoreTest, ResetStore) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
-  SavePageRequest original_request(
-      kRequestId, kUrl, kClientId, creation_time, kUserRequested);
+  SavePageRequest original_request(kRequestId, kUrl, kClientId, creation_time,
+                                   kUserRequested);
   store->AddRequest(original_request,
                     base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
                                base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   store->Reset(base::Bind(&RequestQueueStoreTestBase::ResetDone,
                           base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   this->ClearResults();
 
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_TRUE(this->last_requests().empty());
 }
 
 class RequestQueueStoreSQLTest
     : public RequestQueueStoreTest<RequestQueueStoreSQLFactory> {};
 
 // Makes sure that persistent DB is actually persisting requests across store
 // restarts.
 TEST_F(RequestQueueStoreSQLTest, SaveCloseReopenRead) {
   std::unique_ptr<RequestQueueStore> store(BuildStore());
   base::Time creation_time = base::Time::Now();
-  SavePageRequest original_request(
-      kRequestId, kUrl, kClientId, creation_time, kUserRequested);
+  SavePageRequest original_request(kRequestId, kUrl, kClientId, creation_time,
+                                   kUserRequested);
   store->AddRequest(original_request,
                     base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
                                base::Unretained(this)));
   PumpLoop();
   ClearResults();
 
   // Resets the store, using the same temp directory. The contents should be
   // intact. First reset is done separately to release DB lock.
   store.reset();
   store = BuildStore();
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_EQ(1ul, this->last_requests().size());
   ASSERT_TRUE(original_request == *(this->last_requests().at(0).get()));
 }
 
 }  // offline_pages