Revert of Last_n: Delete previously saved snapshot when navigating.

chrome/browser/android/offline_pages/recent_tab_helper.cc

 // Copyright (c) 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 "chrome/browser/android/offline_pages/recent_tab_helper.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 194 matching lines @@
            << web_contents()->GetLastCommittedURL().spec();
 
   // If there is an ongoing downloads request, lets make Background Offliner
   // take over downloading that page.
   if (downloads_ongoing_snapshot_info_) {
     DVLOG(1) << " - Passing ongoing downloads request to Background Offliner";
     ReportDownloadStatusToRequestCoordinator(
         downloads_ongoing_snapshot_info_.get(), false);
   }
 
-  // If the previous page was saved, delete it now.
-  if (last_n_latest_saved_snapshot_info_) {
-    std::vector<int64_t> id{last_n_latest_saved_snapshot_info_->request_id};
-    page_model_->DeletePagesByOfflineId(id, DeletePageCallback());
-  }
-
   // Cancel any and all in flight snapshot tasks from the previous page.
+  DVLOG_IF(1, last_n_ongoing_snapshot_info_)
+      << " - Canceling ongoing last_n snapshot";
   CancelInFlightSnapshots();
   downloads_snapshot_on_hold_ = false;
 
   // Always reset so that posted tasks get canceled.
   snapshot_controller_->Reset();
 
-  // Check for conditions that should stop last_n from creating snapshots of
-  // this page:
-  // - It is an error page.
-  // - The navigation is a POST as offline pages are never loaded for them.
-  // - The navigated URL is not supported.
-  // - The page being loaded is already an offline page.
+  // Check for conditions that would cause us not to snapshot.
   bool can_save =
-      !navigation_handle->IsErrorPage() && !navigation_handle->IsPost() &&
+      !navigation_handle->IsErrorPage() &&
       OfflinePageModel::CanSaveURL(web_contents()->GetLastCommittedURL()) &&
       OfflinePageUtils::GetOfflinePageFromWebContents(web_contents()) ==
           nullptr;
   DVLOG_IF(1, !can_save) << " - Page can not be saved for offline usage";
 
   UMA_HISTOGRAM_BOOLEAN("OfflinePages.CanSaveRecentPage", can_save);
 
   if (!can_save)
     snapshot_controller_->Stop();
   last_n_listen_to_tab_hidden_ = can_save && !delegate_->IsLowEndDevice() &&
@@ skipping 175 matching lines @@
       OfflinePageUtils::GetOriginalURLFromWebContents(web_contents());
   page_model_->SavePage(
       save_page_params, delegate_->CreatePageArchiver(web_contents()),
       base::Bind(&RecentTabHelper::SavePageCallback,
                  weak_ptr_factory_.GetWeakPtr(), snapshot_info));
 }
 
 void RecentTabHelper::SavePageCallback(SnapshotProgressInfo* snapshot_info,
                                        OfflinePageModel::SavePageResult result,
                                        int64_t offline_id) {
-  DCHECK((snapshot_info->IsForLastN() &&
-          snapshot_info->request_id == OfflinePageModel::kInvalidOfflineId) ||
+  DCHECK(snapshot_info->IsForLastN() ||
          snapshot_info->request_id == offline_id);
-  // Store the assigned offline_id (for downloads case it will already contain
-  // the same value).
-  snapshot_info->request_id = offline_id;
   ReportSnapshotCompleted(snapshot_info, result == SavePageResult::SUCCESS);
 }
 
 // Note: this is the final step in the chain of callbacks and it's where the
 // behavior is different depending on this being a last_n or downloads snapshot.
 void RecentTabHelper::ReportSnapshotCompleted(
     SnapshotProgressInfo* snapshot_info,
     bool success) {
   DVLOG(1) << (snapshot_info->IsForLastN() ? "Last_n" : "Downloads")
            << " snapshot " << (success ? "succeeded" : "failed")
            << " for: " << web_contents()->GetLastCommittedURL().spec();
   if (snapshot_info->IsForLastN()) {
     DCHECK_EQ(snapshot_info, last_n_ongoing_snapshot_info_.get());
-    if (success) {
-      last_n_latest_saved_snapshot_info_ =
-          std::move(last_n_ongoing_snapshot_info_);
-    } else {
-      last_n_ongoing_snapshot_info_.reset();
-    }
+    last_n_ongoing_snapshot_info_.reset();
     return;
   }
 
   DCHECK_EQ(snapshot_info, downloads_ongoing_snapshot_info_.get());
   snapshot_controller_->PendingSnapshotCompleted();
   // Tell RequestCoordinator how the request should be processed further.
   ReportDownloadStatusToRequestCoordinator(snapshot_info, success);
   if (success) {
     downloads_latest_saved_snapshot_info_ =
         std::move(downloads_ongoing_snapshot_info_);
@@ skipping 26 matching lines @@
     request_coordinator->EnableForOffliner(snapshot_info->request_id,
                                            snapshot_info->client_id);
   }
 }
 
 ClientId RecentTabHelper::GetRecentPagesClientId() const {
   return ClientId(kLastNNamespace, tab_id_);
 }
 
 void RecentTabHelper::CancelInFlightSnapshots() {
-  DVLOG_IF(1, last_n_ongoing_snapshot_info_)
-      << " - Canceling ongoing last_n snapshot";
-  DVLOG_IF(1, downloads_ongoing_snapshot_info_)
-      << " - Canceling ongoing downloads snapshot";
   weak_ptr_factory_.InvalidateWeakPtrs();
   downloads_ongoing_snapshot_info_.reset();
   downloads_latest_saved_snapshot_info_.reset();
   last_n_ongoing_snapshot_info_.reset();
-  last_n_latest_saved_snapshot_info_.reset();
 }
 
 }  // namespace offline_pages