Add support for time based deletion of browsing data on iOS

ios/net/http_cache_helper.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 "ios/net/http_cache_helper.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 15 matching lines @@
 // Posts |callback| on |task_runner|.
 void PostCallback(const scoped_refptr<base::TaskRunner>& task_runner,
                   const net::CompletionCallback& callback,
                   int error) {
   task_runner->PostTask(FROM_HERE, base::Bind(callback, error));
 }
 
 // Clears the disk_cache::Backend on the IO thread and deletes |backend|.
 void DoomHttpCache(std::unique_ptr<disk_cache::Backend*> backend,
                    const scoped_refptr<base::TaskRunner>& client_task_runner,
+                   const base::Time& delete_begin,
+                   const base::Time& delete_end,
                    const net::CompletionCallback& callback,
                    int error) {
   // |*backend| may be null in case of error.
   if (*backend) {
-    (*backend)->DoomAllEntries(
+    (*backend)->DoomEntriesBetween(
+        delete_begin, delete_end,
         base::Bind(&PostCallback, client_task_runner, callback));
   } else {
     client_task_runner->PostTask(FROM_HERE, base::Bind(callback, error));
   }
 }
 
 // Clears various caches synchronously and the disk_cache::Backend
 // asynchronously.
 void ClearHttpCacheOnIOThread(
     const scoped_refptr<net::URLRequestContextGetter>& getter,
     const scoped_refptr<base::TaskRunner>& client_task_runner,
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
     const net::CompletionCallback& callback) {
   net::HttpCache* http_cache =
       getter->GetURLRequestContext()->http_transaction_factory()->GetCache();
 
   // Clear QUIC server information from memory and the disk cache.
   http_cache->GetSession()
       ->quic_stream_factory()
       ->ClearCachedStatesInCryptoConfig(base::Callback<bool(const GURL&)>());
 
   // Clear SDCH dictionary state.
   net::SdchManager* sdch_manager =
       getter->GetURLRequestContext()->sdch_manager();
   // The test is probably overkill, since chrome should always have an
   // SdchManager.  But in general the URLRequestContext  is *not*
   // guaranteed to have an SdchManager, so checking is wise.
   if (sdch_manager)
     sdch_manager->ClearData();
 
   std::unique_ptr<disk_cache::Backend*> backend(
       new disk_cache::Backend*(nullptr));
   disk_cache::Backend** backend_ptr = backend.get();
   net::CompletionCallback doom_callback =
       base::Bind(&DoomHttpCache, base::Passed(std::move(backend)),
-                 client_task_runner, callback);
+                 client_task_runner, delete_begin, delete_end, callback);
 
   int rv = http_cache->GetBackend(backend_ptr, doom_callback);
 
   if (rv != net::ERR_IO_PENDING) {
     // GetBackend doesn't call the callback if it completes synchronously, so
     // call it directly here.
     doom_callback.Run(rv);
   }
 }
 
 }  // namespace
 
 namespace net {
 
 void ClearHttpCache(const scoped_refptr<net::URLRequestContextGetter>& getter,
                     const scoped_refptr<base::TaskRunner>& network_task_runner,
+                    const base::Time& delete_begin,
+                    const base::Time& delete_end,
                     const net::CompletionCallback& callback) {
+  DCHECK(delete_end != base::Time());
   network_task_runner->PostTask(
       FROM_HERE, base::Bind(&ClearHttpCacheOnIOThread, getter,
-                            base::ThreadTaskRunnerHandle::Get(), callback));
+                            base::ThreadTaskRunnerHandle::Get(), delete_begin,
+                            delete_end, callback));
 }
 
 }  // namespace net