Store attachment crc in AttachmentStore

sync/internal_api/attachments/on_disk_attachment_store.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/on_disk_attachment_store.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "sync/internal_api/attachments/proto/attachment_store.pb.h"
+#include "sync/internal_api/public/attachments/attachment_util.h"
 #include "sync/protocol/attachments.pb.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "third_party/leveldatabase/src/include/leveldb/slice.h"
 #include "third_party/leveldatabase/src/include/leveldb/status.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace syncer {
 
 namespace {
@@ skipping 181 matching lines @@
 
   db_ = db.Pass();
   return SUCCESS;
 }
 
 scoped_ptr<Attachment> OnDiskAttachmentStore::ReadSingleAttachment(
     const AttachmentId& attachment_id) {
   scoped_ptr<Attachment> attachment;
 
   const std::string key = MakeDataKeyFromAttachmentId(attachment_id);
+  const std::string metadata_key =
+      MakeMetadataKeyFromAttachmentId(attachment_id);
+  leveldb::Status status;
+  std::string metadata_str;
+  status = db_->Get(MakeMetadataReadOptions(), metadata_key, &metadata_str);
+  if (!status.ok()) {
+    DVLOG(1) << "DB::Get for metadata failed: status=" << status.ToString();
+    return attachment.Pass();
+  }
+  attachment_store_pb::RecordMetadata record_metadata;
+  if (!record_metadata.ParseFromString(metadata_str)) {
+    DVLOG(1) << "RecordMetadata::ParseFromString failed";
+    return attachment.Pass();
+  }
   std::string data_str;
-  leveldb::Status status = db_->Get(MakeDataReadOptions(), key, &data_str);
-  if (status.ok()) {
-    scoped_refptr<base::RefCountedMemory> data =
-        base::RefCountedString::TakeString(&data_str);
-    attachment.reset(
-        new Attachment(Attachment::CreateWithId(attachment_id, data)));
-  } else {
-    DVLOG(1) << "DB::Get failed: status=" << status.ToString();
+  status = db_->Get(MakeDataReadOptions(), key, &data_str);
+  if (!status.ok()) {
+    DVLOG(1) << "DB::Get for data failed: status=" << status.ToString();
+    return attachment.Pass();
   }
+  scoped_refptr<base::RefCountedMemory> data =
+      base::RefCountedString::TakeString(&data_str);
+  uint32_t crc = ComputeCrc32c(data);

[maniscalco, 2014/11/11 00:44:54]

crc -> crc32c

[pavely, 2014/11/11 22:27:15]

Done.

+  if (record_metadata.has_crc32c() && record_metadata.crc32c() != crc) {
+    DVLOG(1) << "Attachment crc does not match";
+    return attachment.Pass();
+  }
+  attachment.reset(
+      new Attachment(Attachment::RestoreExisting(attachment_id, data, crc)));
   return attachment.Pass();
 }
 
 bool OnDiskAttachmentStore::WriteSingleAttachment(
     const Attachment& attachment) {
   const std::string metadata_key =
       MakeMetadataKeyFromAttachmentId(attachment.GetId());
   const std::string data_key = MakeDataKeyFromAttachmentId(attachment.GetId());
 
   std::string metadata_str;
   leveldb::Status status =
       db_->Get(MakeMetadataReadOptions(), metadata_key, &metadata_str);
   if (status.ok()) {
     // Entry exists, don't overwrite.
     return true;
   } else if (!status.IsNotFound()) {
     // Entry exists but failed to read.
     DVLOG(1) << "DB::Get failed: status=" << status.ToString();
     return false;
   }
   DCHECK(status.IsNotFound());
 
   leveldb::WriteBatch write_batch;
   // Write metadata.
   attachment_store_pb::RecordMetadata metadata;
   metadata.set_attachment_size(attachment.GetData()->size());
+  metadata.set_crc32c(attachment.GetCrc32c());
   metadata_str = metadata.SerializeAsString();
   write_batch.Put(metadata_key, metadata_str);
   // Write data.
   scoped_refptr<base::RefCountedMemory> data = attachment.GetData();
   leveldb::Slice data_slice(data->front_as<char>(), data->size());
   write_batch.Put(data_key, data_slice);
 
   status = db_->Write(MakeWriteOptions(), &write_batch);
   if (!status.ok()) {
     // Failed to write.
     DVLOG(1) << "DB::Write failed: status=" << status.ToString();
     return false;
   }
   return true;
 }
 
 std::string OnDiskAttachmentStore::MakeDataKeyFromAttachmentId(
     const AttachmentId& attachment_id) {
   std::string key = kDataPrefix + attachment_id.GetProto().unique_id();
   return key;
 }
 
 std::string OnDiskAttachmentStore::MakeMetadataKeyFromAttachmentId(
     const AttachmentId& attachment_id) {
   std::string key = kMetadataPrefix + attachment_id.GetProto().unique_id();
   return key;
 }
 
 }  // namespace syncer