[Sync] Add size and crc32c to AttachmentId.

sync/internal_api/attachments/on_disk_attachment_store_unittest.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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 293 matching lines @@
   RunLoop();
   EXPECT_EQ(AttachmentStore::SUCCESS, create_result);
   EXPECT_EQ(AttachmentStore::SUCCESS, write_result);
   EXPECT_EQ(AttachmentStore::SUCCESS, drop_result);
 
   // Verify that attachment store contains only records for second attachment.
   VerifyAttachmentRecordsPresent(attachments[0].GetId(), false);
   VerifyAttachmentRecordsPresent(attachments[1].GetId(), true);
 }
 
-// Ensure that attachment store fails to load attachment with mismatched crc.
-TEST_F(OnDiskAttachmentStoreSpecificTest, MismatchedCrc) {
+// Ensure that attachment store fails to load attachment if the crc in the store
+// does not match the data.
+TEST_F(OnDiskAttachmentStoreSpecificTest, MismatchedCrcInStore) {
   // Create attachment store.
   AttachmentStore::Result create_result = AttachmentStore::UNSPECIFIED_ERROR;
   store_ = AttachmentStore::CreateOnDiskStore(
       temp_dir_.path(), base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&AttachmentStoreCreated, &create_result));
 
   // Write attachment with incorrect crc32c.
   AttachmentStore::Result write_result = AttachmentStore::UNSPECIFIED_ERROR;
   const uint32_t intentionally_wrong_crc32c = 0;
-  std::string some_data("data1");
+
+  scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString());
+  some_data->data() = "data1";
   Attachment attachment = Attachment::CreateFromParts(
-      AttachmentId::Create(), base::RefCountedString::TakeString(&some_data),
-      intentionally_wrong_crc32c);
+      AttachmentId::Create(some_data->size(), intentionally_wrong_crc32c),
+      some_data);
   AttachmentList attachments;
   attachments.push_back(attachment);
   store_->Write(attachments,
                 base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResult,
                            base::Unretained(this), &write_result));
 
   // Read attachment.
   AttachmentStore::Result read_result = AttachmentStore::UNSPECIFIED_ERROR;
   AttachmentIdList attachment_ids;
   attachment_ids.push_back(attachment.GetId());
   AttachmentIdList failed_attachment_ids;
   store_->Read(
       attachment_ids,
       base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResultAttachments,
                  base::Unretained(this), &read_result, &failed_attachment_ids));
   RunLoop();
   EXPECT_EQ(AttachmentStore::SUCCESS, create_result);
   EXPECT_EQ(AttachmentStore::SUCCESS, write_result);
   EXPECT_EQ(AttachmentStore::UNSPECIFIED_ERROR, read_result);
   EXPECT_THAT(failed_attachment_ids, testing::ElementsAre(attachment.GetId()));
 }
 
+// Ensure that attachment store fails to load attachment if the crc in the id
+// does not match the data.
+TEST_F(OnDiskAttachmentStoreSpecificTest, MismatchedCrcInId) {
+  // Create attachment store.
+  AttachmentStore::Result create_result = AttachmentStore::UNSPECIFIED_ERROR;
+  store_ = AttachmentStore::CreateOnDiskStore(
+      temp_dir_.path(), base::ThreadTaskRunnerHandle::Get(),
+      base::Bind(&AttachmentStoreCreated, &create_result));
+
+  AttachmentStore::Result write_result = AttachmentStore::UNSPECIFIED_ERROR;
+  scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString());
+  some_data->data() = "data1";
+  Attachment attachment = Attachment::Create(some_data);
+  AttachmentList attachments;
+  attachments.push_back(attachment);
+  store_->Write(attachments,
+                base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResult,
+                           base::Unretained(this), &write_result));
+
+  // Read, but with the wrong crc32c in the id.
+  AttachmentStore::Result read_result = AttachmentStore::SUCCESS;
+
+  AttachmentId id_with_bad_crc32c =
+      AttachmentId::Create(attachment.GetId().GetSize(), 12345);
+  AttachmentIdList attachment_ids;
+  attachment_ids.push_back(id_with_bad_crc32c);
+  AttachmentIdList failed_attachment_ids;
+  store_->Read(
+      attachment_ids,
+      base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResultAttachments,
+                 base::Unretained(this), &read_result, &failed_attachment_ids));
+  RunLoop();
+  EXPECT_EQ(AttachmentStore::SUCCESS, create_result);
+  EXPECT_EQ(AttachmentStore::SUCCESS, write_result);
+  EXPECT_EQ(AttachmentStore::UNSPECIFIED_ERROR, read_result);
+  EXPECT_THAT(failed_attachment_ids, testing::ElementsAre(id_with_bad_crc32c));
+}
+
 // Ensure that after store initialization failure ReadWrite/Drop operations fail
 // with correct error.
 TEST_F(OnDiskAttachmentStoreSpecificTest, OpsAfterInitializationFailed) {
   // To simulate corrupt database write empty CURRENT file.
   std::string current_file_content = "";
   base::WriteFile(db_path_.Append(FILE_PATH_LITERAL("CURRENT")),
                   current_file_content.c_str(), current_file_content.size());
 
   AttachmentStore::Result create_result = AttachmentStore::SUCCESS;
   store_ = AttachmentStore::CreateOnDiskStore(
       temp_dir_.path(), base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&AttachmentStoreCreated, &create_result));
 
   // Reading from uninitialized store should result in
   // STORE_INITIALIZATION_FAILED.
   AttachmentStore::Result read_result = AttachmentStore::SUCCESS;
   AttachmentIdList attachment_ids;
-  attachment_ids.push_back(AttachmentId::Create());
+  std::string some_data("data1");
+  Attachment attachment =
+      Attachment::Create(base::RefCountedString::TakeString(&some_data));
+  attachment_ids.push_back(attachment.GetId());
   AttachmentIdList failed_attachment_ids;
   store_->Read(
       attachment_ids,
       base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResultAttachments,
                  base::Unretained(this), &read_result, &failed_attachment_ids));
 
   // Dropping from uninitialized store should result in
   // STORE_INITIALIZATION_FAILED.
   AttachmentStore::Result drop_result = AttachmentStore::SUCCESS;
   store_->Drop(attachment_ids,
                base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResult,
                           base::Unretained(this), &drop_result));
 
   // Writing to uninitialized store should result in
   // STORE_INITIALIZATION_FAILED.
   AttachmentStore::Result write_result = AttachmentStore::SUCCESS;
-  std::string some_data;
   AttachmentList attachments;
-  some_data = "data1";
-  attachments.push_back(
-      Attachment::Create(base::RefCountedString::TakeString(&some_data)));
+  attachments.push_back(attachment);
   store_->Write(attachments,
                 base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResult,
                            base::Unretained(this), &write_result));
 
   RunLoop();
   EXPECT_EQ(AttachmentStore::UNSPECIFIED_ERROR, create_result);
   EXPECT_EQ(AttachmentStore::STORE_INITIALIZATION_FAILED, read_result);
   EXPECT_THAT(failed_attachment_ids, testing::ElementsAre(attachment_ids[0]));
   EXPECT_EQ(AttachmentStore::STORE_INITIALIZATION_FAILED, drop_result);
   EXPECT_EQ(AttachmentStore::STORE_INITIALIZATION_FAILED, write_result);
@@ skipping 68 matching lines @@
   store_->ReadAllMetadata(
       base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResultMetadata,
                  base::Unretained(this), &metadata_result, &metadata_list));
   RunLoop();
   EXPECT_EQ(AttachmentStore::SUCCESS, create_result);
   EXPECT_EQ(AttachmentStore::UNSPECIFIED_ERROR, metadata_result);
   EXPECT_EQ(2U, metadata_list->size());
 }
 
 }  // namespace syncer