Create offline_url_utils

ios/chrome/browser/reading_list/url_downloader_unittest.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 <vector>
 
 #include "base/files/file_util.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #import "base/test/ios/wait_util.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/test/test_web_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class DistillerViewerTest : public dom_distiller::DistillerViewerInterface {
  public:
   DistillerViewerTest(const GURL& url,
                       const DistillationFinishedCallback& callback)
       : dom_distiller::DistillerViewerInterface(nil, nil) {
@@ skipping 11 matching lines @@
 
 class MockURLDownloader : public URLDownloader {
  public:
   MockURLDownloader(base::FilePath path)
       : URLDownloader(nil,
                       nil,
                       path,
                       base::Bind(&MockURLDownloader::OnEndDownload,
                                  base::Unretained(this)),
                       base::Bind(&MockURLDownloader::OnEndRemove,
-                                 base::Unretained(this))) {}
+                                 base::Unretained(this))),
+        base_path_(path) {}
 
   void RemoveOfflineFilesDirectory() {
-    base::DeleteFile(OfflineRootDirectoryPath(), true);
+    base::DeleteFile(reading_list::OfflineRootDirectoryPath(base_path_), true);
   }
 
   void ClearCompletionTrackers() {
     downloaded_files_.clear();
     removed_files_.clear();
   }
 
   bool CheckExistenceOfOfflineURLPagePath(const GURL& url) {
-    return base::PathExists(OfflinePageAbsolutePath(url));
+    return base::PathExists(
+        reading_list::OfflinePageAbsolutePath(base_directory_, url));

[gambard, 2016/11/16 12:44:20]

base_directory_ or base_path_?

[Olivier, 2016/11/16 13:36:27]

Actually MockURLDownloader is friend of URLDownloader, so using base_directory_.

   }
 
   void FakeWorking() { working_ = true; }
 
   void FakeEndWorking() {
     working_ = false;
     HandleNextTask();
   }
 
   std::vector<GURL> downloaded_files_;
@@ skipping 13 matching lines @@
   void OnEndDownload(const GURL& url,
                      SuccessState success,
                      const base::FilePath& distilled_path,
                      const std::string& title) {
     downloaded_files_.push_back(url);
   }
 
   void OnEndRemove(const GURL& url, bool success) {
     removed_files_.push_back(url);
   }
+
+  base::FilePath base_path_;
 };
 
 namespace {
 class URLDownloaderTest : public testing::Test {
  public:
   std::unique_ptr<MockURLDownloader> downloader_;
   web::TestWebThreadBundle bundle_;
 
   URLDownloaderTest() {
     base::FilePath data_dir;
@@ skipping 76 matching lines @@
   ASSERT_TRUE(std::find(downloader_->downloaded_files_.begin(),
                         downloader_->downloaded_files_.end(),
                         url) != downloader_->downloaded_files_.end());
   ASSERT_TRUE(std::find(downloader_->removed_files_.begin(),
                         downloader_->removed_files_.end(),
                         url) != downloader_->removed_files_.end());
   ASSERT_TRUE(downloader_->CheckExistenceOfOfflineURLPagePath(url));
 }
 
 }  // namespace