Fix inheritance in Reading List

components/reading_list/ios/reading_list_model_unittest.mm

 // 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_model.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #import "base/test/ios/wait_util.h"
 #include "components/reading_list/ios/reading_list_model_impl.h"
 #include "components/reading_list/ios/reading_list_model_storage.h"
 #include "components/reading_list/ios/reading_list_store_delegate.h"
+#include "components/sync/model/metadata_change_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const GURL callback_url("http://example.com");
 const std::string callback_title("test title");
 
 class TestReadingListStorageObserver {
  public:
   virtual void ReadingListDidSaveEntry() = 0;
   virtual void ReadingListDidRemoveEntry() = 0;
 };
 
 class TestReadingListStorage : public ReadingListModelStorage {
  public:
   TestReadingListStorage(TestReadingListStorageObserver* observer)
-      : entries_(new ReadingListStoreDelegate::ReadingListEntries()),
+      : ReadingListModelStorage(
+            base::Bind(&syncer::ModelTypeChangeProcessor::Create),
+            syncer::READING_LIST),
+        entries_(new ReadingListStoreDelegate::ReadingListEntries()),
         observer_(observer) {}
 
   void AddSampleEntries() {
     // Adds timer and interlace read/unread entry creation to avoid having two
     // entries with the same creation timestamp.
     ReadingListEntry unread_a(GURL("http://unread_a.com"), "unread_a");
     entries_->insert(
         std::make_pair(GURL("http://unread_a.com"), std::move(unread_a)));
     base::test::ios::SpinRunLoopWithMinDelay(
         base::TimeDelta::FromMilliseconds(5));
@@ skipping 36 matching lines @@
         std::make_pair(GURL("http://unread_d.com"), std::move(unread_d)));
     base::test::ios::SpinRunLoopWithMinDelay(
         base::TimeDelta::FromMilliseconds(5));
   }
 
   void SetReadingListModel(ReadingListModel* model,
                            ReadingListStoreDelegate* delegate) override {
     delegate->StoreLoaded(std::move(entries_));
   }
 
-  syncer::ModelTypeSyncBridge* GetModelTypeSyncBridge() override {
-    return nullptr;
-  }
-
-  std::unique_ptr<ScopedBatchUpdate> EnsureBatchCreated() override {
-    return std::unique_ptr<ScopedBatchUpdate>();
-  }
-
   // Saves or updates an entry. If the entry is not yet in the database, it is
   // created.
   void SaveEntry(const ReadingListEntry& entry) override {
     observer_->ReadingListDidSaveEntry();
   }
 
-  // Removed an entry from the storage.
+  // Removes an entry from the storage.
   void RemoveEntry(const ReadingListEntry& entry) override {
     observer_->ReadingListDidRemoveEntry();
   }
 
+  std::unique_ptr<ScopedBatchUpdate> EnsureBatchCreated() override {
+    return std::unique_ptr<ScopedBatchUpdate>();
+  }
+
+  // Syncing is not used in this test class.
+  std::unique_ptr<syncer::MetadataChangeList> CreateMetadataChangeList()
+      override {
+    NOTREACHED();
+    return std::unique_ptr<syncer::MetadataChangeList>();
+  }
+
+  syncer::SyncError MergeSyncData(
+      std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
+      syncer::EntityDataMap entity_data_map) override {
+    NOTREACHED();
+    return syncer::SyncError();
+  }
+
+  syncer::SyncError ApplySyncChanges(
+      std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
+      syncer::EntityChangeList entity_changes) override {
+    NOTREACHED();
+    return syncer::SyncError();
+  }
+
+  void GetData(StorageKeyList storage_keys, DataCallback callback) override {
+    NOTREACHED();
+    return;
+  }
+
+  void GetAllData(DataCallback callback) override {
+    NOTREACHED();
+    return;
+  }
+
+  std::string GetClientTag(const syncer::EntityData& entity_data) override {
+    NOTREACHED();
+    return "";
+  }
+
+  std::string GetStorageKey(const syncer::EntityData& entity_data) override {
+    NOTREACHED();
+    return "";
+  }
+
  private:
   std::unique_ptr<ReadingListStoreDelegate::ReadingListEntries> entries_;
   TestReadingListStorageObserver* observer_;
 };
 
 class ReadingListModelTest : public ReadingListModelObserver,
                              public TestReadingListStorageObserver,
                              public testing::Test {
  public:
   ReadingListModelTest()
@@ skipping 478 matching lines @@
 }
 
 // Tests that ReadingListModel calls CallbackModelBeingDeleted when destroyed.
 TEST_F(ReadingListModelTest, CallbackModelBeingDeleted) {
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   model_.reset();
   AssertObserverCount(1, 0, 0, 1, 0, 0, 0, 0, 0);
 }
 
 }  // namespace