Move ReadingList model to components/reading_list/core

ios/chrome/browser/reading_list/reading_list_download_service.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 "ios/chrome/browser/reading_list/reading_list_download_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
-#include "components/reading_list/ios/offline_url_utils.h"
-#include "components/reading_list/ios/reading_list_entry.h"
-#include "components/reading_list/ios/reading_list_model.h"
+#include "components/reading_list/core/offline_url_utils.h"
+#include "components/reading_list/core/reading_list_entry.h"
+#include "components/reading_list/core/reading_list_model.h"
 #include "ios/chrome/browser/reading_list/reading_list_distiller_page_factory.h"
 #include "ios/web/public/web_thread.h"
 
 namespace {
 // Status of the download when it ends, for UMA report.
 // These match tools/metrics/histograms/histograms.xml.
 enum UMADownloadStatus {
   // The download was successful.
   SUCCESS = 0,
   // The download failed and it won't be retried.
@@ skipping 104 matching lines @@
     const ReadingListEntry* entry = reading_list_model_->GetEntryByURL(url);
     switch (entry->DistilledState()) {
       case ReadingListEntry::PROCESSED:
         processed_directories.insert(reading_list::OfflineURLDirectoryID(url));
         break;
       case ReadingListEntry::WAITING:
       case ReadingListEntry::PROCESSING:
       case ReadingListEntry::WILL_RETRY:
         unprocessed_entries.insert(url);
         break;
-      case ReadingListEntry::ERROR:
+      case ReadingListEntry::DISTILLATION_ERROR:
         break;
     }
   }
   web::WebThread::PostTaskAndReply(
       web::WebThread::FILE, FROM_HERE,
       base::Bind(&ReadingListDownloadService::CleanUpFiles,
                  base::Unretained(this), processed_directories),
       base::Bind(&ReadingListDownloadService::DownloadUnprocessedEntries,
                  base::Unretained(this), unprocessed_entries));
 }
@@ skipping 14 matching lines @@
 void ReadingListDownloadService::DownloadUnprocessedEntries(
     const std::set<GURL>& unprocessed_entries) {
   for (const GURL& url : unprocessed_entries) {
     this->ScheduleDownloadEntry(url);
   }
 }
 
 void ReadingListDownloadService::ScheduleDownloadEntry(const GURL& url) {
   DCHECK(reading_list_model_->loaded());
   const ReadingListEntry* entry = reading_list_model_->GetEntryByURL(url);
-  if (!entry || entry->DistilledState() == ReadingListEntry::ERROR ||
+  if (!entry ||
+      entry->DistilledState() == ReadingListEntry::DISTILLATION_ERROR ||
       entry->DistilledState() == ReadingListEntry::PROCESSED || entry->IsRead())
     return;
   GURL local_url(url);
   web::WebThread::PostDelayedTask(
       web::WebThread::UI, FROM_HERE,
       base::Bind(&ReadingListDownloadService::DownloadEntry,
                  weak_ptr_factory_.GetWeakPtr(), local_url),
       entry->TimeUntilNextTry());
 }
 
 void ReadingListDownloadService::DownloadEntry(const GURL& url) {
   DCHECK(reading_list_model_->loaded());
   const ReadingListEntry* entry = reading_list_model_->GetEntryByURL(url);
-  if (!entry || entry->DistilledState() == ReadingListEntry::ERROR ||
+  if (!entry ||
+      entry->DistilledState() == ReadingListEntry::DISTILLATION_ERROR ||
       entry->DistilledState() == ReadingListEntry::PROCESSED || entry->IsRead())
     return;
 
   if (net::NetworkChangeNotifier::IsOffline()) {
     // There is no connection, save it for download only if we did not exceed
     // the maximaxum number of tries.
     if (entry->FailedDownloadCounter() < kNumberOfFailsBeforeWifiOnly)
       url_to_download_cellular_.push_back(entry->URL());
     if (entry->FailedDownloadCounter() < kNumberOfFailsBeforeStop)
       url_to_download_wifi_.push_back(entry->URL());
@@ skipping 65 matching lines @@
       if (entry &&
           entry->FailedDownloadCounter() + 1 < kNumberOfFailsBeforeStop) {
         reading_list_model_->SetEntryDistilledState(
             url, ReadingListEntry::WILL_RETRY);
         ScheduleDownloadEntry(url);
         UMA_HISTOGRAM_ENUMERATION("ReadingList.Download.Status", RETRY,
                                   STATUS_MAX);
       } else {
         UMA_HISTOGRAM_ENUMERATION("ReadingList.Download.Status", FAILURE,
                                   STATUS_MAX);
-        reading_list_model_->SetEntryDistilledState(url,
-                                                    ReadingListEntry::ERROR);
+        reading_list_model_->SetEntryDistilledState(
+            url, ReadingListEntry::DISTILLATION_ERROR);
       }
       break;
     }
   }
 }
 
 void ReadingListDownloadService::OnDeleteEnd(const GURL& url, bool success) {
   // Nothing to update as this is only called when deleting reading list entries
 }
 
 void ReadingListDownloadService::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   if (type == net::NetworkChangeNotifier::CONNECTION_NONE) {
     had_connection_ = false;
     return;
   }
 
   if (!had_connection_) {
     had_connection_ = true;
     for (auto& url : url_to_download_cellular_) {
       ScheduleDownloadEntry(url);
     }
   }
   if (type == net::NetworkChangeNotifier::CONNECTION_WIFI) {
     for (auto& url : url_to_download_wifi_) {
       ScheduleDownloadEntry(url);
     }
   }
 }