Use Distilled path instead of DistilledURL.

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 28 matching lines @@
       task_tracker_() {}
 
 URLDownloader::~URLDownloader() {
   task_tracker_.TryCancelAll();
 }
 
 void URLDownloader::OfflineURLExists(const GURL& url,
                                      base::Callback<void(bool)> callback) {
   task_tracker_.PostTaskAndReplyWithResult(
       web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE).get(),
-      FROM_HERE, base::Bind(&base::PathExists, OfflineURLPagePath(url)),
+      FROM_HERE, base::Bind(&base::PathExists, OfflinePageAbsolutePath(url)),
       callback);
 }
 
 void URLDownloader::RemoveOfflineURL(const GURL& url) {
   // Remove all download tasks for this url as it would be pointless work.
   tasks_.erase(
       std::remove(tasks_.begin(), tasks_.end(), std::make_pair(DOWNLOAD, url)),
       tasks_.end());
   tasks_.push_back(std::make_pair(DELETE, url));
   HandleNextTask();
 }
 
 void URLDownloader::DownloadOfflineURL(const GURL& url) {
   if (std::find(tasks_.begin(), tasks_.end(), std::make_pair(DOWNLOAD, url)) ==
       tasks_.end()) {
     tasks_.push_back(std::make_pair(DOWNLOAD, url));
     HandleNextTask();
   }
 }
 
 void URLDownloader::DownloadCompletionHandler(const GURL& url,
                                               const std::string& title,
                                               SuccessState success) {
   DCHECK(working_);
 
   auto post_delete = base::Bind(
       [](URLDownloader* _this, const GURL& url, const std::string& title,
          SuccessState success) {
-        _this->download_completion_.Run(
-            url, success,
-            GURL(std::string(url::kFileScheme) + url::kStandardSchemeSeparator +
-                 _this->OfflineURLPagePath(url).value()),
-            title);
+        _this->download_completion_.Run(url, success,
+                                        _this->OfflinePagePath(url), title);
         _this->distiller_.reset();
         _this->working_ = false;
         _this->HandleNextTask();
       },
       base::Unretained(this), url, title, success);
 
   // If downloading failed, clean up any partial download.
   if (success == ERROR_RETRY || success == ERROR_PERMANENT) {
     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);
                        },
-                       OfflineURLDirectoryPath(url)),
+                       OfflineURLDirectoryAbsolutePath(url)),
         post_delete);
   } else {
     post_delete.Run();
   }
 }
 
 void URLDownloader::DeleteCompletionHandler(const GURL& url, bool success) {
   DCHECK(working_);
   delete_completion_.Run(url, success);
   working_ = false;
   HandleNextTask();
 }
 
 void URLDownloader::HandleNextTask() {
   if (working_ || tasks_.empty()) {
     return;
   }
   working_ = true;
 
   Task task = tasks_.front();
   tasks_.pop_front();
   GURL url = task.second;
 
   if (task.first == DELETE) {
     task_tracker_.PostTaskAndReplyWithResult(
         web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE).get(),
-        FROM_HERE,
-        base::Bind(&base::DeleteFile, OfflineURLDirectoryPath(url), true),
+        FROM_HERE, base::Bind(&base::DeleteFile,
+                              OfflineURLDirectoryAbsolutePath(url), true),
         base::Bind(&URLDownloader::DeleteCompletionHandler,
                    base::Unretained(this), url));
   } else if (task.first == DOWNLOAD) {
     DCHECK(!distiller_);
     OfflineURLExists(url, base::Bind(&URLDownloader::DownloadURL,
                                      base::Unretained(this), url));
   }
 }
 
 void URLDownloader::DownloadURL(GURL url, bool offline_url_exists) {
@@ skipping 35 matching lines @@
         images,
     const std::string& html) {
   if (CreateOfflineURLDirectory(url)) {
     return SaveHTMLForURL(SaveAndReplaceImagesInHTML(url, html, images), url)
                ? DOWNLOAD_SUCCESS
                : ERROR_PERMANENT;
   }
   return ERROR_PERMANENT;
 }
 
-base::FilePath URLDownloader::OfflineDirectoryPath() {
+base::FilePath URLDownloader::OfflineRootDirectoryPath() {
   return base_directory_.Append(FILE_PATH_LITERAL(kOfflineDirectory));
 }
 
-base::FilePath URLDownloader::OfflineURLDirectoryPath(const GURL& url) {
-  std::string hash = base::MD5String(url.spec());
-  return OfflineDirectoryPath().AppendASCII(hash);
+std::string URLDownloader::OfflineURLDirectoryID(const GURL& url) {
+  return base::MD5String(url.spec());
 }
 
-base::FilePath URLDownloader::OfflineURLPagePath(const GURL& url) {
-  return OfflineURLDirectoryPath(url).Append(FILE_PATH_LITERAL("page.html"));
+base::FilePath URLDownloader::OfflinePagePath(const GURL& url) {
+  base::FilePath directory(OfflineURLDirectoryID(url));
+  return directory.Append(FILE_PATH_LITERAL("page.html"));
+}
+
+base::FilePath URLDownloader::OfflineURLDirectoryAbsolutePath(const GURL& url) {
+  return OfflineRootDirectoryPath().Append(OfflineURLDirectoryID(url));
+}
+
+base::FilePath URLDownloader::OfflinePageAbsolutePath(const GURL& url) {
+  return OfflineRootDirectoryPath().Append(OfflinePagePath(url));
 }
 
 bool URLDownloader::CreateOfflineURLDirectory(const GURL& url) {
-  base::FilePath path = OfflineURLDirectoryPath(url);
+  base::FilePath path = OfflineURLDirectoryAbsolutePath(url);
   if (!DirectoryExists(path)) {
     return CreateDirectoryAndGetError(path, nil);
   }
   return true;
 }
 
 bool URLDownloader::SaveImage(const GURL& url,
                               const GURL& image_url,
                               const std::string& data,
                               std::string* image_name) {
   std::string image_hash = base::MD5String(image_url.spec());
   *image_name = image_hash;
-  base::FilePath path = OfflineURLDirectoryPath(url).Append(image_hash);
+  base::FilePath path = OfflineURLDirectoryAbsolutePath(url).Append(image_hash);
   if (!base::PathExists(path)) {
     return base::WriteFile(path, data.c_str(), data.length()) > 0;
   }
   return true;
 }
 
 std::string URLDownloader::SaveAndReplaceImagesInHTML(
     const GURL& url,
     const std::string& html,
     const std::vector<dom_distiller::DistillerViewerInterface::ImageInfo>&
@@ skipping 13 matching lines @@
       pos = mutable_html.find(image_url, pos + local_image_name.size());
     }
   }
   return mutable_html;
 }
 
 bool URLDownloader::SaveHTMLForURL(std::string html, const GURL& url) {
   if (html.empty()) {
     return false;
   }
-  base::FilePath path = OfflineURLPagePath(url);
+  base::FilePath path = OfflinePageAbsolutePath(url);
   return base::WriteFile(path, html.c_str(), html.length()) > 0;
 }