Remove the unused OffDomainInclusionDetector

chrome/browser/safe_browsing/safe_browsing_database.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 "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 276 matching lines @@
       bool enable_download_whitelist,
       bool enable_extension_blacklist,
       bool enable_ip_blacklist,
       bool enable_unwanted_software_list,
       bool enable_module_whitelist) override {
     return new SafeBrowsingDatabaseNew(
         db_task_runner, CreateStore(true, db_task_runner),  // browse_store
         CreateStore(enable_download_protection, db_task_runner),
         CreateStore(enable_client_side_whitelist, db_task_runner),
         CreateStore(enable_download_whitelist, db_task_runner),
-        CreateStore(true, db_task_runner),  // inclusion_whitelist_store
         CreateStore(enable_extension_blacklist, db_task_runner),
         CreateStore(enable_ip_blacklist, db_task_runner),
         CreateStore(enable_unwanted_software_list, db_task_runner),
         CreateStore(enable_module_whitelist, db_task_runner),
         CreateStore(true, db_task_runner));  // resource_blacklist_store
   }
 
   SafeBrowsingDatabaseFactoryImpl() {}
 
  private:
@@ skipping 124 matching lines @@
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   if (list_id == PHISH || list_id == MALWARE) {
     return browse_store_.get();
   } else if (list_id == BINURL) {
     return download_store_.get();
   } else if (list_id == CSDWHITELIST) {
     return csd_whitelist_store_.get();
   } else if (list_id == DOWNLOADWHITELIST) {
     return download_whitelist_store_.get();
-  } else if (list_id == INCLUSIONWHITELIST) {
-    return inclusion_whitelist_store_.get();
   } else if (list_id == EXTENSIONBLACKLIST) {
     return extension_blacklist_store_.get();
   } else if (list_id == IPBLACKLIST) {
     return ip_blacklist_store_.get();
   } else if (list_id == UNWANTEDURL) {
     return unwanted_software_store_.get();
   } else if (list_id == MODULEWHITELIST) {
     return module_whitelist_store_.get();
   } else if (list_id == RESOURCEBLACKLIST) {
     return resource_blacklist_store_.get();
   }
   return NULL;
 }
 
 // static
 void SafeBrowsingDatabase::RecordFailure(FailureType failure_type) {
   UMA_HISTOGRAM_ENUMERATION("SB2.DatabaseFailure", failure_type,
                             FAILURE_DATABASE_MAX);
 }
 
 class SafeBrowsingDatabaseNew::ThreadSafeStateManager::ReadTransaction {
  public:
   const SBWhitelist* GetSBWhitelist(SBWhitelistId id) {
     switch (id) {
       case SBWhitelistId::CSD:
         return &outer_->csd_whitelist_;
       case SBWhitelistId::DOWNLOAD:
         return &outer_->download_whitelist_;
-      case SBWhitelistId::INCLUSION:
-        return &outer_->inclusion_whitelist_;
       case SBWhitelistId::MODULE:
         return &outer_->module_whitelist_;
     }
     NOTREACHED();
     return nullptr;
   }
 
   const IPBlacklist* ip_blacklist() { return &outer_->ip_blacklist_; }
 
   const PrefixSet* GetPrefixSet(PrefixSetId id) {
@@ skipping 90 matching lines @@
     DCHECK(outer_);
     DCHECK(outer_->db_task_runner_->RunsTasksOnCurrentThread());
   }
 
   SBWhitelist* SBWhitelistForId(SBWhitelistId id) {
     switch (id) {
       case SBWhitelistId::CSD:
         return &outer_->csd_whitelist_;
       case SBWhitelistId::DOWNLOAD:
         return &outer_->download_whitelist_;
-      case SBWhitelistId::INCLUSION:
-        return &outer_->inclusion_whitelist_;
       case SBWhitelistId::MODULE:
         return &outer_->module_whitelist_;
     }
     NOTREACHED();
     return nullptr;
   }
 
   ThreadSafeStateManager* outer_;
   base::AutoLock transaction_lock_;
 
@@ skipping 32 matching lines @@
 SafeBrowsingDatabaseNew::ThreadSafeStateManager::BeginWriteTransaction() {
   return base::WrapUnique(new WriteTransaction(this));
 }
 
 SafeBrowsingDatabaseNew::SafeBrowsingDatabaseNew(
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     SafeBrowsingStore* browse_store,
     SafeBrowsingStore* download_store,
     SafeBrowsingStore* csd_whitelist_store,
     SafeBrowsingStore* download_whitelist_store,
-    SafeBrowsingStore* inclusion_whitelist_store,
     SafeBrowsingStore* extension_blacklist_store,
     SafeBrowsingStore* ip_blacklist_store,
     SafeBrowsingStore* unwanted_software_store,
     SafeBrowsingStore* module_whitelist_store,
     SafeBrowsingStore* resource_blacklist_store)
     : db_task_runner_(db_task_runner),
       state_manager_(db_task_runner_),
       db_state_manager_(db_task_runner_),
       browse_store_(browse_store),
       download_store_(download_store),
       csd_whitelist_store_(csd_whitelist_store),
       download_whitelist_store_(download_whitelist_store),
-      inclusion_whitelist_store_(inclusion_whitelist_store),
       extension_blacklist_store_(extension_blacklist_store),
       ip_blacklist_store_(ip_blacklist_store),
       unwanted_software_store_(unwanted_software_store),
       module_whitelist_store_(module_whitelist_store),
       resource_blacklist_store_(resource_blacklist_store),
       reset_factory_(this) {
   DCHECK(browse_store_.get());
 }
 
 SafeBrowsingDatabaseNew::~SafeBrowsingDatabaseNew() {
@@ skipping 47 matching lines @@
 
     // Delete any files of the side-effect free sidelist that may be around
     // from when it was previously enabled.
     //
     // TODO(davidben): Remove this after April 15, 2016.
     SafeBrowsingStoreFile::DeleteStore(
         SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base()));
     base::DeleteFile(PrefixSetForFilename(SideEffectFreeWhitelistDBFilename(
                          db_state_manager_.filename_base())),
                      false);
+
+    // Delete any files of the off-domain inclusion whitelist that may be around
+    // from when it was previously enabled.
+    //
+    // TODO(joenotcharles): Remove this after May 11, 2017.
+    SafeBrowsingStoreFile::DeleteStore(
+        InclusionWhitelistDBFilename(db_state_manager_.filename_base()));
+    base::DeleteFile(PrefixSetForFilename(InclusionWhitelistDBFilename(
+                         db_state_manager_.filename_base())),
+                     false);
   }
   // Note: End the transaction early because LoadWhiteList() and
   // WhitelistEverything() manage their own transactions.
 
   if (download_store_.get()) {
     download_store_->Init(
         DownloadDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
   }
@@ skipping 27 matching lines @@
       LoadWhitelist(full_hashes, SBWhitelistId::DOWNLOAD);
     } else {
       state_manager_.BeginWriteTransaction()->WhitelistEverything(
           SBWhitelistId::DOWNLOAD);
     }
   } else {
     state_manager_.BeginWriteTransaction()->WhitelistEverything(
         SBWhitelistId::DOWNLOAD);  // Just to be safe.
   }
 
-  if (inclusion_whitelist_store_.get()) {
-    inclusion_whitelist_store_->Init(
-        InclusionWhitelistDBFilename(db_state_manager_.filename_base()),
-        base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
-                   base::Unretained(this)));
-
-    std::vector<SBAddFullHash> full_hashes;
-    if (inclusion_whitelist_store_->GetAddFullHashes(&full_hashes)) {
-      LoadWhitelist(full_hashes, SBWhitelistId::INCLUSION);
-    } else {
-      state_manager_.BeginWriteTransaction()->WhitelistEverything(
-          SBWhitelistId::INCLUSION);
-    }
-  } else {
-    state_manager_.BeginWriteTransaction()->WhitelistEverything(
-        SBWhitelistId::INCLUSION);  // Just to be safe.
-  }
-
   if (extension_blacklist_store_.get()) {
     extension_blacklist_store_->Init(
         ExtensionBlacklistDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
   }
 
   if (ip_blacklist_store_.get()) {
     ip_blacklist_store_->Init(
         IpBlacklistDBFilename(db_state_manager_.filename_base()),
@@ skipping 160 matching lines @@
   UrlToFullHashes(url, true, &full_hashes);
   return ContainsWhitelistedHashes(SBWhitelistId::CSD, full_hashes);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadWhitelistedUrl(const GURL& url) {
   std::vector<SBFullHash> full_hashes;
   UrlToFullHashes(url, true, &full_hashes);
   return ContainsWhitelistedHashes(SBWhitelistId::DOWNLOAD, full_hashes);
 }
 
-bool SafeBrowsingDatabaseNew::ContainsInclusionWhitelistedUrl(const GURL& url) {
-  std::vector<SBFullHash> full_hashes;
-  UrlToFullHashes(url, true, &full_hashes);
-  return ContainsWhitelistedHashes(SBWhitelistId::INCLUSION, full_hashes);
-}
-
 bool SafeBrowsingDatabaseNew::ContainsExtensionPrefixes(
     const std::vector<SBPrefix>& prefixes,
     std::vector<SBPrefix>* prefix_hits) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   if (!extension_blacklist_store_)
     return false;
 
   return MatchAddPrefixes(extension_blacklist_store_.get(),
                           EXTENSIONBLACKLIST % 2, prefixes, prefix_hits);
@@ skipping 247 matching lines @@
     return false;
   }
 
   if (download_whitelist_store_.get() &&
       !download_whitelist_store_->BeginUpdate()) {
     RecordFailure(FAILURE_WHITELIST_DATABASE_UPDATE_BEGIN);
     HandleCorruptDatabase();
     return false;
   }
 
-  if (inclusion_whitelist_store_.get() &&
-      !inclusion_whitelist_store_->BeginUpdate()) {
-    RecordFailure(FAILURE_WHITELIST_DATABASE_UPDATE_BEGIN);
-    HandleCorruptDatabase();
-    return false;
-  }
-
   if (extension_blacklist_store_ &&
       !extension_blacklist_store_->BeginUpdate()) {
     RecordFailure(FAILURE_EXTENSION_BLACKLIST_UPDATE_BEGIN);
     HandleCorruptDatabase();
     return false;
   }
 
   if (ip_blacklist_store_ && !ip_blacklist_store_->BeginUpdate()) {
     RecordFailure(FAILURE_IP_BLACKLIST_UPDATE_BEGIN);
     HandleCorruptDatabase();
@@ skipping 30 matching lines @@
   // deprecated.  Code to delete the list from the store shows ~15k hits/day as
   // of Feb 2014, so it has been removed.  Everything _should_ be resilient to
   // extra data of that sort.
   UpdateChunkRangesForList(download_store_.get(), kBinUrlList, lists);
 
   UpdateChunkRangesForList(csd_whitelist_store_.get(), kCsdWhiteList, lists);
 
   UpdateChunkRangesForList(download_whitelist_store_.get(), kDownloadWhiteList,
                            lists);
 
-  UpdateChunkRangesForList(inclusion_whitelist_store_.get(),
-                           kInclusionWhitelist, lists);
-
   UpdateChunkRangesForList(extension_blacklist_store_.get(),
                            kExtensionBlacklist, lists);
 
   UpdateChunkRangesForList(ip_blacklist_store_.get(), kIPBlacklist, lists);
 
   UpdateChunkRangesForList(unwanted_software_store_.get(), kUnwantedUrlList,
                            lists);
 
   UpdateChunkRangesForList(module_whitelist_store_.get(), kModuleWhitelist,
                            lists);
@@ skipping 23 matching lines @@
       DLOG(ERROR) << "Safe-browsing download database corrupt.";
 
     if (csd_whitelist_store_.get() && !csd_whitelist_store_->CheckValidity())
       DLOG(ERROR) << "Safe-browsing csd whitelist database corrupt.";
 
     if (download_whitelist_store_.get() &&
         !download_whitelist_store_->CheckValidity()) {
       DLOG(ERROR) << "Safe-browsing download whitelist database corrupt.";
     }
 
-    if (inclusion_whitelist_store_.get() &&
-        !inclusion_whitelist_store_->CheckValidity()) {
-      DLOG(ERROR) << "Safe-browsing inclusion whitelist database corrupt.";
-    }
-
     if (extension_blacklist_store_ &&
         !extension_blacklist_store_->CheckValidity()) {
       DLOG(ERROR) << "Safe-browsing extension blacklist database corrupt.";
     }
 
     if (ip_blacklist_store_ && !ip_blacklist_store_->CheckValidity()) {
       DLOG(ERROR) << "Safe-browsing IP blacklist database corrupt.";
     }
 
     if (unwanted_software_store_ &&
@@ skipping 21 matching lines @@
     // Track empty updates to answer questions at http://crbug.com/72216 .
     if (update_succeeded && !db_state_manager_.change_detected())
       UMA_HISTOGRAM_COUNTS("SB2.DatabaseUpdateKilobytes", 0);
     browse_store_->CancelUpdate();
     if (download_store_.get())
       download_store_->CancelUpdate();
     if (csd_whitelist_store_.get())
       csd_whitelist_store_->CancelUpdate();
     if (download_whitelist_store_.get())
       download_whitelist_store_->CancelUpdate();
-    if (inclusion_whitelist_store_.get())
-      inclusion_whitelist_store_->CancelUpdate();
     if (extension_blacklist_store_)
       extension_blacklist_store_->CancelUpdate();
     if (ip_blacklist_store_)
       ip_blacklist_store_->CancelUpdate();
     if (unwanted_software_store_)
       unwanted_software_store_->CancelUpdate();
     if (module_whitelist_store_)
       module_whitelist_store_->CancelUpdate();
     if (resource_blacklist_store_)
       resource_blacklist_store_->CancelUpdate();
@@ skipping 10 matching lines @@
                           browse_store_.get(), PrefixSetId::BROWSE,
                           FAILURE_BROWSE_DATABASE_UPDATE_FINISH,
                           FAILURE_BROWSE_PREFIX_SET_WRITE, true);
 
   UpdateWhitelistStore(
       CsdWhitelistDBFilename(db_state_manager_.filename_base()),
       csd_whitelist_store_.get(), SBWhitelistId::CSD);
   UpdateWhitelistStore(
       DownloadWhitelistDBFilename(db_state_manager_.filename_base()),
       download_whitelist_store_.get(), SBWhitelistId::DOWNLOAD);
-  UpdateWhitelistStore(
-      InclusionWhitelistDBFilename(db_state_manager_.filename_base()),
-      inclusion_whitelist_store_.get(), SBWhitelistId::INCLUSION);
 
   if (extension_blacklist_store_) {
     UpdateHashPrefixStore(
         ExtensionBlacklistDBFilename(db_state_manager_.filename_base()),
         extension_blacklist_store_.get(),
         FAILURE_EXTENSION_BLACKLIST_UPDATE_FINISH);
   }
 
   if (ip_blacklist_store_)
     UpdateIpBlacklistStore();
@@ skipping 258 matching lines @@
       csd_whitelist_store_.get() ? csd_whitelist_store_->Delete() : true;
   if (!r3)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
   const bool r4 = download_whitelist_store_.get()
                       ? download_whitelist_store_->Delete()
                       : true;
   if (!r4)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
-  const bool r5 = inclusion_whitelist_store_.get()
-                      ? inclusion_whitelist_store_->Delete()
-                      : true;
-  if (!r5)
-    RecordFailure(FAILURE_DATABASE_STORE_DELETE);
-
   const base::FilePath browse_filename =
       BrowseDBFilename(db_state_manager_.filename_base());
   const base::FilePath bloom_filter_filename =
       BloomFilterForFilename(browse_filename);
-  const bool r6 = base::DeleteFile(bloom_filter_filename, false);
-  if (!r6)
+  const bool r5 = base::DeleteFile(bloom_filter_filename, false);
+  if (!r5)
     RecordFailure(FAILURE_DATABASE_FILTER_DELETE);
 
   const base::FilePath browse_prefix_set_filename =
       PrefixSetForFilename(browse_filename);
-  const bool r7 = base::DeleteFile(browse_prefix_set_filename, false);
-  if (!r7)
+  const bool r6 = base::DeleteFile(browse_prefix_set_filename, false);
+  if (!r6)
     RecordFailure(FAILURE_BROWSE_PREFIX_SET_DELETE);
 
   const base::FilePath extension_blacklist_filename =
       ExtensionBlacklistDBFilename(db_state_manager_.filename_base());
-  const bool r8 = base::DeleteFile(extension_blacklist_filename, false);
-  if (!r8)
+  const bool r7 = base::DeleteFile(extension_blacklist_filename, false);
+  if (!r7)
     RecordFailure(FAILURE_EXTENSION_BLACKLIST_DELETE);
 
-  const bool r9 = base::DeleteFile(
+  const bool r8 = base::DeleteFile(
       IpBlacklistDBFilename(db_state_manager_.filename_base()), false);
-  if (!r9)
+  if (!r8)
     RecordFailure(FAILURE_IP_BLACKLIST_DELETE);
 
-  const bool r10 = base::DeleteFile(
+  const bool r9 = base::DeleteFile(
       UnwantedSoftwareDBFilename(db_state_manager_.filename_base()), false);
-  if (!r10)
+  if (!r9)
     RecordFailure(FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_DELETE);
 
-  const bool r11 = base::DeleteFile(
+  const bool r10 = base::DeleteFile(
       ResourceBlacklistDBFilename(db_state_manager_.filename_base()), false);
-  if (!r11)
+  if (!r10)
     RecordFailure(FAILURE_RESOURCE_BLACKLIST_DELETE);
 
-  const bool r12 =
+  const bool r11 =
       module_whitelist_store_.get() ? module_whitelist_store_->Delete() : true;
-  if (!r12)
+  if (!r11)
     RecordFailure(FAILURE_MODULE_WHITELIST_DELETE);
 
-  return r1 && r2 && r3 && r4 && r5 && r6 && r7 && r8 && r9 && r10 && r11 &&
-         r12;
+  return r1 && r2 && r3 && r4 && r5 && r6 && r7 && r8 && r9 && r10 && r11;
 }
 
 void SafeBrowsingDatabaseNew::WritePrefixSet(const base::FilePath& db_filename,
                                              PrefixSetId prefix_set_id,
                                              FailureType write_failure_type) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   // Do not grab the lock to avoid contention while writing to disk. This is
   // safe as only this task runner can ever modify |state_manager_|'s prefix
   // sets anyways.
@@ skipping 170 matching lines @@
 
   // Histogram properties as in UMA_HISTOGRAM_COUNTS macro.
   base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
       histogram_name, 1, 1000000, 50,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram_pointer->Add(file_size_kilobytes);
 }
 
 }  // namespace safe_browsing