Add per attachment metadata records.

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/api/attachments/attachment_store.h"
+#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"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "sync/internal_api/attachments/attachment_store_test_template.h"
 #include "sync/internal_api/attachments/proto/attachment_store.pb.h"
@@ skipping 86 matching lines @@
 
   std::string ReadStoreMetadataRecord(const base::FilePath& path) {
     scoped_ptr<leveldb::DB> db = OpenLevelDB(path);
     std::string content;
     leveldb::Status s =
         db->Get(leveldb::ReadOptions(), "database-metadata", &content);
     EXPECT_TRUE(s.ok());
     return content;
   }
 
+  void VerifyAttachmentRecordsPresent(const base::FilePath& path,
+                                      const AttachmentId& attachment_id,
+                                      bool expect_records_present) {
+    scoped_ptr<leveldb::DB> db = OpenLevelDB(path);
+
+    std::string metadata_key =
+        OnDiskAttachmentStore::MakeMetadataKeyFromAttachmentId(attachment_id);
+    std::string data_key =
+        OnDiskAttachmentStore::MakeDataKeyFromAttachmentId(attachment_id);
+    std::string data;
+    leveldb::Status s = db->Get(leveldb::ReadOptions(), data_key, &data);
+    if (expect_records_present)
+      EXPECT_TRUE(s.ok());
+    else
+      EXPECT_TRUE(s.IsNotFound());
+    s = db->Get(leveldb::ReadOptions(), metadata_key, &data);
+    if (expect_records_present)
+      EXPECT_TRUE(s.ok());
+    else
+      EXPECT_TRUE(s.IsNotFound());
+  }
+
   void RunLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 };
 
 // Ensure that store can be closed and reopen while retaining stored
 // attachments.
 TEST_F(OnDiskAttachmentStoreSpecificTest, CloseAndReopen) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
@@ skipping 82 matching lines @@
       base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&AttachmentStoreCreated, &store_, &result));
   RunLoop();
   EXPECT_EQ(result, AttachmentStore::SUCCESS);
   // Close AttachmentStore so that test can check content.
   store_ = nullptr;
   RunLoop();
 
   // AttachmentStore should create metadata record.
   std::string data = ReadStoreMetadataRecord(db_path);
-  attachment_store_pb::AttachmentStoreMetadata metadata;
+  attachment_store_pb::StoreMetadata metadata;
   EXPECT_TRUE(metadata.ParseFromString(data));
   EXPECT_EQ(metadata.schema_version(), 1);
 
   // Set unknown future schema version.
   metadata.set_schema_version(2);
   data = metadata.SerializeAsString();
   UpdateStoreMetadataRecord(db_path, data);
 
   // AttachmentStore should fail to load.
   result = AttachmentStore::SUCCESS;
@@ skipping 12 matching lines @@
   result = AttachmentStore::SUCCESS;
   AttachmentStore::CreateOnDiskStore(
       temp_dir_.path(),
       base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&AttachmentStoreCreated, &store_, &result));
   RunLoop();
   EXPECT_EQ(result, AttachmentStore::UNSPECIFIED_ERROR);
   EXPECT_EQ(store_.get(), nullptr);
 }
 
+TEST_F(OnDiskAttachmentStoreSpecificTest, RecordMetadata) {
+  ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+  base::FilePath db_path =
+      temp_dir_.path().Append(FILE_PATH_LITERAL("leveldb"));
+
+  // Create attachment store.
+  AttachmentStore::Result result = AttachmentStore::UNSPECIFIED_ERROR;
+  AttachmentStore::CreateOnDiskStore(
+      temp_dir_.path(),
+      base::ThreadTaskRunnerHandle::Get(),
+      base::Bind(&AttachmentStoreCreated, &store_, &result));
+  RunLoop();
+  EXPECT_EQ(result, AttachmentStore::SUCCESS);
+
+  // Write two attachments.
+  std::string some_data;
+  AttachmentList attachments;
+  some_data = "data1";
+  attachments.push_back(
+      Attachment::Create(base::RefCountedString::TakeString(&some_data)));
+  some_data = "data2";
+  attachments.push_back(
+      Attachment::Create(base::RefCountedString::TakeString(&some_data)));
+  store_->Write(attachments,
+                base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResult,
+                           base::Unretained(this),
+                           &result));
+  RunLoop();
+  EXPECT_EQ(result, AttachmentStore::SUCCESS);
+
+  // Delete one of written attachments.
+  AttachmentIdList attachment_ids;
+  attachment_ids.push_back(attachments[0].GetId());
+  store_->Drop(attachment_ids,
+               base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResult,
+                          base::Unretained(this),
+                          &result));
+  RunLoop();
+  EXPECT_EQ(result, AttachmentStore::SUCCESS);
+  store_ = nullptr;
+  RunLoop();
+
+  // Verify that attachment store contains only records for second attachment.
+  VerifyAttachmentRecordsPresent(db_path, attachments[0].GetId(), false);
+  VerifyAttachmentRecordsPresent(db_path, attachments[1].GetId(), true);
+}
+
 }  // namespace syncer