Remove PrerenderLocalPredictor, part 2.

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 <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 307 matching lines @@
 
 // The default SafeBrowsingDatabaseFactory.
 class SafeBrowsingDatabaseFactoryImpl : public SafeBrowsingDatabaseFactory {
  public:
   SafeBrowsingDatabase* CreateSafeBrowsingDatabase(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       bool enable_download_protection,
       bool enable_client_side_whitelist,
       bool enable_download_whitelist,
       bool enable_extension_blacklist,
-      bool enable_side_effect_free_whitelist,
       bool enable_ip_blacklist,
       bool enable_unwanted_software_list) 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_side_effect_free_whitelist, db_task_runner),
         CreateStore(enable_ip_blacklist, db_task_runner),
         CreateStore(enable_unwanted_software_list, db_task_runner));
   }
 
   SafeBrowsingDatabaseFactoryImpl() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseFactoryImpl);
 };
 
 // static
 SafeBrowsingDatabaseFactory* SafeBrowsingDatabase::factory_ = NULL;
 
 // Factory method, should be called on the Safe Browsing sequenced task runner,
 // which is also passed to the function as |current_task_runner|.
 // TODO(shess): There's no need for a factory any longer.  Convert
 // SafeBrowsingDatabaseNew to SafeBrowsingDatabase, and have Create()
 // callers just construct things directly.
 SafeBrowsingDatabase* SafeBrowsingDatabase::Create(
     const scoped_refptr<base::SequencedTaskRunner>& current_task_runner,
     bool enable_download_protection,
     bool enable_client_side_whitelist,
     bool enable_download_whitelist,
     bool enable_extension_blacklist,
-    bool enable_side_effect_free_whitelist,
     bool enable_ip_blacklist,
     bool enable_unwanted_software_list) {
   DCHECK(current_task_runner->RunsTasksOnCurrentThread());
   if (!factory_)
     factory_ = new SafeBrowsingDatabaseFactoryImpl();
   return factory_->CreateSafeBrowsingDatabase(
       current_task_runner, enable_download_protection,
       enable_client_side_whitelist, enable_download_whitelist,
-      enable_extension_blacklist, enable_side_effect_free_whitelist,
-      enable_ip_blacklist, enable_unwanted_software_list);
+      enable_extension_blacklist, enable_ip_blacklist,
+      enable_unwanted_software_list);
 }
 
 SafeBrowsingDatabase::~SafeBrowsingDatabase() {
 }
 
 // static
 base::FilePath SafeBrowsingDatabase::BrowseDBFilename(
     const base::FilePath& db_base_filename) {
   return base::FilePath(db_base_filename.value() + kBrowseDBFile);
 }
@@ skipping 80 matching lines @@
   } else if (list_id == safe_browsing_util::BINURL) {
     return download_store_.get();
   } else if (list_id == safe_browsing_util::CSDWHITELIST) {
     return csd_whitelist_store_.get();
   } else if (list_id == safe_browsing_util::DOWNLOADWHITELIST) {
     return download_whitelist_store_.get();
   } else if (list_id == safe_browsing_util::INCLUSIONWHITELIST) {
     return inclusion_whitelist_store_.get();
   } else if (list_id == safe_browsing_util::EXTENSIONBLACKLIST) {
     return extension_blacklist_store_.get();
-  } else if (list_id == safe_browsing_util::SIDEEFFECTFREEWHITELIST) {
-    return side_effect_free_whitelist_store_.get();
   } else if (list_id == safe_browsing_util::IPBLACKLIST) {
     return ip_blacklist_store_.get();
   } else if (list_id == safe_browsing_util::UNWANTEDURL) {
     return unwanted_software_store_.get();
   }
   return NULL;
 }
 
 // static
 void SafeBrowsingDatabase::RecordFailure(FailureType failure_type) {
@@ skipping 15 matching lines @@
     NOTREACHED();
     return nullptr;
   }
 
   const IPBlacklist* ip_blacklist() { return &outer_->ip_blacklist_; }
 
   const PrefixSet* GetPrefixSet(PrefixSetId id) {
     switch (id) {
       case PrefixSetId::BROWSE:
         return outer_->browse_prefix_set_.get();
-      case PrefixSetId::SIDE_EFFECT_FREE_WHITELIST:
-        return outer_->side_effect_free_whitelist_prefix_set_.get();
       case PrefixSetId::UNWANTED_SOFTWARE:
         return outer_->unwanted_software_prefix_set_.get();
     }
     NOTREACHED();
     return nullptr;
   }
 
   PrefixGetHashCache* prefix_gethash_cache() {
     // The cache is special: it is read/write on all threads. Access to it
     // therefore requires a LOCK'ed transaction (i.e. it can't benefit from
@@ skipping 53 matching lines @@
   void swap_ip_blacklist(IPBlacklist* new_blacklist) {
     outer_->ip_blacklist_.swap(*new_blacklist);
   }
 
   void SwapPrefixSet(PrefixSetId id,
                      scoped_ptr<const PrefixSet> new_prefix_set) {
     switch (id) {
       case PrefixSetId::BROWSE:
         outer_->browse_prefix_set_.swap(new_prefix_set);
         break;
-      case PrefixSetId::SIDE_EFFECT_FREE_WHITELIST:
-        outer_->side_effect_free_whitelist_prefix_set_.swap(new_prefix_set);
-        break;
       case PrefixSetId::UNWANTED_SOFTWARE:
         outer_->unwanted_software_prefix_set_.swap(new_prefix_set);
         break;
     }
   }
 
   void clear_prefix_gethash_cache() { outer_->prefix_gethash_cache_.clear(); }
 
  private:
   // Only ThreadSafeStateManager is allowed to build a WriteTransaction.
@@ skipping 61 matching lines @@
 }
 
 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* side_effect_free_whitelist_store,
     SafeBrowsingStore* ip_blacklist_store,
     SafeBrowsingStore* unwanted_software_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),
-      side_effect_free_whitelist_store_(side_effect_free_whitelist_store),
       ip_blacklist_store_(ip_blacklist_store),
       unwanted_software_store_(unwanted_software_store),
       reset_factory_(this) {
   DCHECK(browse_store_.get());
 }
 
 SafeBrowsingDatabaseNew::~SafeBrowsingDatabaseNew() {
   // The DCHECK is disabled due to crbug.com/338486 .
   // DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 }
@@ skipping 34 matching lines @@
     LoadPrefixSet(BrowseDBFilename(db_state_manager_.filename_base()),
                   txn.get(), PrefixSetId::BROWSE,
                   FAILURE_BROWSE_PREFIX_SET_READ);
     if (unwanted_software_store_.get()) {
       LoadPrefixSet(
           UnwantedSoftwareDBFilename(db_state_manager_.filename_base()),
           txn.get(), PrefixSetId::UNWANTED_SOFTWARE,
           FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_READ);
     }
 
-    if (side_effect_free_whitelist_store_.get()) {
-      const base::FilePath side_effect_free_whitelist_filename =
-          SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base());
-      side_effect_free_whitelist_store_->Init(
-          side_effect_free_whitelist_filename,
-          base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
-                     base::Unretained(this)));
-
-      LoadPrefixSet(side_effect_free_whitelist_filename, txn.get(),
-                    PrefixSetId::SIDE_EFFECT_FREE_WHITELIST,
-                    FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_READ);
-    } else {
-      // Delete any files of the side-effect free sidelist that may be around
-      // from when it was previously enabled.
-      SafeBrowsingStoreFile::DeleteStore(
-          SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base()));
-      base::DeleteFile(PrefixSetForFilename(SideEffectFreeWhitelistDBFilename(
-                           db_state_manager_.filename_base())),
-                       false);
-    }
+    // Delete any files of the side-effect free sidelist that may be around
+    // from when it was previously enabled.

[Alexei Svitkine (slow), 2015/04/10 15:03:37]

Should this have a TODO() to clean up this code in some number of releases?

[Scott Hess - ex-Googler, 2015/04/10 15:51:45]

I'd say after a specific date, but wouldn't worry too much about whether anyone
bothers (given the I/O load in this region, this operation really only costs the
code to support it).

I once would have been able to tell you how quickly things churn based on the
version-tracking histograms (for stores and prefix sets), but I no longer
remember.  I think around two release cycles was where I started to wonder if
the numbers were reflecting organic restarts versus weird edge cases, like
restarts from freeze-dried VM images, or profiles with broken storage that
wasn't writable.  So if this said something like "Delete after April 15, 2016",
I think you'd be more than safe.

[davidben, 2015/04/13 19:48:18]

Done.

+    SafeBrowsingStoreFile::DeleteStore(
+        SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base()));
+    base::DeleteFile(PrefixSetForFilename(SideEffectFreeWhitelistDBFilename(
+                         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 80 matching lines @@
   // Delete files on disk.
   // TODO(shess): Hard to see where one might want to delete without a
   // reset.  Perhaps inline |Delete()|?
   if (!Delete())
     return false;
 
   // Reset objects in memory.
   scoped_ptr<WriteTransaction> txn = state_manager_.BeginWriteTransaction();
   txn->clear_prefix_gethash_cache();
   txn->SwapPrefixSet(PrefixSetId::BROWSE, nullptr);
-  txn->SwapPrefixSet(PrefixSetId::SIDE_EFFECT_FREE_WHITELIST, nullptr);
   txn->SwapPrefixSet(PrefixSetId::UNWANTED_SOFTWARE, nullptr);
   txn->clear_ip_blacklist();
   txn->WhitelistEverything(SBWhitelistId::CSD);
   txn->WhitelistEverything(SBWhitelistId::DOWNLOAD);
   return true;
 }
 
 bool SafeBrowsingDatabaseNew::ContainsBrowseUrl(
     const GURL& url,
     std::vector<SBPrefix>* prefix_hits,
@@ skipping 111 matching lines @@
 
   if (!extension_blacklist_store_)
     return false;
 
   return MatchAddPrefixes(extension_blacklist_store_.get(),
                           safe_browsing_util::EXTENSIONBLACKLIST % 2,
                           prefixes,
                           prefix_hits);
 }
 
-bool SafeBrowsingDatabaseNew::ContainsSideEffectFreeWhitelistUrl(
-    const GURL& url) {
-  std::string host;
-  std::string path;
-  std::string query;
-  safe_browsing_util::CanonicalizeUrl(url, &host, &path, &query);
-  std::string url_to_check = host + path;
-  if (!query.empty())
-    url_to_check +=  "?" + query;
-  SBFullHash full_hash = SBFullHashForString(url_to_check);
-
-  scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
-
-  const PrefixSet* side_effect_free_whitelist_prefix_set =
-      txn->GetPrefixSet(PrefixSetId::SIDE_EFFECT_FREE_WHITELIST);
-
-  // |side_effect_free_whitelist_prefix_set_| is empty until it is either read
-  // from disk, or the first update populates it.  Bail out without a hit if
-  // not yet available.
-  if (!side_effect_free_whitelist_prefix_set)
-    return false;
-
-  return side_effect_free_whitelist_prefix_set->Exists(full_hash);
-}
-
 bool SafeBrowsingDatabaseNew::ContainsMalwareIP(const std::string& ip_address) {
   net::IPAddressNumber ip_number;
   if (!net::ParseIPLiteralToNumber(ip_address, &ip_number))
     return false;
   if (ip_number.size() == net::kIPv4AddressSize)
     ip_number = net::ConvertIPv4NumberToIPv6Number(ip_number);
   if (ip_number.size() != net::kIPv6AddressSize)
     return false;  // better safe than sorry.
 
   scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
@@ skipping 232 matching lines @@
     return false;
   }
 
   if (extension_blacklist_store_ &&
       !extension_blacklist_store_->BeginUpdate()) {
     RecordFailure(FAILURE_EXTENSION_BLACKLIST_UPDATE_BEGIN);
     HandleCorruptDatabase();
     return false;
   }
 
-  if (side_effect_free_whitelist_store_ &&
-      !side_effect_free_whitelist_store_->BeginUpdate()) {
-    RecordFailure(FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_BEGIN);
-    HandleCorruptDatabase();
-    return false;
-  }
-
   if (ip_blacklist_store_ && !ip_blacklist_store_->BeginUpdate()) {
     RecordFailure(FAILURE_IP_BLACKLIST_UPDATE_BEGIN);
     HandleCorruptDatabase();
     return false;
   }
 
   if (unwanted_software_store_ && !unwanted_software_store_->BeginUpdate()) {
     RecordFailure(FAILURE_UNWANTED_SOFTWARE_DATABASE_UPDATE_BEGIN);
     HandleCorruptDatabase();
     return false;
@@ skipping 20 matching lines @@
 
   UpdateChunkRangesForList(download_whitelist_store_.get(),
                            safe_browsing_util::kDownloadWhiteList, lists);
 
   UpdateChunkRangesForList(inclusion_whitelist_store_.get(),
                            safe_browsing_util::kInclusionWhitelist, lists);
 
   UpdateChunkRangesForList(extension_blacklist_store_.get(),
                            safe_browsing_util::kExtensionBlacklist, lists);
 
-  UpdateChunkRangesForList(side_effect_free_whitelist_store_.get(),
-                           safe_browsing_util::kSideEffectFreeWhitelist, lists);
-
   UpdateChunkRangesForList(ip_blacklist_store_.get(),
                            safe_browsing_util::kIPBlacklist, lists);
 
   UpdateChunkRangesForList(unwanted_software_store_.get(),
                            safe_browsing_util::kUnwantedUrlList,
                            lists);
 
   db_state_manager_.reset_corruption_detected();
   db_state_manager_.reset_change_detected();
   return true;
@@ skipping 26 matching lines @@
     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 (side_effect_free_whitelist_store_ &&
-        !side_effect_free_whitelist_store_->CheckValidity()) {
-      DLOG(ERROR) << "Safe-browsing side-effect free whitelist database "
-                  << "corrupt.";
-    }
-
     if (ip_blacklist_store_ && !ip_blacklist_store_->CheckValidity()) {
       DLOG(ERROR) << "Safe-browsing IP blacklist database corrupt.";
     }
 
     if (unwanted_software_store_ &&
         !unwanted_software_store_->CheckValidity()) {
       DLOG(ERROR) << "Unwanted software url list database corrupt.";
     }
   }
 
@@ skipping 11 matching lines @@
     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 (side_effect_free_whitelist_store_)
-      side_effect_free_whitelist_store_->CancelUpdate();
     if (ip_blacklist_store_)
       ip_blacklist_store_->CancelUpdate();
     if (unwanted_software_store_)
       unwanted_software_store_->CancelUpdate();
     return;
   }
 
   if (download_store_) {
     UpdateHashPrefixStore(DownloadDBFilename(db_state_manager_.filename_base()),
                           download_store_.get(),
@@ skipping 15 matching lines @@
       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 (side_effect_free_whitelist_store_) {
-    UpdatePrefixSetUrlStore(
-        SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base()),
-        side_effect_free_whitelist_store_.get(),
-        PrefixSetId::SIDE_EFFECT_FREE_WHITELIST,
-        FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_FINISH,
-        FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_WRITE, false);
-  }
-
   if (ip_blacklist_store_)
     UpdateIpBlacklistStore();
 
   if (unwanted_software_store_) {
     UpdatePrefixSetUrlStore(
         UnwantedSoftwareDBFilename(db_state_manager_.filename_base()),
         unwanted_software_store_.get(), PrefixSetId::UNWANTED_SOFTWARE,
         FAILURE_UNWANTED_SOFTWARE_DATABASE_UPDATE_FINISH,
         FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_WRITE, true);
   }
@@ skipping 266 matching lines @@
   const bool r7 = base::DeleteFile(browse_prefix_set_filename, false);
   if (!r7)
     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)
     RecordFailure(FAILURE_EXTENSION_BLACKLIST_DELETE);
 
-  const base::FilePath side_effect_free_whitelist_filename =
-      SideEffectFreeWhitelistDBFilename(db_state_manager_.filename_base());
-  const bool r9 = base::DeleteFile(side_effect_free_whitelist_filename,
-                                   false);
+  const bool r9 = base::DeleteFile(
+      IpBlacklistDBFilename(db_state_manager_.filename_base()), false);
   if (!r9)
-    RecordFailure(FAILURE_SIDE_EFFECT_FREE_WHITELIST_DELETE);
-
-  const base::FilePath side_effect_free_whitelist_prefix_set_filename =
-      PrefixSetForFilename(side_effect_free_whitelist_filename);
-  const bool r10 = base::DeleteFile(
-      side_effect_free_whitelist_prefix_set_filename,
-      false);
-  if (!r10)
-    RecordFailure(FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_DELETE);
-
-  const bool r11 = base::DeleteFile(
-      IpBlacklistDBFilename(db_state_manager_.filename_base()), false);
-  if (!r11)
     RecordFailure(FAILURE_IP_BLACKLIST_DELETE);
 
-  const bool r12 = base::DeleteFile(
+  const bool r10 = base::DeleteFile(
       UnwantedSoftwareDBFilename(db_state_manager_.filename_base()), false);
-  if (!r12)
+  if (!r10)
     RecordFailure(FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_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;
 }
 
 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 134 matching lines @@
   else if (EndsWith(filename, kDownloadDBFile, true))
     histogram_name.append(".Download");
   else if (EndsWith(filename, kCsdWhitelistDBFile, true))
     histogram_name.append(".CsdWhitelist");
   else if (EndsWith(filename, kDownloadWhitelistDBFile, true))
     histogram_name.append(".DownloadWhitelist");
   else if (EndsWith(filename, kInclusionWhitelistDBFile, true))
     histogram_name.append(".InclusionWhitelist");
   else if (EndsWith(filename, kExtensionBlacklistDBFile, true))
     histogram_name.append(".ExtensionBlacklist");
-  else if (EndsWith(filename, kSideEffectFreeWhitelistDBFile, true))
-    histogram_name.append(".SideEffectFreeWhitelist");
   else if (EndsWith(filename, kIPBlacklistDBFile, true))
     histogram_name.append(".IPBlacklist");
   else if (EndsWith(filename, kUnwantedSoftwareDBFile, true))
     histogram_name.append(".UnwantedSoftware");
   else
     NOTREACHED();  // Add support for new lists above.
 
   // 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);
 }