Add prefetch support to AffiliationBackend.

components/password_manager/core/browser/affiliation_backend.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/password_manager/core/browser/affiliation_backend.h"
 
 #include <stdint.h>
 
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "components/password_manager/core/browser/affiliation_database.h"
 #include "components/password_manager/core/browser/affiliation_fetcher.h"
 #include "components/password_manager/core/browser/facet_manager.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace password_manager {
 
@@ skipping 17 matching lines @@
     NOTIMPLEMENTED();
   }
 }
 
 void AffiliationBackend::GetAffiliations(
     const FacetURI& facet_uri,
     bool cached_only,
     const AffiliationService::ResultCallback& callback,
     const scoped_refptr<base::TaskRunner>& callback_task_runner) {
   DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
-  if (!facet_managers_.contains(facet_uri)) {
-    scoped_ptr<FacetManager> new_manager(new FacetManager(this, facet_uri));
-    facet_managers_.add(facet_uri, new_manager.Pass());
-  }
 
-  FacetManager* facet_manager = facet_managers_.get(facet_uri);
+  FacetManager* facet_manager = GetOrCreateFacetManager(facet_uri);
   DCHECK(facet_manager);
   facet_manager->GetAffiliations(cached_only, callback, callback_task_runner);
 
   if (facet_manager->CanBeDiscarded())
     facet_managers_.erase(facet_uri);
 }
 
 void AffiliationBackend::Prefetch(const FacetURI& facet_uri,
                                   const base::Time& keep_fresh_until) {
   DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
 
-  // TODO(engedy): Implement this. crbug.com/437865.
-  NOTIMPLEMENTED();
+  FacetManager* facet_manager = GetOrCreateFacetManager(facet_uri);
+  DCHECK(facet_manager);
+  facet_manager->Prefetch(keep_fresh_until);
+
+  if (facet_manager->CanBeDiscarded())
+    facet_managers_.erase(facet_uri);
 }
 
 void AffiliationBackend::CancelPrefetch(const FacetURI& facet_uri,
                                         const base::Time& keep_fresh_until) {
   DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
 
-  // TODO(engedy): Implement this. crbug.com/437865.
-  NOTIMPLEMENTED();
+  FacetManager* facet_manager = facet_managers_.get(facet_uri);
+  if (!facet_manager)
+    return;
+  facet_manager->CancelPrefetch(keep_fresh_until);
+
+  if (facet_manager->CanBeDiscarded())
+    facet_managers_.erase(facet_uri);
 }
 
 void AffiliationBackend::TrimCache() {
   DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
 
   // TODO(engedy): Implement this. crbug.com/437865.
   NOTIMPLEMENTED();
 }
 
+FacetManager* AffiliationBackend::GetOrCreateFacetManager(
+    const FacetURI& facet_uri) {
+  if (!facet_managers_.contains(facet_uri)) {
+    scoped_ptr<FacetManager> new_manager(
+        new FacetManager(facet_uri, this, clock_.get()));
+    facet_managers_.add(facet_uri, new_manager.Pass());
+  }
+  return facet_managers_.get(facet_uri);
+}
+
 void AffiliationBackend::SendNetworkRequest() {
   DCHECK(!fetcher_);
 
   std::vector<FacetURI> requested_facet_uris;
   for (const auto& facet_manager_pair : facet_managers_) {
     if (facet_manager_pair.second->DoesRequireFetch())
       requested_facet_uris.push_back(facet_manager_pair.first);
   }
   DCHECK(!requested_facet_uris.empty());
   fetcher_.reset(AffiliationFetcher::Create(request_context_getter_.get(),
                                             requested_facet_uris, this));
   fetcher_->StartRequest();
 }
 
-base::Time AffiliationBackend::GetCurrentTime() {
-  return clock_->Now();
-}
+void AffiliationBackend::OnSendNotification(const FacetURI& facet_uri) {
+  DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
 
-base::Time AffiliationBackend::ReadLastUpdateTimeFromDatabase(
-    const FacetURI& facet_uri) {
-  AffiliatedFacetsWithUpdateTime affiliation;
-  return ReadAffiliationsFromDatabase(facet_uri, &affiliation)
-             ? affiliation.last_update_time
-             : base::Time();
+  FacetManager* facet_manager = facet_managers_.get(facet_uri);
+  if (!facet_manager)
+    return;
+  facet_manager->NotifyAtRequestedTime();
+
+  if (facet_manager->CanBeDiscarded())
+    facet_managers_.erase(facet_uri);
 }
 
 bool AffiliationBackend::ReadAffiliationsFromDatabase(
     const FacetURI& facet_uri,
     AffiliatedFacetsWithUpdateTime* affiliations) {
   return cache_->GetAffiliationsForFacet(facet_uri, affiliations);
 }
 
 void AffiliationBackend::SignalNeedNetworkRequest() {
   // TODO(engedy): Add more sophisticated throttling logic. crbug.com/437865.
   if (fetcher_)
     return;
   SendNetworkRequest();
 }
 
+void AffiliationBackend::RequestNotificationAtTime(const FacetURI& facet_uri,
+                                                   base::Time time) {
+  // TODO(engedy): Avoid spamming the task runner; only ever schedule the first
+  // callback. crbug.com/437865.
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&AffiliationBackend::OnSendNotification,
+                            weak_ptr_factory_.GetWeakPtr(), facet_uri),
+      time - clock_->Now());

[Mike West, 2015/02/25 10:33:05]

Are prefetches meant to be stored across restarts? If so, what's responsible for
doing so? If not, it should be documented somewhere (maybe it is?).

[engedy, 2015/03/10 11:01:00]

Indeed, they will not survive a restart. This is documented in
affiliation_service.h.

+}
+
 void AffiliationBackend::OnFetchSucceeded(
     scoped_ptr<AffiliationFetcherDelegate::Result> result) {
   DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
   fetcher_.reset();
 
   for (const AffiliatedFacets& affiliated_facets : *result) {
     AffiliatedFacetsWithUpdateTime affiliation;
     affiliation.facets = affiliated_facets;
     affiliation.last_update_time = clock_->Now();
 
@@ skipping 35 matching lines @@
 }
 
 void AffiliationBackend::OnMalformedResponse() {
   DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
 
   // TODO(engedy): Implement this. crbug.com/437865.
   NOTIMPLEMENTED();
 }
 
 }  // namespace password_manager