[Reading List iOS] Store distillation date and size.

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 86 matching lines @@
     const GURL& url,
     const std::string& title,
     const base::FilePath& offline_path,
     SuccessState success) {
   DCHECK(working_);
 
   auto post_delete = base::Bind(
       [](URLDownloader* _this, const GURL& url, const std::string& title,
          const base::FilePath& offline_path, SuccessState success) {
         _this->download_completion_.Run(url, _this->distilled_url_, success,
-                                        offline_path, title);
+                                        offline_path, _this->saved_size_,
+                                        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) {
     base::FilePath directory_path =
         reading_list::OfflineURLDirectoryAbsolutePath(base_directory_, url);
@@ skipping 44 matching lines @@
 
 void URLDownloader::DownloadURL(const GURL& url, bool offline_url_exists) {
   if (offline_url_exists) {
     DownloadCompletionHandler(url, std::string(), base::FilePath(),
                               DOWNLOAD_EXISTS);
     return;
   }
 
   original_url_ = url;
   distilled_url_ = url;
+  saved_size_ = 0;
   std::unique_ptr<reading_list::ReadingListDistillerPage>
       reading_list_distiller_page =
           distiller_page_factory_->CreateReadingListDistillerPage(this);
 
   distiller_.reset(new dom_distiller::DistillerViewer(
       distiller_factory_, std::move(reading_list_distiller_page), pref_service_,
       url,
       base::Bind(&URLDownloader::DistillerCallback, base::Unretained(this))));
 }
 
@@ skipping 49 matching lines @@
 URLDownloader::SuccessState URLDownloader::SavePDFFile(
     const base::FilePath& temporary_path) {
   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)) {
+      int64_t pdf_file_size;
+      base::GetFileSize(absolute_path, &pdf_file_size);
+      saved_size_ += pdf_file_size;
       return DOWNLOAD_SUCCESS;
     } else {
       return ERROR;
     }
   }
 
   return ERROR;
 }
 
 void URLDownloader::DistillerCallback(
@@ skipping 53 matching lines @@
 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 directory_path =
       reading_list::OfflineURLDirectoryAbsolutePath(base_directory_, url);
   base::FilePath path = directory_path.Append(image_hash);
   if (!base::PathExists(path)) {
-    return base::WriteFile(path, data.c_str(), data.length()) > 0;
+    int written = base::WriteFile(path, data.c_str(), data.length());
+    if (written <= 0) {
+      return false;
+    }
+    saved_size_ += written;
+    return true;
   }
   return true;
 }
 
 std::string URLDownloader::SaveAndReplaceImagesInHTML(
     const GURL& url,
     const std::string& html,
     const std::vector<dom_distiller::DistillerViewerInterface::ImageInfo>&
         images) {
   std::string mutable_html = html;
@@ skipping 30 matching lines @@
   return mutable_html;
 }
 
 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;
+  int written = base::WriteFile(path, html.c_str(), html.length());
+  if (written <= 0) {
+    return false;
+  }
+  saved_size_ += written;
+  return true;
 }