Safebrowsing: change gethash caching to match api 2.3 rules, fix some corner cases.

chrome/browser/safe_browsing/safe_browsing_store_file.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_store_file.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
@@ skipping 424 matching lines @@
 // Helper to find the next shard boundary.
 template <class T>
 bool prefix_bounder(SBPrefix val, const T& elt) {
   return val < elt.GetAddPrefix();
 }
 
 // Container for partial database state.  Includes add/sub prefixes/hashes, plus
 // aggregate operations on same.
 class StateInternal {
  public:
-  explicit StateInternal(const std::vector<SBAddFullHash>& pending_adds)
-    : add_full_hashes_(pending_adds.begin(), pending_adds.end()) {
-  }
-
   StateInternal() {}
 
   // Append indicated amount of data from |fp|.
   bool AppendData(size_t add_prefix_count, size_t sub_prefix_count,
                   size_t add_hash_count, size_t sub_hash_count,
                   FILE* fp, base::MD5Context* context) {
     return
         ReadToContainer(&add_prefixes_, add_prefix_count, fp, context) &&
         ReadToContainer(&sub_prefixes_, sub_prefix_count, fp, context) &&
         ReadToContainer(&add_full_hashes_, add_hash_count, fp, context) &&
@@ skipping 313 matching lines @@
 
   StateInternal db_state;
   if (!ReadDbStateHelper(filename_, &db_state))
     return OnCorruptDatabase();
 
   add_full_hashes->swap(db_state.add_full_hashes_);
   return true;
 }
 
 bool SafeBrowsingStoreFile::WriteAddHash(int32 chunk_id,
-                                         base::Time receive_time,
                                          const SBFullHash& full_hash) {
-  add_hashes_.push_back(SBAddFullHash(chunk_id, receive_time, full_hash));
+  add_hashes_.push_back(SBAddFullHash(chunk_id, full_hash));
   return true;
 }
 
 bool SafeBrowsingStoreFile::WriteSubPrefix(int32 chunk_id,
                                            int32 add_chunk_id,
                                            SBPrefix prefix) {
   sub_prefixes_.push_back(SBSubPrefix(chunk_id, add_chunk_id, prefix));
   return true;
 }
 
@@ skipping 113 matching lines @@
       !WriteContainer(sub_hashes_, new_file_.get(), NULL))
     return false;
 
   ++chunks_written_;
 
   // Clear everything to save memory.
   return ClearChunkBuffers();
 }
 
 bool SafeBrowsingStoreFile::DoUpdate(
-    const std::vector<SBAddFullHash>& pending_adds,
     safe_browsing::PrefixSetBuilder* builder,
     std::vector<SBAddFullHash>* add_full_hashes_result) {
   DCHECK(file_.get() || empty_);
   DCHECK(new_file_.get());
   CHECK(builder);
   CHECK(add_full_hashes_result);
 
   // Rewind the temporary storage.
   if (!FileRewind(new_file_.get()))
     return false;
 
   // Get chunk file's size for validating counts.
   int64 update_size = 0;
   if (!base::GetFileSize(TemporaryFileForFilename(filename_), &update_size))
     return OnCorruptDatabase();
 
   // Track update size to answer questions at http://crbug.com/72216 .
   // Log small updates as 1k so that the 0 (underflow) bucket can be
   // used for "empty" in SafeBrowsingDatabase.
   UMA_HISTOGRAM_COUNTS("SB2.DatabaseUpdateKilobytes",
                        std::max(static_cast<int>(update_size / 1024), 1));
 
   // Chunk updates to integrate.
-  StateInternal new_state(pending_adds);
+  StateInternal new_state;
 
   // Read update chunks.
   for (int i = 0; i < chunks_written_; ++i) {
     ChunkHeader header;
 
     int64 ofs = ftell(new_file_.get());
     if (ofs == -1)
       return false;
 
     if (!ReadItem(&header, new_file_.get(), NULL))
@@ skipping 221 matching lines @@
     return false;
 
   // Record counts before swapping to caller.
   UMA_HISTOGRAM_COUNTS("SB2.AddPrefixes", add_prefix_count);
   UMA_HISTOGRAM_COUNTS("SB2.SubPrefixes", sub_prefix_count);
 
   return true;
 }
 
 bool SafeBrowsingStoreFile::FinishUpdate(
-    const std::vector<SBAddFullHash>& pending_adds,
     safe_browsing::PrefixSetBuilder* builder,
     std::vector<SBAddFullHash>* add_full_hashes_result) {
   DCHECK(builder);
   DCHECK(add_full_hashes_result);
 
-  if (!DoUpdate(pending_adds, builder, add_full_hashes_result)) {
+  if (!DoUpdate(builder, add_full_hashes_result)) {
     CancelUpdate();
     return false;
   }
 
   DCHECK(!new_file_.get());
   DCHECK(!file_.get());
 
   return Close();
 }
 
@@ skipping 53 matching lines @@
   // With SQLite support gone, one way to get to this code is if the
   // existing file is a SQLite file.  Make sure the journal file is
   // also removed.
   const base::FilePath journal_filename(
       basename.value() + FILE_PATH_LITERAL("-journal"));
   if (base::PathExists(journal_filename))
     base::DeleteFile(journal_filename, false);
 
   return true;
 }