Move ReadingList model to components/reading_list/core

components/reading_list/core/reading_list_entry_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/reading_list/ios/reading_list_entry.h"
+#include "components/reading_list/core/reading_list_entry.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
-#include "components/reading_list/ios/proto/reading_list.pb.h"
+#include "components/reading_list/core/proto/reading_list.pb.h"
 #include "components/sync/protocol/reading_list_specifics.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 const int kFirstBackoff = 10;
 const int kSecondBackoff = 10;
 const int kThirdBackoff = 60;
 const int kFourthBackoff = 120;
 const int kFifthBackoff = 120;
 
@@ skipping 64 matching lines @@
   EXPECT_EQ(e.UpdateTitleTime(), 15 * base::Time::kMicrosecondsPerSecond);
   EXPECT_EQ("foo", e.Title());
 }
 
 TEST(ReadingListEntry, DistilledInfo) {
   ReadingListEntry e(GURL("http://example.com"), "bar",
                      base::Time::FromTimeT(10));
 
   EXPECT_TRUE(e.DistilledPath().empty());
 
-  const base::FilePath distilled_path("distilled/page.html");
+  const base::FilePath distilled_path(FILE_PATH_LITERAL("distilled/page.html"));
   const GURL distilled_url("http://example.com/distilled");
   int64_t size = 50;
   int64_t time = 100;
   e.SetDistilledInfo(distilled_path, distilled_url, size,
                      base::Time::FromTimeT(time));
   EXPECT_EQ(distilled_path, e.DistilledPath());
   EXPECT_EQ(distilled_url, e.DistilledURL());
   EXPECT_EQ(size, e.DistillationSize());
   EXPECT_EQ(e.DistillationTime(), time * base::Time::kMicrosecondsPerSecond);
 }
 
 TEST(ReadingListEntry, DistilledState) {
   ReadingListEntry e(GURL("http://example.com"), "bar",
                      base::Time::FromTimeT(10));
 
   EXPECT_EQ(ReadingListEntry::WAITING, e.DistilledState());
 
-  e.SetDistilledState(ReadingListEntry::ERROR);
-  EXPECT_EQ(ReadingListEntry::ERROR, e.DistilledState());
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
+  EXPECT_EQ(ReadingListEntry::DISTILLATION_ERROR, e.DistilledState());
 
-  const base::FilePath distilled_path("distilled/page.html");
+  const base::FilePath distilled_path(FILE_PATH_LITERAL("distilled/page.html"));
   const GURL distilled_url("http://example.com/distilled");
   e.SetDistilledInfo(distilled_path, distilled_url, 50,
                      base::Time::FromTimeT(100));
   EXPECT_EQ(ReadingListEntry::PROCESSED, e.DistilledState());
 }
 
 // Tests that the the time until next try increase exponentially when the state
 // changes from non-error to error.
 TEST(ReadingListEntry, TimeUntilNextTry) {
   base::SimpleTestTickClock clock;
   std::unique_ptr<net::BackoffEntry> backoff =
       base::MakeUnique<net::BackoffEntry>(&ReadingListEntry::kBackoffPolicy,
                                           &clock);
 
   ReadingListEntry e(GURL("http://example.com"), "bar",
                      base::Time::FromTimeT(10), std::move(backoff));
 
   // Allow twice the jitter as test is not instantaneous.
   double fuzzing = 2 * ReadingListEntry::kBackoffPolicy.jitter_factor;
 
   EXPECT_EQ(0, e.TimeUntilNextTry().InSeconds());
 
   // First error.
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   int nextTry = e.TimeUntilNextTry().InMinutes();
   EXPECT_NEAR(kFirstBackoff, nextTry, kFirstBackoff * fuzzing);
   e.SetDistilledState(ReadingListEntry::WILL_RETRY);
   EXPECT_EQ(nextTry, e.TimeUntilNextTry().InMinutes());
 
   e.SetDistilledState(ReadingListEntry::PROCESSING);
   EXPECT_EQ(nextTry, e.TimeUntilNextTry().InMinutes());
 
   // Second error.
   e.SetDistilledState(ReadingListEntry::WILL_RETRY);
   nextTry = e.TimeUntilNextTry().InMinutes();
   EXPECT_NEAR(kSecondBackoff, nextTry, kSecondBackoff * fuzzing);
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   EXPECT_EQ(nextTry, e.TimeUntilNextTry().InMinutes());
 
   e.SetDistilledState(ReadingListEntry::PROCESSING);
   EXPECT_EQ(nextTry, e.TimeUntilNextTry().InMinutes());
 
   // Third error.
   e.SetDistilledState(ReadingListEntry::WILL_RETRY);
   EXPECT_NEAR(kThirdBackoff, e.TimeUntilNextTry().InMinutes(),
               kThirdBackoff * fuzzing);
 
   // Fourth error.
   e.SetDistilledState(ReadingListEntry::PROCESSING);
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   EXPECT_NEAR(kFourthBackoff, e.TimeUntilNextTry().InMinutes(),
               kFourthBackoff * fuzzing);
 
   // Fifth error.
   e.SetDistilledState(ReadingListEntry::PROCESSING);
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   EXPECT_NEAR(kFifthBackoff, e.TimeUntilNextTry().InMinutes(),
               kFifthBackoff * fuzzing);
 }
 
 // Tests that if the time until next try is in the past, 0 is returned.
 TEST(ReadingListEntry, TimeUntilNextTryInThePast) {
   // Setup.
   base::SimpleTestTickClock clock;
   std::unique_ptr<net::BackoffEntry> backoff =
       base::MakeUnique<net::BackoffEntry>(&ReadingListEntry::kBackoffPolicy,
                                           &clock);
   ReadingListEntry e(GURL("http://example.com"), "bar",
                      base::Time::FromTimeT(10), std::move(backoff));
   double fuzzing = ReadingListEntry::kBackoffPolicy.jitter_factor;
 
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   ASSERT_NEAR(kFirstBackoff, e.TimeUntilNextTry().InMinutes(),
               kFirstBackoff * fuzzing);
 
   // Action.
   clock.Advance(base::TimeDelta::FromMinutes(kFirstBackoff * 2));
 
   // Test.
   EXPECT_EQ(0, e.TimeUntilNextTry().InMilliseconds());
 }
 
 // Tests that if the entry gets a distilled URL, 0 is returned.
 TEST(ReadingListEntry, ResetTimeUntilNextTry) {
   // Setup.
   base::SimpleTestTickClock clock;
   std::unique_ptr<net::BackoffEntry> backoff =
       base::MakeUnique<net::BackoffEntry>(&ReadingListEntry::kBackoffPolicy,
                                           &clock);
   ReadingListEntry e(GURL("http://example.com"), "bar",
                      base::Time::FromTimeT(10), std::move(backoff));
   double fuzzing = ReadingListEntry::kBackoffPolicy.jitter_factor;
 
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   ASSERT_NEAR(kFirstBackoff, e.TimeUntilNextTry().InMinutes(),
               kFirstBackoff * fuzzing);
 
   // Action.
-  const base::FilePath distilled_path("distilled/page.html");
+  const base::FilePath distilled_path(FILE_PATH_LITERAL("distilled/page.html"));
   const GURL distilled_url("http://example.com/distilled");
   e.SetDistilledInfo(distilled_path, distilled_url, 50,
                      base::Time::FromTimeT(100));
 
   // Test.
   EXPECT_EQ(0, e.TimeUntilNextTry().InSeconds());
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   ASSERT_NEAR(kFirstBackoff, e.TimeUntilNextTry().InMinutes(),
               kFirstBackoff * fuzzing);
 }
 
 // Tests that the failed download counter is incremented when the state change
 // from non-error to error.
 TEST(ReadingListEntry, FailedDownloadCounter) {
   ReadingListEntry e(GURL("http://example.com"), "bar",
                      base::Time::FromTimeT(10));
 
   EXPECT_EQ(0, e.FailedDownloadCounter());
 
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   EXPECT_EQ(1, e.FailedDownloadCounter());
   e.SetDistilledState(ReadingListEntry::WILL_RETRY);
   EXPECT_EQ(1, e.FailedDownloadCounter());
 
   e.SetDistilledState(ReadingListEntry::PROCESSING);
   EXPECT_EQ(1, e.FailedDownloadCounter());
 
   e.SetDistilledState(ReadingListEntry::WILL_RETRY);
   EXPECT_EQ(2, e.FailedDownloadCounter());
-  e.SetDistilledState(ReadingListEntry::ERROR);
+  e.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   EXPECT_EQ(2, e.FailedDownloadCounter());
 }
 
 // Tests that the reading list entry is correctly encoded to
 // sync_pb::ReadingListSpecifics.
 TEST(ReadingListEntry, AsReadingListSpecifics) {
   ReadingListEntry entry(GURL("http://example.com"), "bar",
                          base::Time::FromTimeT(10));
   int64_t creation_time_us = entry.UpdateTime();
 
@@ skipping 64 matching lines @@
   EXPECT_EQ(pb_entry->failed_download_counter(), 0);
   EXPECT_NE(pb_entry->backoff(), "");
 
   entry.SetDistilledState(ReadingListEntry::WILL_RETRY);
   std::unique_ptr<reading_list::ReadingListLocal> will_retry_pb_entry(
       entry.AsReadingListLocal(base::Time::FromTimeT(50)));
   EXPECT_EQ(will_retry_pb_entry->distillation_state(),
             reading_list::ReadingListLocal::WILL_RETRY);
   EXPECT_EQ(will_retry_pb_entry->failed_download_counter(), 1);
 
-  const base::FilePath distilled_path("distilled/page.html");
+  const base::FilePath distilled_path(FILE_PATH_LITERAL("distilled/page.html"));
   const GURL distilled_url("http://example.com/distilled");
   int64_t size = 50;
   entry.SetDistilledInfo(distilled_path, distilled_url, size,
                          base::Time::FromTimeT(100));
 
   entry.SetRead(true, base::Time::FromTimeT(20));
   entry.MarkEntryUpdated(base::Time::FromTimeT(30));
   EXPECT_NE(entry.UpdateTime(), creation_time_us);
   std::unique_ptr<reading_list::ReadingListLocal> distilled_pb_entry(
       entry.AsReadingListLocal(base::Time::FromTimeT(40)));
   EXPECT_EQ(distilled_pb_entry->creation_time_us(), creation_time_us);
   EXPECT_EQ(distilled_pb_entry->update_time_us(), entry.UpdateTime());
   EXPECT_NE(distilled_pb_entry->backoff(), "");
   EXPECT_EQ(distilled_pb_entry->status(), reading_list::ReadingListLocal::READ);
   EXPECT_EQ(distilled_pb_entry->distillation_state(),
             reading_list::ReadingListLocal::PROCESSED);
   EXPECT_EQ(distilled_pb_entry->distilled_path(), "distilled/page.html");
   EXPECT_EQ(distilled_pb_entry->failed_download_counter(), 0);
   EXPECT_EQ(distilled_pb_entry->distillation_time_us(),
             entry.DistillationTime());
   EXPECT_EQ(distilled_pb_entry->distillation_size(), entry.DistillationSize());
 }
 
 // Tests that the reading list entry is correctly parsed from
 // sync_pb::ReadingListLocal.
 TEST(ReadingListEntry, FromReadingListLocal) {
   ReadingListEntry entry(GURL("http://example.com/"), "title",
                          base::Time::FromTimeT(10));
-  entry.SetDistilledState(ReadingListEntry::ERROR);
+  entry.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
 
   std::unique_ptr<reading_list::ReadingListLocal> pb_entry(
       entry.AsReadingListLocal(base::Time::FromTimeT(10)));
   int64_t now = 12345;
 
   pb_entry->set_entry_id("http://example.com/");
   pb_entry->set_url("http://example.com/");
   pb_entry->set_title("title");
   pb_entry->set_creation_time_us(1);
   pb_entry->set_update_time_us(2);
@@ skipping 21 matching lines @@
   int nextTry = waiting_entry->TimeUntilNextTry().InMinutes();
   EXPECT_NEAR(kFirstBackoff, nextTry, kFirstBackoff * fuzzing);
 }
 
 // Tests the merging of two ReadingListEntry.
 // Additional merging tests are done in
 // ReadingListStoreTest.CompareEntriesForSync
 TEST(ReadingListEntry, MergeWithEntry) {
   ReadingListEntry local_entry(GURL("http://example.com/"), "title",
                                base::Time::FromTimeT(10));
-  local_entry.SetDistilledState(ReadingListEntry::ERROR);
+  local_entry.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   local_entry.SetTitle("title updated", base::Time::FromTimeT(30));
   int64_t local_update_time_us = local_entry.UpdateTime();
 
   ReadingListEntry sync_entry(GURL("http://example.com/"), "title2",
                               base::Time::FromTimeT(20));
-  sync_entry.SetDistilledState(ReadingListEntry::ERROR);
+  sync_entry.SetDistilledState(ReadingListEntry::DISTILLATION_ERROR);
   int64_t sync_update_time_us = sync_entry.UpdateTime();
   EXPECT_NE(local_update_time_us, sync_update_time_us);
   local_entry.MergeWithEntry(sync_entry);
   EXPECT_EQ(local_entry.URL().spec(), "http://example.com/");
   EXPECT_EQ(local_entry.Title(), "title updated");
   EXPECT_EQ(local_entry.UpdateTitleTime(),
             30 * base::Time::kMicrosecondsPerSecond);
   EXPECT_FALSE(local_entry.HasBeenSeen());
   EXPECT_EQ(local_entry.UpdateTime(), sync_update_time_us);
   EXPECT_EQ(local_entry.FailedDownloadCounter(), 1);
-  EXPECT_EQ(local_entry.DistilledState(), ReadingListEntry::ERROR);
+  EXPECT_EQ(local_entry.DistilledState(), ReadingListEntry::DISTILLATION_ERROR);
   // Allow twice the jitter as test is not instantaneous.
   double fuzzing = 2 * ReadingListEntry::kBackoffPolicy.jitter_factor;
   int nextTry = local_entry.TimeUntilNextTry().InMinutes();
   EXPECT_NEAR(kFirstBackoff, nextTry, kFirstBackoff * fuzzing);
 }