Get signals working in the EXTRA_DATA section of MHTML

components/offline_pages/core/offline_page_model_impl.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 "components/offline_pages/core/offline_page_model_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 322 matching lines @@
 
 void OfflinePageModelImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void OfflinePageModelImpl::SavePage(
     const SavePageParams& save_page_params,
     std::unique_ptr<OfflinePageArchiver> archiver,
     const SavePageCallback& callback) {
   DCHECK(is_loaded_);
+  base::FilePath empty_file_path;
 
   // Skip saving the page that is not intended to be saved, like local file
   // page.
   if (!OfflinePageModel::CanSaveURL(save_page_params.url)) {
     InformSavePageDone(callback, SavePageResult::SKIPPED,
-                       save_page_params.client_id, kInvalidOfflineId);
+                       save_page_params.client_id, kInvalidOfflineId,
+                       empty_file_path);
     return;
   }
 
   // The web contents is not available if archiver is not created and passed.
   if (!archiver.get()) {
     InformSavePageDone(callback, SavePageResult::CONTENT_UNAVAILABLE,
-                       save_page_params.client_id, kInvalidOfflineId);
+                       save_page_params.client_id, kInvalidOfflineId,
+                       empty_file_path);
     return;
   }
 
   // If we already have an offline id, use it.  If not, generate one.
   int64_t offline_id = save_page_params.proposed_offline_id;
   if (offline_id == kInvalidOfflineId)
     offline_id = GenerateOfflineId();
 
   OfflinePageArchiver::CreateArchiveParams create_archive_params;
   // If the page is being saved in the background, we should try to remove the
@@ skipping 320 matching lines @@
     ArchiverResult archiver_result,
     const GURL& url,
     const base::FilePath& file_path,
     const base::string16& title,
     int64_t file_size) {
   if (save_page_params.url != url) {
     DVLOG(1) << "Saved URL does not match requested URL.";
     // TODO(fgorski): We have created an archive for a wrong URL. It should be
     // deleted from here, once archiver has the right functionality.
     InformSavePageDone(callback, SavePageResult::ARCHIVE_CREATION_FAILED,
-                       save_page_params.client_id, offline_id);
+                       save_page_params.client_id, offline_id, file_path);
     DeletePendingArchiver(archiver);
     return;
   }
 
   if (archiver_result != ArchiverResult::SUCCESSFULLY_CREATED) {
     SavePageResult result = ToSavePageResult(archiver_result);
-    InformSavePageDone(
-        callback, result, save_page_params.client_id, offline_id);
+    InformSavePageDone(callback, result, save_page_params.client_id, offline_id,
+                       file_path);
     DeletePendingArchiver(archiver);
     return;
   }
   OfflinePageItem offline_page_item(url, offline_id, save_page_params.client_id,
                                     file_path, file_size, start_time);
   offline_page_item.title = title;
   offline_page_item.original_url = save_page_params.original_url;
   store_->AddOfflinePage(offline_page_item,
                          base::Bind(&OfflinePageModelImpl::OnAddOfflinePageDone,
                                     weak_ptr_factory_.GetWeakPtr(), archiver,
@@ skipping 17 matching lines @@
                                           offline_page.url.spec(),
                                           offline_page.offline_id);
   } else if (status == ItemActionStatus::ALREADY_EXISTS) {
     // Remove the orphaned archive.  No callback necessary.
     archive_manager_->DeleteArchive(file_path, base::Bind([](bool) {}));
     result = SavePageResult::ALREADY_EXISTS;
   } else {
     result = SavePageResult::STORE_FAILURE;
   }
   InformSavePageDone(callback, result, offline_page.client_id,
-                     offline_page.offline_id);
+                     offline_page.offline_id, file_path);
   if (result == SavePageResult::SUCCESS) {
     DeleteExistingPagesWithSameURL(offline_page);
   } else {
     PostClearStorageIfNeededTask(false /* delayed */);
   }
 
   DeletePendingArchiver(archiver);
 
   // We don't want to notify observers if the add failed.
   if (result != SavePageResult::SUCCESS)
@@ skipping 94 matching lines @@
     delayed_task.Run();
   delayed_tasks_.clear();
 
   // Clear storage.
   PostClearStorageIfNeededTask(true /* delayed */);
 }
 
 void OfflinePageModelImpl::InformSavePageDone(const SavePageCallback& callback,
                                               SavePageResult result,
                                               const ClientId& client_id,
-                                              int64_t offline_id) {
+                                              int64_t offline_id,
+                                              const base::FilePath& file_path) {
   ReportSavePageResultHistogramAfterSave(client_id, result);
   archive_manager_->GetStorageStats(
       base::Bind(&ReportStorageHistogramsAfterSave));
-  callback.Run(result, offline_id);
+  callback.Run(result, offline_id, file_path);
 }
 
 void OfflinePageModelImpl::DeleteExistingPagesWithSameURL(
     const OfflinePageItem& offline_page) {
   // Remove existing pages generated by the same policy and with same url.
   size_t pages_allowed =
       policy_controller_->GetPolicy(offline_page.client_id.name_space)
           .pages_allowed_per_url;
   if (pages_allowed == kUnlimitedPages)
     return;
@@ skipping 223 matching lines @@
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 base::Time OfflinePageModelImpl::GetCurrentTime() const {
   return testing_clock_ ? testing_clock_->Now() : base::Time::Now();
 }
 
 }  // namespace offline_pages