Supervised user SafeSites: don't cache results for more than one hour

chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.cc

 // Copyright 2014 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/supervised_user/experimental/supervised_user_async_url_checker.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
@@ skipping 17 matching lines @@
 using net::URLRequestContextGetter;
 using net::URLRequestStatus;
 
 namespace {
 
 const char kApiUrl[] = "https://safesearch.googleapis.com/v1:classify";
 const char kDataContentType[] = "application/x-www-form-urlencoded";
 const char kDataFormat[] = "key=%s&urls=%s";
 
 const size_t kDefaultCacheSize = 1000;
+const size_t kDefaultCacheTimeoutSeconds = 3600;
 
 // Builds the POST data for SafeSearch API requests.
 std::string BuildRequestData(const std::string& api_key, const GURL& url) {
   std::string query = net::EscapeQueryParamValue(url.spec(), true);
   return base::StringPrintf(kDataFormat, api_key.c_str(), query.c_str());
 }
 
 // Creates a URLFetcher to call the SafeSearch API for |url|.
 scoped_ptr<net::URLFetcher> CreateFetcher(URLFetcherDelegate* delegate,
                                           URLRequestContextGetter* context,
@@ skipping 39 matching lines @@
 
 struct SupervisedUserAsyncURLChecker::Check {
   Check(const GURL& url,
         scoped_ptr<net::URLFetcher> fetcher,
         const CheckCallback& callback);
   ~Check();
 
   GURL url;
   scoped_ptr<net::URLFetcher> fetcher;
   std::vector<CheckCallback> callbacks;
-  base::Time start_time;
+  base::TimeTicks start_time;
 };
 
 SupervisedUserAsyncURLChecker::Check::Check(
     const GURL& url,
     scoped_ptr<net::URLFetcher> fetcher,
     const CheckCallback& callback)
     : url(url),
       fetcher(fetcher.Pass()),
       callbacks(1, callback),
-      start_time(base::Time::Now()) {
+      start_time(base::TimeTicks::Now()) {
 }
 
 SupervisedUserAsyncURLChecker::Check::~Check() {}
 
 SupervisedUserAsyncURLChecker::CheckResult::CheckResult(
-    SupervisedUserURLFilter::FilteringBehavior behavior, bool uncertain)
-    : behavior(behavior), uncertain(uncertain) {
-}
+    SupervisedUserURLFilter::FilteringBehavior behavior,
+    bool uncertain)
+    : behavior(behavior),
+      uncertain(uncertain),
+      timestamp(base::TimeTicks::Now()) {}
 
 SupervisedUserAsyncURLChecker::SupervisedUserAsyncURLChecker(
     URLRequestContextGetter* context)
-    : context_(context), cache_(kDefaultCacheSize) {
-}
+    : SupervisedUserAsyncURLChecker(context, kDefaultCacheSize) {}
 
 SupervisedUserAsyncURLChecker::SupervisedUserAsyncURLChecker(
     URLRequestContextGetter* context,
     size_t cache_size)
-    : context_(context), cache_(cache_size) {
-}
+    : context_(context),
+      cache_(cache_size),
+      cache_timeout_(
+          base::TimeDelta::FromSeconds(kDefaultCacheTimeoutSeconds)) {}
 
 SupervisedUserAsyncURLChecker::~SupervisedUserAsyncURLChecker() {}
 
 bool SupervisedUserAsyncURLChecker::CheckURL(const GURL& url,
                                              const CheckCallback& callback) {
-  // TODO(treib): Hack: For now, allow all Google URLs to save search QPS. If we
-  // ever remove this, we should find a way to allow at least the NTP.
+  // TODO(treib): Hack: For now, allow all Google URLs to save QPS. If we ever
+  // remove this, we should find a way to allow at least the NTP.
   if (google_util::IsGoogleDomainUrl(url,
                                      google_util::ALLOW_SUBDOMAIN,
                                      google_util::ALLOW_NON_STANDARD_PORTS)) {
     callback.Run(url, SupervisedUserURLFilter::ALLOW, false);
     return true;
   }
   // TODO(treib): Hack: For now, allow all YouTube URLs since YouTube has its
   // own Safety Mode anyway.
   if (google_util::IsYoutubeDomainUrl(url,
                                       google_util::ALLOW_SUBDOMAIN,
                                       google_util::ALLOW_NON_STANDARD_PORTS)) {
     callback.Run(url, SupervisedUserURLFilter::ALLOW, false);
     return true;
   }
 
   auto cache_it = cache_.Get(url);
   if (cache_it != cache_.end()) {
     const CheckResult& result = cache_it->second;
-    DVLOG(1) << "Cache hit! " << url.spec() << " is "
-             << (result.behavior == SupervisedUserURLFilter::BLOCK ? "NOT" : "")
-             << " safe; certain: " << !result.uncertain;
-    callback.Run(url, result.behavior, result.uncertain);
-    return true;
+    base::TimeDelta age = base::TimeTicks::Now() - result.timestamp;
+    if (age < cache_timeout_) {
+      DVLOG(1) << "Cache hit! " << url.spec() << " is "
+               << (result.behavior == SupervisedUserURLFilter::BLOCK ? "NOT"
+                                                                     : "")
+               << " safe; certain: " << !result.uncertain;
+      callback.Run(url, result.behavior, result.uncertain);
+      return true;
+    }
+    DVLOG(1) << "Outdated cache entry for " << url.spec() << ", purging";
+    cache_.Erase(cache_it);
   }
 
   // See if we already have a check in progress for this URL.
   for (Check* check : checks_in_progress_) {
     if (check->url == url) {
       DVLOG(1) << "Adding to pending check for " << url.spec();
       check->callbacks.push_back(callback);
       return false;
     }
   }
@@ skipping 27 matching lines @@
   }
 
   std::string response_body;
   source->GetResponseAsString(&response_body);
   bool is_porn = false;
   bool uncertain = !ParseResponse(response_body, &is_porn);
   SupervisedUserURLFilter::FilteringBehavior behavior =
       is_porn ? SupervisedUserURLFilter::BLOCK : SupervisedUserURLFilter::ALLOW;
 
   UMA_HISTOGRAM_TIMES("ManagedUsers.SafeSitesDelay",
-                      base::Time::Now() - check->start_time);
+                      base::TimeTicks::Now() - check->start_time);
 
   cache_.Put(check->url, CheckResult(behavior, uncertain));
 
   for (size_t i = 0; i < check->callbacks.size(); i++)
     check->callbacks[i].Run(check->url, behavior, uncertain);
   checks_in_progress_.erase(it);
 }