Small: Delay checksum only on ReadFromDisk, not in FullUpdate cases

components/safe_browsing_db/v4_store_unittest.cc

 // Copyright 2016 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 "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 39 matching lines @@
           file_format.mutable_list_update_response();
       *list_update_response = *response;
     }
 
     std::string file_format_string;
     file_format.SerializeToString(&file_format_string);
     base::WriteFile(store_path_, file_format_string.data(),
                     file_format_string.size());
   }
 
-  void UpdatedStoreReadyAfterRiceRemovals(bool* called_back,
-                                          std::unique_ptr<V4Store> new_store) {
+  void UpdatedStoreReady(bool* called_back,
+                         bool expect_store,
+                         std::unique_ptr<V4Store> store) {
     *called_back = true;
-    EXPECT_EQ(2u, new_store->hash_prefix_map_.size());
-    EXPECT_EQ("22222", new_store->hash_prefix_map_[5]);
-    EXPECT_EQ("abcd", new_store->hash_prefix_map_[4]);
+    if (expect_store) {
+      ASSERT_TRUE(store);
+      EXPECT_EQ(2u, store->hash_prefix_map_.size());
+      EXPECT_EQ("22222", store->hash_prefix_map_[5]);
+      EXPECT_EQ("abcd", store->hash_prefix_map_[4]);
+    } else {
+      ASSERT_FALSE(store);
+    }
   }
 
   base::ScopedTempDir temp_dir_;
   base::FilePath store_path_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(V4StoreTest, TestReadFromEmptyFile) {
   base::CloseFile(base::OpenFile(store_path_, "wb+"));
@@ skipping 651 matching lines @@
   ThreatEntrySet* removal = lur->add_removals();
   removal->set_compression_type(RICE);
   RiceDeltaEncoding* rice_indices = removal->mutable_rice_indices();
   rice_indices->set_first_value(0);
   rice_indices->set_num_entries(2);
   rice_indices->set_rice_parameter(2);
   rice_indices->set_encoded_data("\x16");
 
   bool called_back = false;
   UpdatedStoreReadyCallback store_ready_callback =
-      base::Bind(&V4StoreTest::UpdatedStoreReadyAfterRiceRemovals,
-                 base::Unretained(this), &called_back);
+      base::Bind(&V4StoreTest::UpdatedStoreReady, base::Unretained(this),
+                 &called_back, true /* expect_store */);
   EXPECT_FALSE(base::PathExists(store.store_path_));
   store.ApplyUpdate(std::move(lur), task_runner_, store_ready_callback);
   EXPECT_TRUE(base::PathExists(store.store_path_));
 
   task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 
   // This ensures that the callback was called.
   EXPECT_TRUE(called_back);
 }
@@ skipping 60 matching lines @@
   EXPECT_TRUE(another_store.VerifyChecksum());
 }
 
 TEST_F(V4StoreTest, WriteToDiskFails) {
   // Pass the directory name as file name so that when the code tries to rename
   // the temp store file to |store_path_| it fails.
   EXPECT_EQ(UNABLE_TO_RENAME_FAILURE,
             V4Store(task_runner_, temp_dir_.GetPath()).WriteToDisk(Checksum()));
 }
 
+TEST_F(V4StoreTest, FullUpdateFailsChecksumSynchronously) {
+  V4Store store(task_runner_, store_path_);
+  bool called_back = false;
+  UpdatedStoreReadyCallback store_ready_callback =
+      base::Bind(&V4StoreTest::UpdatedStoreReady, base::Unretained(this),
+                 &called_back, false /* expect_store */);
+  EXPECT_FALSE(base::PathExists(store.store_path_));
+
+  // Now create a response with invalid checksum.
+  std::unique_ptr<ListUpdateResponse> lur(new ListUpdateResponse);
+  lur->set_response_type(ListUpdateResponse::FULL_UPDATE);
+  lur->mutable_checksum()->set_sha256(std::string(crypto::kSHA256Length, 0));
+  store.ApplyUpdate(std::move(lur), task_runner_, store_ready_callback);
+  // The update should fail synchronously and not create a store file.
+  EXPECT_FALSE(base::PathExists(store.store_path_));
+
+  // Run everything on the task runner to ensure there are no pending tasks.
+  task_runner_->RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
+
+  // This ensures that the callback was called.
+  EXPECT_TRUE(called_back);
+  // Ensure that the file is still not created.
+  EXPECT_FALSE(base::PathExists(store.store_path_));
+}
+
 }  // namespace safe_browsing