Choose the best offline page when given an online URL.

components/offline_pages/offline_page_model.cc

 // Copyright 2015 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/offline_page_model.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 411 matching lines @@
 
 const OfflinePageItem* OfflinePageModel::MaybeGetPageByOfflineURL(
     const GURL& offline_url) const {
   for (const auto& id_page_pair : offline_pages_) {
     if (id_page_pair.second.GetOfflineURL() == offline_url)
       return &(id_page_pair.second);
   }
   return nullptr;
 }
 
+void OfflinePageModel::GetBestPageForOnlineURL(
+    const GURL& online_url,
+    const SingleOfflinePageItemCallback callback) {
+  RunWhenLoaded(
+      base::Bind(&OfflinePageModel::GetBestPageForOnlineURLWhenLoadDone,
+                 weak_ptr_factory_.GetWeakPtr(), online_url, callback));
+}
+
+void OfflinePageModel::GetBestPageForOnlineURLWhenLoadDone(
+    const GURL& online_url,
+    const SingleOfflinePageItemCallback& callback) const {
+  SingleOfflinePageItemResult result;
+
+  const OfflinePageItem* best_page = MaybeGetBestPageForOnlineURL(online_url);
+  if (best_page != nullptr)
+    result = *best_page;
+
+  callback.Run(result);
+}
+
 void OfflinePageModel::GetPagesByOnlineURL(
     const GURL& online_url,
     const MultipleOfflinePageItemCallback& callback) {
   RunWhenLoaded(base::Bind(&OfflinePageModel::GetPagesByOnlineURLWhenLoadDone,
                            weak_ptr_factory_.GetWeakPtr(), online_url,
                            callback));
 }
 
 void OfflinePageModel::GetPagesByOnlineURLWhenLoadDone(
     const GURL& online_url,
     const MultipleOfflinePageItemCallback& callback) const {
   std::vector<OfflinePageItem> result;
 
   for (const auto& id_page_pair : offline_pages_) {
     if (id_page_pair.second.url == online_url)
       result.push_back(id_page_pair.second);
   }
 
   callback.Run(result);
 }
 
-const OfflinePageItem* OfflinePageModel::MaybeGetPageByOnlineURL(
+const OfflinePageItem* OfflinePageModel::MaybeGetBestPageForOnlineURL(
     const GURL& online_url) const {
+  const OfflinePageItem* result = nullptr;
   for (const auto& id_page_pair : offline_pages_) {
-    if (id_page_pair.second.url == online_url)
-      return &(id_page_pair.second);
+    if (id_page_pair.second.url == online_url) {
+      if (!result || id_page_pair.second.creation_time > result->creation_time)
+        result = &(id_page_pair.second);
+    }
   }
-  return nullptr;
+  return result;
 }
 
 void OfflinePageModel::CheckForExternalFileDeletion() {
   DCHECK(is_loaded_);
 
   std::vector<std::pair<int64_t, base::FilePath>> id_path_pairs;
   for (const auto& id_page_pair : offline_pages_) {
     id_path_pairs.push_back(
         std::make_pair(id_page_pair.first, id_page_pair.second.file_path));
   }
@@ skipping 339 matching lines @@
 void OfflinePageModel::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
 }
 
 }  // namespace offline_pages