Add Unseen state to Reading List Entry

components/reading_list/ios/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 "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/sync/protocol/reading_list_specifics.pb.h"
@@ skipping 26 matching lines @@
   ReadingListEntry e2(GURL("http://example.com"), "bar");
   ASSERT_EQ(e1, e2);
   ASSERT_EQ(e1.Title(), e2.Title());
 
   ReadingListEntry e3(std::move(e1));
 
   EXPECT_EQ(e3, e2);
   EXPECT_EQ(e3.Title(), e2.Title());
 }
 
+TEST(ReadingListEntry, ReadState) {
+  ReadingListEntry e(GURL("http://example.com"), "bar");
+  EXPECT_FALSE(e.HasBeenSeen());
+  EXPECT_FALSE(e.IsRead());
+  e.SetRead(false);
+  EXPECT_TRUE(e.HasBeenSeen());
+  EXPECT_FALSE(e.IsRead());
+  e.SetRead(true);
+  EXPECT_TRUE(e.HasBeenSeen());
+  EXPECT_TRUE(e.IsRead());
+}
+
 TEST(ReadingListEntry, DistilledPathAndURL) {
   ReadingListEntry e(GURL("http://example.com"), "bar");
 
   EXPECT_TRUE(e.DistilledPath().empty());
 
   const base::FilePath distilled_path("distilled/page.html");
   e.SetDistilledPath(distilled_path);
   EXPECT_EQ(distilled_path, e.DistilledPath());
 }
 
@@ skipping 134 matching lines @@
   ReadingListEntry entry(GURL("http://example.com/"), "bar");
   int64_t creation_time_us = entry.UpdateTime();
 
   std::unique_ptr<sync_pb::ReadingListSpecifics> pb_entry(
       entry.AsReadingListSpecifics());
   EXPECT_EQ(pb_entry->entry_id(), "http://example.com/");
   EXPECT_EQ(pb_entry->url(), "http://example.com/");
   EXPECT_EQ(pb_entry->title(), "bar");
   EXPECT_EQ(pb_entry->creation_time_us(), creation_time_us);
   EXPECT_EQ(pb_entry->update_time_us(), entry.UpdateTime());
-  EXPECT_EQ(pb_entry->status(), sync_pb::ReadingListSpecifics::UNREAD);
+  EXPECT_EQ(pb_entry->status(), sync_pb::ReadingListSpecifics::UNSEEN);
 
   entry.SetRead(true);
   EXPECT_NE(entry.UpdateTime(), creation_time_us);
   std::unique_ptr<sync_pb::ReadingListSpecifics> updated_pb_entry(
       entry.AsReadingListSpecifics());
   EXPECT_EQ(updated_pb_entry->creation_time_us(), creation_time_us);
   EXPECT_EQ(updated_pb_entry->update_time_us(), entry.UpdateTime());
   EXPECT_EQ(updated_pb_entry->status(), sync_pb::ReadingListSpecifics::READ);
 }
 
@@ skipping 23 matching lines @@
   ReadingListEntry entry(GURL("http://example.com/"), "bar");
   int64_t creation_time_us = entry.UpdateTime();
 
   std::unique_ptr<reading_list::ReadingListLocal> pb_entry(
       entry.AsReadingListLocal());
   EXPECT_EQ(pb_entry->entry_id(), "http://example.com/");
   EXPECT_EQ(pb_entry->url(), "http://example.com/");
   EXPECT_EQ(pb_entry->title(), "bar");
   EXPECT_EQ(pb_entry->creation_time_us(), creation_time_us);
   EXPECT_EQ(pb_entry->update_time_us(), entry.UpdateTime());
-  EXPECT_EQ(pb_entry->status(), reading_list::ReadingListLocal::UNREAD);
+  EXPECT_EQ(pb_entry->status(), reading_list::ReadingListLocal::UNSEEN);
   EXPECT_EQ(pb_entry->distillation_state(),
             reading_list::ReadingListLocal::WAITING);
   EXPECT_EQ(pb_entry->distilled_path(), "");
   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());
   EXPECT_EQ(will_retry_pb_entry->distillation_state(),
@@ skipping 63 matching lines @@
   EXPECT_EQ(sync_entry.URL().spec(), "http://example2.com/");
   EXPECT_EQ(sync_entry.Title(), "title2");
   EXPECT_EQ(sync_entry.UpdateTime(), sync_update_time_us);
   EXPECT_EQ(sync_entry.FailedDownloadCounter(), 0);
   EXPECT_EQ(sync_entry.DistilledState(), ReadingListEntry::PROCESSED);
   EXPECT_EQ(sync_entry.DistilledPath().value(), "distilled/page.html");
   base::Time sync_next_call = base::Time::Now() + sync_entry.TimeUntilNextTry();
   base::TimeDelta delta = next_call - sync_next_call;
   EXPECT_NEAR(delta.InMillisecondsRoundedUp(), 0, 10);
 }