[Sync] Add size and crc32c to AttachmentId.

sync/internal_api/attachments/attachment_downloader_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_downloader_impl.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 114 matching lines @@
   DCHECK(request == access_token_request_.get());
   access_token_request_.reset();
   StateList::const_iterator iter;
   // Without access token all downloads fail.
   for (iter = requests_waiting_for_access_token_.begin();
        iter != requests_waiting_for_access_token_.end();
        ++iter) {
     DownloadState* download_state = *iter;
     scoped_refptr<base::RefCountedString> null_attachment_data;
     ReportResult(*download_state, DOWNLOAD_TRANSIENT_ERROR,
-                 null_attachment_data, 0);
+                 null_attachment_data);
     DCHECK(state_map_.find(download_state->attachment_url) != state_map_.end());
     state_map_.erase(download_state->attachment_url);
   }
   requests_waiting_for_access_token_.clear();
 }
 
 void AttachmentDownloaderImpl::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 40 matching lines @@
                                                oauth2_scopes_,
                                                download_state.access_token);
     // Fail the request, but indicate that it may be successful if retried.
     result = DOWNLOAD_TRANSIENT_ERROR;
   } else if (response_code == net::HTTP_FORBIDDEN) {
     // User is not allowed to use attachments.  Retrying won't help.
     result = DOWNLOAD_UNSPECIFIED_ERROR;
   } else if (response_code == net::URLFetcher::RESPONSE_CODE_INVALID) {
     result = DOWNLOAD_TRANSIENT_ERROR;
   }
-  ReportResult(download_state, result, attachment_data, attachment_crc32c);
+  ReportResult(download_state, result, attachment_data);

[pavely, 2015/03/07 00:07:25]

I feel there should be a check here to make sure that crc calculated on data
matches crc from id.

[maniscalco, 2015/03/09 17:09:00]

Done and added test case to verify.

   state_map_.erase(iter);
 }
 
 scoped_ptr<net::URLFetcher> AttachmentDownloaderImpl::CreateFetcher(
     const AttachmentUrl& url,
     const std::string& access_token) {
   scoped_ptr<net::URLFetcher> url_fetcher(
       net::URLFetcher::Create(GURL(url), net::URLFetcher::GET, this));
   AttachmentUploaderImpl::ConfigureURLFetcherCommon(
       url_fetcher.get(), access_token, raw_store_birthday_, model_type_,
       url_request_context_getter_.get());
   return url_fetcher.Pass();
 }
 
 void AttachmentDownloaderImpl::RequestAccessToken(
     DownloadState* download_state) {
   requests_waiting_for_access_token_.push_back(download_state);
   // Start access token request if there is no active one.
   if (access_token_request_ == NULL) {
     access_token_request_ = OAuth2TokenServiceRequest::CreateAndStart(
         token_service_provider_.get(), account_id_, oauth2_scopes_, this);
   }
 }
 
 void AttachmentDownloaderImpl::ReportResult(
     const DownloadState& download_state,
     const DownloadResult& result,
-    const scoped_refptr<base::RefCountedString>& attachment_data,
-    uint32_t attachment_crc32c) {
+    const scoped_refptr<base::RefCountedString>& attachment_data) {
   std::vector<DownloadCallback>::const_iterator iter;
   for (iter = download_state.user_callbacks.begin();
        iter != download_state.user_callbacks.end();
        ++iter) {
     scoped_ptr<Attachment> attachment;
     if (result == DOWNLOAD_SUCCESS) {
       attachment.reset(new Attachment(Attachment::CreateFromParts(
-          download_state.attachment_id, attachment_data, attachment_crc32c)));
+          download_state.attachment_id, attachment_data)));
     }
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(*iter, result, base::Passed(&attachment)));
   }
 }
 
 bool AttachmentDownloaderImpl::ExtractCrc32c(
     const net::HttpResponseHeaders* headers,
     uint32_t* crc32c) {
@@ skipping 28 matching lines @@
 
   if (crc32c_raw.size() != sizeof(*crc32c))
     return false;
 
   *crc32c =
       base::NetToHost32(*reinterpret_cast<const uint32_t*>(crc32c_raw.c_str()));
   return true;
 }
 
 }  // namespace syncer