Remove all synchronous methods from OfflinePageBridge.

components/offline_pages/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/offline_page_model_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 410 matching lines @@
     InformDeletePageDone(callback, DeletePageResult::SUCCESS);
     return;
   }
 
   archive_manager_->DeleteMultipleArchives(
       paths_to_delete,
       base::Bind(&OfflinePageModelImpl::OnDeleteArchiveFilesDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_ids, callback));
 }
 
+void OfflinePageModelImpl::DeletePagesByClientIds(
+    const std::vector<ClientId>& client_ids,
+    const DeletePageCallback& callback) {
+  RunWhenLoaded(base::Bind(&OfflinePageModelImpl::DoDeletePagesByClientIds,
+                           weak_ptr_factory_.GetWeakPtr(), client_ids,
+                           callback));
+}
+
+void OfflinePageModelImpl::DoDeletePagesByClientIds(
+    const std::vector<ClientId>& client_ids,
+    const DeletePageCallback& callback) {
+  std::set<ClientId> client_id_set(client_ids.begin(), client_ids.end());
+
+  std::vector<int64_t> offline_ids;
+  for (const auto& page_pair : offline_pages_) {
+    if (client_id_set.count(page_pair.second.client_id) > 0)
+      offline_ids.emplace_back(page_pair.first);
+  }
+
+  DoDeletePagesByOfflineId(offline_ids, callback);
+}
+
+void OfflinePageModelImpl::GetPagesByClientIds(
+    const std::vector<ClientId>& client_ids,
+    const MultipleOfflinePageItemCallback& callback) {
+  RunWhenLoaded(base::Bind(&OfflinePageModelImpl::DoGetPagesByClientIds,
+                           weak_ptr_factory_.GetWeakPtr(), client_ids,
+                           callback));
+}
+
+void OfflinePageModelImpl::DoGetPagesByClientIds(
+    const std::vector<ClientId>& client_ids,
+    const MultipleOfflinePageItemCallback& callback) {
+  std::set<ClientId> client_id_set(client_ids.begin(), client_ids.end());
+
+  std::vector<OfflinePageItem> result;
+  for (const auto& page_pair : offline_pages_) {
+    if (!page_pair.second.IsExpired() &&
+        client_id_set.count(page_pair.second.client_id) > 0) {
+      result.emplace_back(page_pair.second);
+    }
+  }
+  callback.Run(result);
+}
+
 void OfflinePageModelImpl::DeleteCachedPagesByURLPredicate(
     const UrlPredicate& predicate,
     const DeletePageCallback& callback) {
   RunWhenLoaded(
       base::Bind(&OfflinePageModelImpl::DoDeleteCachedPagesByURLPredicate,
                  weak_ptr_factory_.GetWeakPtr(), predicate, callback));
 }
 
 void OfflinePageModelImpl::DoDeleteCachedPagesByURLPredicate(
     const UrlPredicate& predicate,
@@ skipping 147 matching lines @@
     // stripped.
     if (online_url_without_fragment ==
         id_page_pair.second.url.ReplaceComponents(remove_params)) {
       result.push_back(id_page_pair.second);
     }
   }
 
   callback.Run(result);
 }
 
-const OfflinePageItem* OfflinePageModelImpl::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 &&
-        !id_page_pair.second.IsExpired()) {
-      if (!result || id_page_pair.second.creation_time > result->creation_time)
-        result = &(id_page_pair.second);
-    }
-  }
-  return result;
-}
-
 void OfflinePageModelImpl::CheckMetadataConsistency() {
   DCHECK(is_loaded_);
   archive_manager_->GetAllArchives(
       base::Bind(&OfflinePageModelImpl::CheckMetadataConsistencyForArchivePaths,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OfflinePageModelImpl::ExpirePages(
     const std::vector<int64_t>& offline_ids,
     const base::Time& expiration_time,
@@ skipping 427 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