Store attachment crc in AttachmentStore

sync/internal_api/attachments/attachment_uploader_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_uploader_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/oauth2_token_service_request.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/api/attachments/attachment.h"
+#include "sync/internal_api/public/attachments/attachment_util.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kAttachmentData[] = "some data";
 const char kAccountId[] = "some-account-id";
 const char kAccessToken[] = "some-access-token";
 const char kAuthorization[] = "Authorization";
@@ skipping 269 matching lines @@
     run_loop.Run();
   }
 }
 
 Attachment AttachmentUploaderImplTest::UploadAndRespondWith(
     const net::HttpStatusCode& status_code) {
   token_service().AddAccount(kAccountId);
   request_handler().SetStatusCode(status_code);
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
-  Attachment attachment = Attachment::Create(some_data);
+  Attachment attachment = Attachment::CreateNew(some_data);
   uploader()->UploadAttachment(attachment, upload_callback());
   return attachment;
 }
 
 scoped_ptr<AttachmentUploader>& AttachmentUploaderImplTest::uploader() {
   return uploader_;
 }
 
 const AttachmentUploader::UploadCallback&
 AttachmentUploaderImplTest::upload_callback() const {
@@ skipping 200 matching lines @@
 
 // Verify that we do not issue an HTTP request when we fail to receive an access
 // token.
 //
 // Token is requested, no token is returned, no HTTP request is made
 TEST_F(AttachmentUploaderImplTest, UploadAttachment_FailToGetToken) {
   // Note, we won't receive a token because we did not add kAccountId to the
   // token service.
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
-  Attachment attachment = Attachment::Create(some_data);
+  Attachment attachment = Attachment::CreateNew(some_data);
   uploader()->UploadAttachment(attachment, upload_callback());
 
   RunAndWaitFor(1);
 
   // See that the done callback was invoked.
   ASSERT_EQ(1U, upload_results().size());
   EXPECT_EQ(AttachmentUploader::UPLOAD_TRANSIENT_ERROR, upload_results()[0]);
   ASSERT_EQ(1U, attachment_ids().size());
   EXPECT_EQ(attachment.GetId(), attachment_ids()[0]);
 
@@ skipping 73 matching lines @@
   std::string expected_relative_url(kAttachments +
                                     attachment.GetId().GetProto().unique_id());
   EXPECT_EQ(expected_relative_url, http_request.relative_url);
   EXPECT_TRUE(http_request.has_content);
   EXPECT_EQ(kAttachmentData, http_request.content);
 
   // See that we invalidated the token.
   ASSERT_EQ(1, token_service().num_invalidate_token());
 }
 
 TEST_F(AttachmentUploaderImplTest, ComputeCrc32cHash) {

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

Rename test case to FormatCrc32Hash since that's what it's really testing?

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

Done.

   scoped_refptr<base::RefCountedString> empty(new base::RefCountedString);
   empty->data() = "";
   EXPECT_EQ("AAAAAA==",
-            AttachmentUploaderImpl::ComputeCrc32cHash(empty->front_as<char>(),
-                                                      empty->size()));
+            AttachmentUploaderImpl::FormatCrc32cHash(ComputeCrc32c(empty)));
 
   scoped_refptr<base::RefCountedString> hello_world(new base::RefCountedString);
   hello_world->data() = "hello world";
-  EXPECT_EQ("yZRlqg==",
-            AttachmentUploaderImpl::ComputeCrc32cHash(
-                hello_world->front_as<char>(), hello_world->size()));
+  EXPECT_EQ("yZRlqg==", AttachmentUploaderImpl::FormatCrc32cHash(
+                            ComputeCrc32c(hello_world)));
 }
 
 // TODO(maniscalco): Add test case for when we are uploading an attachment that
 // already exists.  409 Conflict? (bug 379825)
 
 }  // namespace syncer