Create offline_url_utils

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"
 #include "base/files/file_util.h"
-#include "base/md5.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "ios/chrome/browser/chrome_paths.h"
 #include "ios/chrome/browser/dom_distiller/distiller_viewer.h"
+#include "ios/chrome/browser/reading_list/offline_url_utils.h"
 #include "ios/web/public/web_thread.h"
 #include "net/base/escape.h"
 #include "url/gurl.h"
 
-const char kReadingListOfflineDirectory[] = "Offline";
-
 // URLDownloader
 
 URLDownloader::URLDownloader(
     dom_distiller::DomDistillerService* distiller_service,
     PrefService* prefs,
     base::FilePath chrome_profile_path,
     const DownloadCompletion& download_completion,
     const SuccessCompletion& delete_completion)
     : distiller_service_(distiller_service),
       pref_service_(prefs),
       download_completion_(download_completion),
       delete_completion_(delete_completion),
       working_(false),
       base_directory_(chrome_profile_path),
       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, OfflinePageAbsolutePath(url)),
+      FROM_HERE,
+      base::Bind(&base::PathExists,
+                 reading_list::OfflinePageAbsolutePath(base_directory_, 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,
-                                        _this->OfflinePagePath(url), title);
+        _this->download_completion_.Run(
+            url, success, reading_list::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);
                        },
-                       OfflineURLDirectoryAbsolutePath(url)),
+                       reading_list::OfflineURLDirectoryAbsolutePath(
+                           base_directory_, 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,
-                              OfflineURLDirectoryAbsolutePath(url), true),
+                              reading_list::OfflineURLDirectoryAbsolutePath(
+                                  base_directory_, 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::OfflineRootDirectoryPath() {
-  return base_directory_.Append(
-      FILE_PATH_LITERAL(kReadingListOfflineDirectory));
-}
-
-std::string URLDownloader::OfflineURLDirectoryID(const GURL& url) {
-  return base::MD5String(url.spec());
-}
-
-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 = OfflineURLDirectoryAbsolutePath(url);
+  base::FilePath path =
+      reading_list::OfflineURLDirectoryAbsolutePath(base_directory_, 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 = OfflineURLDirectoryAbsolutePath(url).Append(image_hash);
+  base::FilePath path =
+      reading_list::OfflineURLDirectoryAbsolutePath(base_directory_, 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 = OfflinePageAbsolutePath(url);
+  base::FilePath path =
+      reading_list::OfflinePageAbsolutePath(base_directory_, url);
   return base::WriteFile(path, html.c_str(), html.length()) > 0;
 }