[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 22 matching lines @@
 
     attachment_crc32c = ComputeCrc32c(attachment_data);
     uint32_t crc32c_from_headers = 0;
     if (ExtractCrc32c(source->GetResponseHeaders(), &crc32c_from_headers) &&
         attachment_crc32c != crc32c_from_headers) {
       // Fail download only if there is useful crc32c in header and it doesn't
       // match data. All other cases are fine. When crc32c is not in headers
       // locally calculated one will be stored and used for further checks.
       result = DOWNLOAD_TRANSIENT_ERROR;
     } else {
-      result = DOWNLOAD_SUCCESS;
+      // If the id's crc32c doesn't match that of the downloaded attachment,
+      // then we're stuck and retrying is unlikely to help.
+      if (attachment_crc32c != download_state.attachment_id.GetCrc32c()) {
+        result = DOWNLOAD_UNSPECIFIED_ERROR;
+      } else {
+        result = DOWNLOAD_SUCCESS;
+      }
     }
     UMA_HISTOGRAM_BOOLEAN("Sync.Attachments.DownloadChecksumResult",
                           result == DOWNLOAD_SUCCESS);
   } else if (response_code == net::HTTP_UNAUTHORIZED) {
     // Server tells us we've got a bad token so invalidate it.
     OAuth2TokenServiceRequest::InvalidateToken(token_service_provider_.get(),
                                                account_id_,
                                                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);
   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