Create a strict order in ReadingListSpecifics

components/reading_list/ios/reading_list_entry.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/json/json_string_value_serializer.h"
 #include "base/memory/ptr_util.h"
 #include "components/reading_list/ios/offline_url_utils.h"
 #include "components/reading_list/ios/proto/reading_list.pb.h"
+#include "components/reading_list/ios/reading_list_store.h"
 #include "components/sync/protocol/reading_list_specifics.pb.h"
 #include "net/base/backoff_entry_serializer.h"
 
 // The backoff time is the following: 10min, 10min, 1h, 2h, 2h..., starting
 // after the first failure.
 const net::BackoffEntry::Policy ReadingListEntry::kBackoffPolicy = {
     // Number of initial errors (in sequence) to ignore before applying
     // exponential back-off rules.
     2,
 
@@ skipping 299 matching lines @@
         state = UNSEEN;
         break;
     }
   }
 
   return base::WrapUnique<ReadingListEntry>(
       new ReadingListEntry(url, title, state, creation_time_us, update_time_us,
                            WAITING, base::FilePath(), 0, nullptr));
 }
 
-void ReadingListEntry::MergeLocalStateFrom(ReadingListEntry& other) {
-  distilled_path_ = std::move(other.distilled_path_);
-  distilled_state_ = std::move(other.distilled_state_);
-  backoff_ = std::move(other.backoff_);
-  failed_download_counter_ = std::move(other.failed_download_counter_);
+void ReadingListEntry::MergeWithEntry(const ReadingListEntry& other) {
+#if !defined(NDEBUG)
+  // Checks that the result entry respects the sync order.
+  std::unique_ptr<sync_pb::ReadingListSpecifics> old_this_pb(
+      AsReadingListSpecifics());
+  std::unique_ptr<sync_pb::ReadingListSpecifics> other_pb(
+      other.AsReadingListSpecifics());
+#endif
+  DCHECK(url_ == other.url_);
+  if (title_.compare(other.title_) < 0) {
+    // Take the last in alphabetical order or the longer one.
+    // This ensure empty string is replaced.
+    title_ = std::move(other.title_);
+  }
+  if (creation_time_us_ < other.creation_time_us_) {
+    creation_time_us_ = std::move(other.creation_time_us_);
+  }
+  if (state_ == UNSEEN) {
+    state_ = std::move(other.state_);
+  } else if (other.state_ != UNSEEN) {
+    // Both are not UNSEEN, take the newer one.
+    if (update_time_us_ < other.update_time_us_) {
+      state_ = std::move(other.state_);
+    } else if (update_time_us_ == other.update_time_us_) {
+      // Both states are likely the same, but if they are not, READ should wim.

[pavely, 2016/12/07 19:16:06]

typo: wim => win.

[Olivier, 2016/12/08 08:04:07]

Done.

+      if (other.state_ == READ) {
+        state_ = std::move(other.state_);
+      }
+    }
+  }
+  if (update_time_us_ < other.update_time_us_) {
+    update_time_us_ = std::move(other.update_time_us_);
+  }
+#if !defined(NDEBUG)
+  std::unique_ptr<sync_pb::ReadingListSpecifics> new_this_pb(
+      AsReadingListSpecifics());
+  DCHECK(ReadingListStore::CompareEntriesForSync(*old_this_pb, *new_this_pb));
+  DCHECK(ReadingListStore::CompareEntriesForSync(*other_pb, *new_this_pb));
+#endif
 }
 
 std::unique_ptr<reading_list::ReadingListLocal>
 ReadingListEntry::AsReadingListLocal() const {
   std::unique_ptr<reading_list::ReadingListLocal> pb_entry =
       base::MakeUnique<reading_list::ReadingListLocal>();
 
   // URL is used as the key for the database and sync as there is only one entry
   // per URL.
   pb_entry->set_entry_id(URL().spec());
@@ skipping 71 matching lines @@
     case UNREAD:
       pb_entry->set_status(sync_pb::ReadingListSpecifics::UNREAD);
       break;
     case UNSEEN:
       pb_entry->set_status(sync_pb::ReadingListSpecifics::UNSEEN);
       break;
   }
 
   return pb_entry;
 }
-
-bool ReadingListEntry::CompareEntryUpdateTime(const ReadingListEntry& lhs,
-                                              const ReadingListEntry& rhs) {
-  return lhs.UpdateTime() > rhs.UpdateTime();
-}