[IOS Reading List] Change handling of distillation error.

ios/chrome/browser/reading_list/url_downloader.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/url_downloader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
@@ skipping 94 matching lines @@
          const base::FilePath& offline_path, SuccessState success) {
         _this->download_completion_.Run(url, _this->distilled_url_, success,
                                         offline_path, title);
         _this->distiller_.reset();
         _this->working_ = false;
         _this->HandleNextTask();
       },
       base::Unretained(this), url, title, offline_path, success);
 
   // If downloading failed, clean up any partial download.
-  if (success == ERROR_RETRY || success == ERROR_PERMANENT) {
+  if (success == ERROR) {
     base::FilePath directory_path =
         reading_list::OfflineURLDirectoryAbsolutePath(base_directory_, url);
     task_tracker_.PostTaskAndReply(
         web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE).get(),
         FROM_HERE, base::Bind(
                        [](const base::FilePath& offline_directory_path) {
                          base::DeleteFile(offline_directory_path, true);
                        },
                        directory_path),
         post_delete);
@@ skipping 69 matching lines @@
   DCHECK(source == fetcher_.get());
   // At the moment, only pdf files are downloaded using URLFetcher.
   DCHECK(mime_type_ == "application/pdf");
   base::FilePath path = reading_list::OfflinePagePath(
       original_url_, reading_list::OFFLINE_TYPE_PDF);
   std::string mime_type;
   if (fetcher_->GetResponseHeaders()) {
     fetcher_->GetResponseHeaders()->GetMimeType(&mime_type);
   }
   if (!fetcher_->GetStatus().is_success() || mime_type != mime_type_) {
-    return DownloadCompletionHandler(original_url_, "", path, ERROR_RETRY);
+    return DownloadCompletionHandler(original_url_, "", path, ERROR);
   }
   base::FilePath temporary_path;
   // Do not take ownership of the file until the file is moved. This ensures
   // that the file is cleaned if there a problem before file is moved.
   fetcher_->GetResponseAsFilePath(false, &temporary_path);
 
   task_tracker_.PostTaskAndReplyWithResult(
       web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE).get(),
       FROM_HERE, base::Bind(&URLDownloader::SavePDFFile, base::Unretained(this),
                             temporary_path),
@@ skipping 17 matching lines @@
   if (CreateOfflineURLDirectory(original_url_)) {
     base::FilePath path = reading_list::OfflinePagePath(
         original_url_, reading_list::OFFLINE_TYPE_PDF);
     base::FilePath absolute_path =
         reading_list::OfflineURLAbsolutePathFromRelativePath(base_directory_,
                                                              path);
 
     if (base::Move(temporary_path, absolute_path)) {
       return DOWNLOAD_SUCCESS;
     } else {
-      return ERROR_PERMANENT;
+      return ERROR;
     }
   }
 
-  return ERROR_PERMANENT;
+  return ERROR;
 }
 
 void URLDownloader::DistillerCallback(
     const GURL& page_url,
     const std::string& html,
     const std::vector<dom_distiller::DistillerViewerInterface::ImageInfo>&
         images,
     const std::string& title) {
   if (html.empty()) {
     // The page may not be HTML. Check the mime-type to see if another handler
     // can save offline content.
     if (mime_type_ == "application/pdf") {
       // PDF handler just downloads the PDF file.
       FetchPDFFile();
       return;
     }
     // This content cannot be processed, return an error value to the client.
-    DownloadCompletionHandler(page_url, std::string(), base::FilePath(),
-                              ERROR_RETRY);
+    DownloadCompletionHandler(page_url, std::string(), base::FilePath(), ERROR);
     return;
   }
 
   std::vector<dom_distiller::DistillerViewer::ImageInfo> images_block = images;
   std::string block_html = html;
   task_tracker_.PostTaskAndReplyWithResult(
       web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE).get(),
       FROM_HERE,
       base::Bind(&URLDownloader::SaveDistilledHTML, base::Unretained(this),
                  page_url, images_block, block_html),
       base::Bind(&URLDownloader::DownloadCompletionHandler,
                  base::Unretained(this), page_url, title,
                  reading_list::OfflinePagePath(
                      page_url, reading_list::OFFLINE_TYPE_HTML)));
 }
 
 URLDownloader::SuccessState URLDownloader::SaveDistilledHTML(
     const GURL& url,
     const std::vector<dom_distiller::DistillerViewerInterface::ImageInfo>&
         images,
     const std::string& html) {
   if (CreateOfflineURLDirectory(url)) {
     return SaveHTMLForURL(SaveAndReplaceImagesInHTML(url, html, images), url)
                ? DOWNLOAD_SUCCESS
-               : ERROR_PERMANENT;
+               : ERROR;
   }
-  return ERROR_PERMANENT;
+  return ERROR;
 }
 
 bool URLDownloader::CreateOfflineURLDirectory(const GURL& url) {
   base::FilePath directory_path =
       reading_list::OfflineURLDirectoryAbsolutePath(base_directory_, url);
   if (!DirectoryExists(directory_path)) {
     return CreateDirectoryAndGetError(directory_path, nil);
   }
   return true;
 }
@@ skipping 54 matching lines @@
 
 bool URLDownloader::SaveHTMLForURL(std::string html, const GURL& url) {
   if (html.empty()) {
     return false;
   }
   base::FilePath path = reading_list::OfflineURLAbsolutePathFromRelativePath(
       base_directory_,
       reading_list::OfflinePagePath(url, reading_list::OFFLINE_TYPE_HTML));
   return base::WriteFile(path, html.c_str(), html.length()) > 0;
 }