Support restricting browsing data removal for downloads by origin.

content/browser/download/download_manager_impl.cc

 // Copyright (c) 2012 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 "content/browser/download/download_manager_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 26 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/referrer.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/url_request/url_request_context.h"
+#include "url/origin.h"
 
 namespace content {
 namespace {
 
 void BeginDownload(scoped_ptr<DownloadUrlParameters> params,
                    uint32 download_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // ResourceDispatcherHost{Base} is-not-a URLRequest::Delegate, and
   // DownloadUrlParameters can-not include resource_dispatcher_host_impl.h, so
   // we must down cast. RDHI is the only subclass of RDH as of 2012 May 4.
@@ skipping 501 matching lines @@
 void DownloadManagerImpl::DownloadRemoved(DownloadItemImpl* download) {
   if (!download)
     return;
 
   uint32 download_id = download->GetId();
   if (downloads_.erase(download_id) == 0)
     return;
   delete download;
 }
 
-int DownloadManagerImpl::RemoveDownloadsBetween(base::Time remove_begin,
-                                                base::Time remove_end) {
+namespace {
+
+bool RemoveDownloadBetween(base::Time remove_begin,
+                           base::Time remove_end,
+                           const DownloadItemImpl* download_item) {
+  return download_item->GetStartTime() >= remove_begin &&
+         (remove_end.is_null() || download_item->GetStartTime() < remove_end);
+}
+
+bool RemoveDownloadByOriginAndTime(const url::Origin& origin,
+                                   base::Time remove_begin,
+                                   base::Time remove_end,
+                                   const DownloadItemImpl* download_item) {
+  return origin.IsSameOriginWith(url::Origin(download_item->GetURL())) &&
+         RemoveDownloadBetween(remove_begin, remove_end, download_item);
+}
+
+}  // namespace
+
+int DownloadManagerImpl::RemoveDownloads(const DownloadRemover& remover) {
   int count = 0;
   DownloadMap::const_iterator it = downloads_.begin();
   while (it != downloads_.end()) {
     DownloadItemImpl* download = it->second;
 
     // Increment done here to protect against invalidation below.
     ++it;
 
-    if (download->GetStartTime() >= remove_begin &&
-        (remove_end.is_null() || download->GetStartTime() < remove_end) &&
-        (download->GetState() != DownloadItem::IN_PROGRESS)) {
-      // Erases the download from downloads_.
+    if (download->GetState() != DownloadItem::IN_PROGRESS &&
+        remover.Run(download)) {
       download->Remove();
       count++;
     }
   }
   return count;
 }
 
+int DownloadManagerImpl::RemoveDownloadsByOriginAndTime(
+    const url::Origin& origin,
+    base::Time remove_begin,
+    base::Time remove_end) {
+  return RemoveDownloads(base::Bind(&RemoveDownloadByOriginAndTime,
+                                    base::ConstRef(origin), remove_begin,
+                                    remove_end));
+}
+
+int DownloadManagerImpl::RemoveDownloadsBetween(base::Time remove_begin,
+                                                base::Time remove_end) {
+  return RemoveDownloads(
+      base::Bind(&RemoveDownloadBetween, remove_begin, remove_end));
+}
+
 int DownloadManagerImpl::RemoveDownloads(base::Time remove_begin) {
   return RemoveDownloadsBetween(remove_begin, base::Time());
 }
 
 int DownloadManagerImpl::RemoveAllDownloads() {
   // The null times make the date range unbounded.
   int num_deleted = RemoveDownloadsBetween(base::Time(), base::Time());
   RecordClearAllSize(num_deleted);
   return num_deleted;
 }
@@ skipping 117 matching lines @@
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content