Store attachment crc in AttachmentStore

sync/internal_api/attachments/attachment_uploader_impl.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/base64.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/non_thread_safe.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "sync/api/attachments/attachment.h"
 #include "sync/protocol/sync.pb.h"
-#include "third_party/leveldatabase/src/util/crc32c.h"
 
 namespace {
 
 const char kContentType[] = "application/octet-stream";
 const char kAttachments[] = "attachments/";
 
 }  // namespace
 
 namespace syncer {
 
@@ skipping 166 matching lines @@
   fetcher_->SetRequestContext(url_request_context_getter_.get());
   // TODO(maniscalco): Is there a better way?  Copying the attachment data into
   // a string feels wrong given how large attachments may be (several MBs).  If
   // we may end up switching from URLFetcher to URLRequest, this copy won't be
   // necessary.
   scoped_refptr<base::RefCountedMemory> memory = attachment_.GetData();
   const std::string upload_content(memory->front_as<char>(), memory->size());
   fetcher_->SetUploadData(kContentType, upload_content);
   const std::string auth_header("Authorization: Bearer " + access_token_);
   fetcher_->AddExtraRequestHeader(auth_header);
-  // TODO(maniscalco): Consider computing the hash once and storing the value as
-  // a new field in the Attachment object to avoid recomputing when an upload
-  // fails and is retried (bug 417794).
+  uint32_t crc = attachment_.GetCrc32c();

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

Can be made const.  Also, how about renaming to crc32c to remove ambiguity?

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

Done.

   fetcher_->AddExtraRequestHeader(base::StringPrintf(
-      "X-Goog-Hash: crc32c=%s",
-      ComputeCrc32cHash(memory->front_as<char>(), memory->size()).c_str()));
+      "X-Goog-Hash: crc32c=%s", FormatCrc32cHash(crc).c_str()));
   fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                          net::LOAD_DO_NOT_SEND_COOKIES |
                          net::LOAD_DISABLE_CACHE);
   // TODO(maniscalco): Set appropriate headers (e.g. User-Agent) on the request
   // and include the "sync birthday" (bug 371521).
   fetcher_->Start();
 }
 
 void AttachmentUploaderImpl::UploadState::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
@@ skipping 112 matching lines @@
   StateMap::iterator iter = state_map_.find(unique_id);
   // Only erase if stopped.  Because this method is called asynchronously, it's
   // possible that a new request for this same id arrived after the UploadState
   // stopped, but before this method was invoked.  In that case the UploadState
   // in the map might be a new one.
   if (iter != state_map_.end() && iter->second->IsStopped()) {
     state_map_.erase(iter);
   }
 }
 
-std::string AttachmentUploaderImpl::ComputeCrc32cHash(const char* data,
-                                                      size_t size) {
-  const uint32_t crc32c_big_endian =
-      base::HostToNet32(leveldb::crc32c::Value(data, size));
+std::string AttachmentUploaderImpl::FormatCrc32cHash(uint32_t crc) {

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

crc -> crc32c?

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

Done.

+  const uint32_t crc32c_big_endian = base::HostToNet32(crc);
   const base::StringPiece raw(reinterpret_cast<const char*>(&crc32c_big_endian),
                         sizeof(crc32c_big_endian));
   std::string encoded;
   base::Base64Encode(raw, &encoded);
   return encoded;
 }
 
 }  // namespace syncer