Revert of [Sync] Add size and crc32c to AttachmentId.

sync/internal_api/attachments/attachment_service_impl_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/attachment_service_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 61 matching lines @@
     AttachmentIdList ids = read_ids.back();
     read_callbacks.pop_back();
     read_ids.pop_back();
 
     scoped_ptr<AttachmentMap> attachments(new AttachmentMap());
     scoped_ptr<AttachmentIdList> unavailable_attachments(
         new AttachmentIdList());
     for (AttachmentIdList::const_iterator iter = ids.begin(); iter != ids.end();
          ++iter) {
       if (local_attachments.find(*iter) != local_attachments.end()) {
-        Attachment attachment = Attachment::CreateFromParts(*iter, data);
+        uint32_t crc32c = ComputeCrc32c(data);
+        Attachment attachment =
+            Attachment::CreateFromParts(*iter, data, crc32c);
         attachments->insert(std::make_pair(*iter, attachment));
       } else {
         unavailable_attachments->push_back(*iter);
       }
     }
     AttachmentStore::Result result = unavailable_attachments->empty()
                                          ? AttachmentStore::SUCCESS
                                          : AttachmentStore::UNSPECIFIED_ERROR;
 
     base::MessageLoop::current()->PostTask(
@@ skipping 35 matching lines @@
     download_requests.insert(std::make_pair(id, callback));
   }
 
   // Multiple requests to download will be active at the same time.
   // RespondToDownload should respond to only one of them.
   void RespondToDownload(const AttachmentId& id, const DownloadResult& result) {
     ASSERT_TRUE(download_requests.find(id) != download_requests.end());
     scoped_ptr<Attachment> attachment;
     if (result == DOWNLOAD_SUCCESS) {
       scoped_refptr<base::RefCountedString> data = new base::RefCountedString();
-      attachment.reset(new Attachment(Attachment::CreateFromParts(id, data)));
+      uint32_t crc32c = ComputeCrc32c(data);
+      attachment.reset(
+          new Attachment(Attachment::CreateFromParts(id, data, crc32c)));
     }
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(download_requests[id], result, base::Passed(&attachment)));
 
     download_requests.erase(id);
   }
 
   std::map<AttachmentId, DownloadCallback> download_requests;
 
@@ skipping 161 matching lines @@
   RunLoop();
   store()->RespondToRead(AttachmentIdSet());
 
   RunLoop();
   EXPECT_EQ(1U, download_results().size());
   EXPECT_EQ(0U, last_download_attachments().size());
 }
 
 TEST_F(AttachmentServiceImplTest, GetOrDownload_Local) {
   AttachmentIdList attachment_ids;
-  attachment_ids.push_back(AttachmentId::Create(0, 0));
+  attachment_ids.push_back(AttachmentId::Create());
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
   AttachmentIdSet local_attachments;
   local_attachments.insert(attachment_ids[0]);
   RunLoop();
   store()->RespondToRead(local_attachments);
 
   RunLoop();
   EXPECT_EQ(1U, download_results().size());
   EXPECT_EQ(1U, last_download_attachments().size());
   EXPECT_TRUE(last_download_attachments().find(attachment_ids[0]) !=
               last_download_attachments().end());
 }
 
 TEST_F(AttachmentServiceImplTest, GetOrDownload_LocalRemoteUnavailable) {
   // Create attachment list with 4 ids.
   AttachmentIdList attachment_ids;
-  attachment_ids.push_back(AttachmentId::Create(0, 0));
-  attachment_ids.push_back(AttachmentId::Create(0, 0));
-  attachment_ids.push_back(AttachmentId::Create(0, 0));
-  attachment_ids.push_back(AttachmentId::Create(0, 0));
+  attachment_ids.push_back(AttachmentId::Create());
+  attachment_ids.push_back(AttachmentId::Create());
+  attachment_ids.push_back(AttachmentId::Create());
+  attachment_ids.push_back(AttachmentId::Create());
   // Call attachment service.
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
   RunLoop();
   // Ensure AttachmentStore is called.
   EXPECT_FALSE(store()->read_ids.empty());
 
   // Make AttachmentStore return only attachment 0.
   AttachmentIdSet local_attachments;
   local_attachments.insert(attachment_ids[0]);
@@ skipping 46 matching lines @@
 }
 
 TEST_F(AttachmentServiceImplTest, GetOrDownload_NoDownloader) {
   // No downloader.
   InitializeAttachmentService(
       make_scoped_ptr<MockAttachmentUploader>(new MockAttachmentUploader()),
       make_scoped_ptr<MockAttachmentDownloader>(NULL),
       this);
 
   AttachmentIdList attachment_ids;
-  attachment_ids.push_back(AttachmentId::Create(0, 0));
+  attachment_ids.push_back(AttachmentId::Create());
   attachment_service()->GetOrDownloadAttachments(attachment_ids,
                                                  download_callback());
   RunLoop();
   EXPECT_FALSE(store()->read_ids.empty());
 
   AttachmentIdSet local_attachments;
   store()->RespondToRead(local_attachments);
   RunLoop();
   ASSERT_EQ(1U, download_results().size());
   EXPECT_EQ(AttachmentService::GET_UNSPECIFIED_ERROR, download_results()[0]);
   EXPECT_TRUE(last_download_attachments().empty());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_Success) {
   AttachmentIdSet attachment_ids;
   const unsigned num_attachments = 3;
   for (unsigned i = 0; i < num_attachments; ++i) {
-    attachment_ids.insert(AttachmentId::Create(0, 0));
+    attachment_ids.insert(AttachmentId::Create());
   }
   attachment_service()->UploadAttachments(attachment_ids);
 
   for (unsigned i = 0; i < num_attachments; ++i) {
     RunLoopAndFireTimer();
     // See that the service has issued a read for at least one of the
     // attachments.
     ASSERT_GE(store()->read_ids.size(), 1U);
     store()->RespondToRead(attachment_ids);
     RunLoop();
@@ skipping 13 matching lines @@
     EXPECT_THAT(on_attachment_uploaded_list(), testing::Contains(*iter));
   }
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_Success_NoDelegate) {
   InitializeAttachmentService(make_scoped_ptr(new MockAttachmentUploader()),
                               make_scoped_ptr(new MockAttachmentDownloader()),
                               NULL);  // No delegate.
 
   AttachmentIdSet attachment_ids;
-  attachment_ids.insert(AttachmentId::Create(0, 0));
+  attachment_ids.insert(AttachmentId::Create());
   attachment_service()->UploadAttachments(attachment_ids);
   RunLoopAndFireTimer();
   ASSERT_EQ(1U, store()->read_ids.size());
   ASSERT_EQ(0U, uploader()->upload_requests.size());
   store()->RespondToRead(attachment_ids);
   RunLoop();
   ASSERT_EQ(0U, store()->read_ids.size());
   ASSERT_EQ(1U, uploader()->upload_requests.size());
   uploader()->RespondToUpload(*attachment_ids.begin(),
                               AttachmentUploader::UPLOAD_SUCCESS);
   RunLoop();
   ASSERT_TRUE(on_attachment_uploaded_list().empty());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_SomeMissingFromStore) {
   AttachmentIdSet attachment_ids;
-  attachment_ids.insert(AttachmentId::Create(0, 0));
-  attachment_ids.insert(AttachmentId::Create(0, 0));
+  attachment_ids.insert(AttachmentId::Create());
+  attachment_ids.insert(AttachmentId::Create());
   attachment_service()->UploadAttachments(attachment_ids);
   RunLoopAndFireTimer();
   ASSERT_GE(store()->read_ids.size(), 1U);
 
   ASSERT_EQ(0U, uploader()->upload_requests.size());
   store()->RespondToRead(attachment_ids);
   RunLoop();
   ASSERT_EQ(1U, uploader()->upload_requests.size());
 
   uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                               AttachmentUploader::UPLOAD_SUCCESS);
   RunLoopAndFireTimer();
   ASSERT_EQ(1U, on_attachment_uploaded_list().size());
   ASSERT_GE(store()->read_ids.size(), 1U);
   // Not found!
   store()->RespondToRead(AttachmentIdSet());
   RunLoop();
   // No upload requests since the read failed.
   ASSERT_EQ(0U, uploader()->upload_requests.size());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_AllMissingFromStore) {
   AttachmentIdSet attachment_ids;
   const unsigned num_attachments = 2;
   for (unsigned i = 0; i < num_attachments; ++i) {
-    attachment_ids.insert(AttachmentId::Create(0, 0));
+    attachment_ids.insert(AttachmentId::Create());
   }
   attachment_service()->UploadAttachments(attachment_ids);
 
   for (unsigned i = 0; i < num_attachments; ++i) {
     RunLoopAndFireTimer();
     ASSERT_GE(store()->read_ids.size(), 1U);
     // None found!
     store()->RespondToRead(AttachmentIdSet());
   }
   RunLoop();
 
   // Nothing uploaded.
   EXPECT_EQ(0U, uploader()->upload_requests.size());
   // See that the delegate was never called.
   ASSERT_EQ(0U, on_attachment_uploaded_list().size());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_NoUploader) {
   InitializeAttachmentService(make_scoped_ptr<MockAttachmentUploader>(NULL),
                               make_scoped_ptr(new MockAttachmentDownloader()),
                               this);
 
   AttachmentIdSet attachment_ids;
-  attachment_ids.insert(AttachmentId::Create(0, 0));
+  attachment_ids.insert(AttachmentId::Create());
   attachment_service()->UploadAttachments(attachment_ids);
   RunLoop();
   EXPECT_EQ(0U, store()->read_ids.size());
   ASSERT_EQ(0U, on_attachment_uploaded_list().size());
 }
 
 // Upload three attachments.  For one of them, server responds with error.
 TEST_F(AttachmentServiceImplTest, UploadAttachments_OneUploadFails) {
   AttachmentIdSet attachment_ids;
   const unsigned num_attachments = 3;
   for (unsigned i = 0; i < num_attachments; ++i) {
-    attachment_ids.insert(AttachmentId::Create(0, 0));
+    attachment_ids.insert(AttachmentId::Create());
   }
   attachment_service()->UploadAttachments(attachment_ids);
 
   for (unsigned i = 0; i < 3; ++i) {
     RunLoopAndFireTimer();
     ASSERT_GE(store()->read_ids.size(), 1U);
     store()->RespondToRead(attachment_ids);
     RunLoop();
     ASSERT_EQ(1U, uploader()->upload_requests.size());
     AttachmentUploader::UploadResult result =
         AttachmentUploader::UPLOAD_SUCCESS;
     // Fail the 2nd one.
     if (i == 2U) {
       result = AttachmentUploader::UPLOAD_UNSPECIFIED_ERROR;
     } else {
       result = AttachmentUploader::UPLOAD_SUCCESS;
     }
     uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                                 result);
     RunLoop();
   }
   ASSERT_EQ(2U, on_attachment_uploaded_list().size());
 }
 
 // Attempt an upload, respond with transient error to trigger backoff, issue
 // network disconnect/connect events and see that backoff is cleared.
 TEST_F(AttachmentServiceImplTest,
        UploadAttachments_ResetBackoffAfterNetworkChange) {
   AttachmentIdSet attachment_ids;
-  attachment_ids.insert(AttachmentId::Create(0, 0));
+  attachment_ids.insert(AttachmentId::Create());
   attachment_service()->UploadAttachments(attachment_ids);
 
   RunLoopAndFireTimer();
   ASSERT_EQ(1U, store()->read_ids.size());
   store()->RespondToRead(attachment_ids);
   RunLoop();
   ASSERT_EQ(1U, uploader()->upload_requests.size());
 
   uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                               AttachmentUploader::UPLOAD_TRANSIENT_ERROR);
@@ skipping 16 matching lines @@
   net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   RunLoop();
 
   // No longer in backoff.
   ASSERT_TRUE(mock_timer()->IsRunning());
   ASSERT_EQ(base::TimeDelta(), mock_timer()->GetCurrentDelay());
 }
 
 }  // namespace syncer