Last_n: create snapshots from user triggers even if similar quality ones exist.

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 166 matching lines @@
     page_model_ = OfflinePageModelFactory::GetForBrowserContext(
         web_contents()->GetBrowserContext());
   }
 
   return snapshots_enabled_;
 }
 
 void RecentTabHelper::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame() ||
-      !navigation_handle->HasCommitted()) {
+      !navigation_handle->HasCommitted() || navigation_handle->IsSamePage()) {
     return;
   }
 
   if (!EnsureInitialized())
     return;
 
   // If there is an ongoing downloads request, lets allow Background Offliner to
   // continue downloading this page.
   if (downloads_ongoing_snapshot_info_) {
     ReportDownloadStatusToRequestCoordinator(
         downloads_ongoing_snapshot_info_.get(), false);
   }
 
   // Cancel any and all in flight snapshot tasks from the previous page.
   CancelInFlightSnapshots();
   downloads_snapshot_on_hold_ = false;
 
-  // New navigation, new snapshot session.
-  snapshot_url_ = web_contents()->GetLastCommittedURL();
-
   // Always reset so that posted tasks get canceled.
   snapshot_controller_->Reset();
 
   // Check for conditions that would cause us not to snapshot.
-  bool can_save = !navigation_handle->IsErrorPage() &&
-                  OfflinePageModel::CanSaveURL(snapshot_url_) &&
-                  OfflinePageUtils::GetOfflinePageFromWebContents(
-                      web_contents()) == nullptr;
+  bool can_save =
+      !navigation_handle->IsErrorPage() &&
+      OfflinePageModel::CanSaveURL(web_contents()->GetLastCommittedURL()) &&
+      OfflinePageUtils::GetOfflinePageFromWebContents(web_contents()) ==
+          nullptr;
 
   UMA_HISTOGRAM_BOOLEAN("OfflinePages.CanSaveRecentPage", can_save);
 
   if (!can_save)
     snapshot_controller_->Stop();
   last_n_listen_to_tab_hidden_ = can_save && !delegate_->IsLowEndDevice() &&
                                  IsOffliningRecentPagesEnabled();
-  last_n_latest_saved_quality_ = PageQuality::POOR;
 }
 
 void RecentTabHelper::DocumentAvailableInMainFrame() {
   EnsureInitialized();
   snapshot_controller_->DocumentAvailableInMainFrame();
 }
 
 void RecentTabHelper::DocumentOnLoadCompletedInMainFrame() {
   EnsureInitialized();
   snapshot_controller_->DocumentOnLoadCompletedInMainFrame();
@@ skipping 14 matching lines @@
 // the close). We should detect that and avoid the saving.
 void RecentTabHelper::WasHidden() {
   if (!IsOffliningRecentPagesEnabled())
     return;
 
   // Return immediately if last_n is not listening to tab hidden events or if a
   // last_n snapshot is currently being saved.
   if (!last_n_listen_to_tab_hidden_ || last_n_ongoing_snapshot_info_)
     return;
 
-  // Do not save if page quality is too low or if we already have a snapshot
-  // with the current quality level.
+  // Do not save if page quality is too low.
   // Note: we assume page quality for a page can only increase.
-  PageQuality current_quality = snapshot_controller_->current_page_quality();
-  if (current_quality == PageQuality::POOR ||
-      current_quality == last_n_latest_saved_quality_) {
+  if (snapshot_controller_->current_page_quality() == PageQuality::POOR)
     return;
-  }
 
   last_n_ongoing_snapshot_info_ =
       base::MakeUnique<SnapshotProgressInfo>(GetRecentPagesClientId());
   DCHECK(last_n_ongoing_snapshot_info_->IsForLastN());
   DCHECK(snapshots_enabled_);
   // Remove previously captured pages for this tab.
   page_model_->GetOfflineIdsForClientId(
       GetRecentPagesClientId(),
       base::Bind(&RecentTabHelper::ContinueSnapshotWithIdsToPurge,
                  weak_ptr_factory_.GetWeakPtr(),
@@ skipping 66 matching lines @@
   DCHECK(snapshot_info);
 
   page_model_->DeletePagesByOfflineId(
       page_ids, base::Bind(&RecentTabHelper::ContinueSnapshotAfterPurge,
                            weak_ptr_factory_.GetWeakPtr(), snapshot_info));
 }
 
 void RecentTabHelper::ContinueSnapshotAfterPurge(
     SnapshotProgressInfo* snapshot_info,
     OfflinePageModel::DeletePageResult result) {
-  DCHECK_EQ(snapshot_url_, web_contents()->GetLastCommittedURL());
   if (result != OfflinePageModel::DeletePageResult::SUCCESS) {
     ReportSnapshotCompleted(snapshot_info, false);
     return;
   }
 
+  DCHECK(OfflinePageModel::CanSaveURL(web_contents()->GetLastCommittedURL()));
   snapshot_info->expected_page_quality =
       snapshot_controller_->current_page_quality();
   OfflinePageModel::SavePageParams save_page_params;
-  save_page_params.url = snapshot_url_;
+  save_page_params.url = web_contents()->GetLastCommittedURL();
   save_page_params.client_id = snapshot_info->client_id;
   save_page_params.proposed_offline_id = snapshot_info->request_id;
   save_page_params.is_background = false;
   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 == 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) {
   if (snapshot_info->IsForLastN()) {
     DCHECK_EQ(snapshot_info, last_n_ongoing_snapshot_info_.get());
-    if (success)
-      last_n_latest_saved_quality_ = snapshot_info->expected_page_quality;
     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_ =
@@ skipping 14 matching lines @@
 
   RequestCoordinator* request_coordinator =
       RequestCoordinatorFactory::GetForBrowserContext(
           web_contents()->GetBrowserContext());
   if (!request_coordinator)
     return;
 
   // It is OK to call these methods more then once, depending on
   // number of snapshots attempted in this tab helper. If the request_id is not
   // in the list of RequestCoordinator, these calls have no effect.
-  if (cancel_background_request)
+  if (cancel_background_request) {
     request_coordinator->MarkRequestCompleted(snapshot_info->request_id);
-  else
+  } else {
     request_coordinator->EnableForOffliner(snapshot_info->request_id,
                                            snapshot_info->client_id);
+  }
 }
 
 ClientId RecentTabHelper::GetRecentPagesClientId() const {
   return ClientId(kLastNNamespace, tab_id_);
 }
 
 void RecentTabHelper::CancelInFlightSnapshots() {
   weak_ptr_factory_.InvalidateWeakPtrs();
   downloads_ongoing_snapshot_info_.reset();
   downloads_latest_saved_snapshot_info_.reset();
   last_n_ongoing_snapshot_info_.reset();
 }
 
 }  // namespace offline_pages