SafeBrowsing PVer4: Send mutable response to the database and the stores

components/safe_browsing_db/v4_store.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/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/stringprintf.h"
@@ skipping 60 matching lines @@
                             state_base64.c_str());
 }
 
 bool V4Store::Reset() {
   // TODO(vakh): Implement skeleton.
   state_ = "";
   return true;
 }
 
 void V4Store::ApplyUpdate(
-    const ListUpdateResponse& response,
+    std::unique_ptr<ListUpdateResponse> response,
     const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
     UpdatedStoreReadyCallback callback) {
   std::unique_ptr<V4Store> new_store(
       new V4Store(this->task_runner_, this->store_path_));
 
-  // TODO(vakh): The new store currently only picks up the new state. Do more.
-  new_store->state_ = response.new_client_state();
-
-  // TODO(vakh): Merge the old store and the new update in new_store.
-  // Then, create a ListUpdateResponse containing RICE encoded hash-prefixes and
+  new_store->state_ = response->new_client_state();
+  // TODO(vakh):
+  // 1. Merge the old store and the new update in new_store.
+  // 2. Create a ListUpdateResponse containing RICE encoded hash-prefixes and
   // response_type as FULL_UPDATE, and write that to disk.
-  StoreWriteResult result = new_store->WriteToDisk(response);
-  RecordStoreWriteResult(result);
+  // 3. Remove this if condition after completing 1. and 2.
+  if (response->has_response_type() &&
+      response->response_type() == ListUpdateResponse::FULL_UPDATE) {
+    StoreWriteResult result = new_store->WriteToDisk(std::move(response));
+    RecordStoreWriteResult(result);
+  }
 
   // new_store is done updating, pass it to the callback.
   callback_task_runner->PostTask(
       FROM_HERE, base::Bind(callback, base::Passed(&new_store)));
 }
 
 StoreReadResult V4Store::ReadFromDisk() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   std::string contents;
@@ skipping 30 matching lines @@
   }
 
   ListUpdateResponse list_update_response = file_format.list_update_response();
   state_ = list_update_response.new_client_state();
   // TODO(vakh): Do more with what's read from the disk.
 
   return READ_SUCCESS;
 }
 
 StoreWriteResult V4Store::WriteToDisk(
-    const ListUpdateResponse& response) const {
+    std::unique_ptr<ListUpdateResponse> response) const {
   // Do not write partial updates to the disk.
   // After merging the updates, the ListUpdateResponse passed to this method
   // should be a FULL_UPDATE.
-  if (!response.has_response_type() ||
-      response.response_type() != ListUpdateResponse::FULL_UPDATE) {
-    DVLOG(1) << "response.has_response_type(): "
-             << response.has_response_type();
-    DVLOG(1) << "response.response_type(): " << response.response_type();
+  if (!response->has_response_type() ||
+      response->response_type() != ListUpdateResponse::FULL_UPDATE) {
+    DVLOG(1) << "response->has_response_type(): "
+             << response->has_response_type();
+    DVLOG(1) << "response->response_type(): " << response->response_type();
     return INVALID_RESPONSE_TYPE_FAILURE;
   }
 
   // Attempt writing to a temporary file first and at the end, swap the files.
   const base::FilePath new_filename = TemporaryFileForFilename(store_path_);
 
   V4StoreFileFormat file_format;
   file_format.set_magic_number(kFileMagic);
   file_format.set_version_number(kFileVersion);
   ListUpdateResponse* response_to_write =
       file_format.mutable_list_update_response();
-  *response_to_write = response;
+  response_to_write->Swap(response.get());
   std::string file_format_string;
   file_format.SerializeToString(&file_format_string);
   size_t written = base::WriteFile(new_filename, file_format_string.data(),
                                    file_format_string.size());
   DCHECK_EQ(file_format_string.size(), written);
 
   if (!base::Move(new_filename, store_path_)) {
     DVLOG(1) << "store_path_: " << store_path_.value();
     return UNABLE_TO_RENAME_FAILURE;
   }
 
   return WRITE_SUCCESS;
 }
 
 }  // namespace safe_browsing