[Sync] Add size and crc32c to AttachmentId.

sync/internal_api/attachments/attachment_downloader_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_downloader_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 134 matching lines @@
  protected:
   typedef std::map<AttachmentId, AttachmentDownloader::DownloadResult>
       ResultsMap;
 
   enum HashHeaderType {
     HASH_HEADER_NONE,
     HASH_HEADER_VALID,
     HASH_HEADER_INVALID
   };
 
-  AttachmentDownloaderImplTest() : num_completed_downloads_(0) {}
+  AttachmentDownloaderImplTest()
+      : num_completed_downloads_(0),
+        attachment_id_(
+            Attachment::Create(new base::RefCountedStaticMemory(
+                                   kAttachmentContent,
+                                   strlen(kAttachmentContent))).GetId()) {}
 
   void SetUp() override;
   void TearDown() override;
 
   AttachmentDownloader* downloader() { return attachment_downloader_.get(); }
 
   MockOAuth2TokenService* token_service() { return token_service_.get(); }
 
   int num_completed_downloads() { return num_completed_downloads_; }
 
+  const AttachmentId attachment_id() const { return attachment_id_; }
+
   AttachmentDownloader::DownloadCallback download_callback(
       const AttachmentId& id) {
     return base::Bind(&AttachmentDownloaderImplTest::DownloadDone,
                       base::Unretained(this),
                       id);
   }
 
   // Respond with |response_code| and hash header of type |hash_header_type|.
   void CompleteDownload(int response_code, HashHeaderType hash_header_type);
 
@@ skipping 10 matching lines @@
   static void AddHashHeader(HashHeaderType hash_header_type,
                             net::TestURLFetcher* fetcher);
 
   base::MessageLoopForIO message_loop_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   net::TestURLFetcherFactory url_fetcher_factory_;
   scoped_ptr<MockOAuth2TokenService> token_service_;
   scoped_ptr<AttachmentDownloader> attachment_downloader_;
   ResultsMap download_results_;
   int num_completed_downloads_;
+  const AttachmentId attachment_id_;
 };
 
 void AttachmentDownloaderImplTest::SetUp() {
   url_request_context_getter_ =
       new net::TestURLRequestContextGetter(message_loop_.message_loop_proxy());
   url_fetcher_factory_.set_remove_fetcher_on_delete(true);
   token_service_.reset(new MockOAuth2TokenService());
   token_service_->AddAccount(kAccountId);
   scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider>
       token_service_provider(new TokenServiceProvider(token_service_.get()));
@@ skipping 81 matching lines @@
       break;
     case HASH_HEADER_INVALID:
       header += "BOGUS1==";
       headers->AddHeader(header);
       break;
   }
   fetcher->set_response_headers(headers);
 }
 
 TEST_F(AttachmentDownloaderImplTest, HappyCase) {
-  AttachmentId id1 = AttachmentId::Create();
+  AttachmentId id1 = attachment_id();
   // DownloadAttachment should trigger RequestAccessToken.
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   // Return valid access token.
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   // Catch histogram entries.
   base::HistogramTester histogram_tester;
   // Check that there is outstanding URLFetcher request and complete it.
   CompleteDownload(net::HTTP_OK, HASH_HEADER_VALID);
   // Verify that the response code was logged properly.
   histogram_tester.ExpectUniqueSample("Sync.Attachments.DownloadResponseCode",
                                       net::HTTP_OK, 1);
   // Verify that callback was called for the right id with the right result.
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_SUCCESS);
 }
 
 TEST_F(AttachmentDownloaderImplTest, SameIdMultipleDownloads) {
-  AttachmentId id1 = AttachmentId::Create();
+  AttachmentId id1 = attachment_id();
   base::HistogramTester histogram_tester;
   // Call DownloadAttachment two times for the same id.
   downloader()->DownloadAttachment(id1, download_callback(id1));
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   // Return valid access token.
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   // Start one more download after access token is received.
@@ skipping 16 matching lines @@
   // Complete URLFetcher request.
   CompleteDownload(net::HTTP_OK, HASH_HEADER_VALID);
   // Verify that all download requests completed.
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_SUCCESS);
   EXPECT_EQ(4, num_completed_downloads());
   histogram_tester.ExpectUniqueSample("Sync.Attachments.DownloadResponseCode",
                                       net::HTTP_OK, 2);
 }
 
 TEST_F(AttachmentDownloaderImplTest, RequestAccessTokenFails) {
-  AttachmentId id1 = AttachmentId::Create();
-  AttachmentId id2 = AttachmentId::Create();
+  AttachmentId id1 = attachment_id();
+  AttachmentId id2 = AttachmentId::Create(id1.GetSize(), id1.GetCrc32c());
   // Trigger first RequestAccessToken.
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   // Return valid access token.
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   // Trigger second RequestAccessToken.
   downloader()->DownloadAttachment(id2, download_callback(id2));
   RunMessageLoop();
   // Fail RequestAccessToken.
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError(GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS));
   RunMessageLoop();
   // Only id2 should fail.
   VerifyDownloadResult(id2, AttachmentDownloader::DOWNLOAD_TRANSIENT_ERROR);
   // Complete request for id1.
   CompleteDownload(net::HTTP_OK, HASH_HEADER_VALID);
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_SUCCESS);
 }
 
 TEST_F(AttachmentDownloaderImplTest, URLFetcher_BadToken) {
-  AttachmentId id1 = AttachmentId::Create();
+  AttachmentId id1 = attachment_id();
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   // Return valid access token.
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   // Fail URLFetcher. This should trigger download failure and access token
   // invalidation.
   base::HistogramTester histogram_tester;
   CompleteDownload(net::HTTP_UNAUTHORIZED, HASH_HEADER_VALID);
   EXPECT_EQ(1, token_service()->num_invalidate_token());
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_TRANSIENT_ERROR);
   histogram_tester.ExpectUniqueSample("Sync.Attachments.DownloadResponseCode",
                                       net::HTTP_UNAUTHORIZED, 1);
 }
 
 TEST_F(AttachmentDownloaderImplTest, URLFetcher_ServiceUnavailable) {
-  AttachmentId id1 = AttachmentId::Create();
+  AttachmentId id1 = attachment_id();
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   // Return valid access token.
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   // Fail URLFetcher. This should trigger download failure. Access token
   // shouldn't be invalidated.
   base::HistogramTester histogram_tester;
   CompleteDownload(net::HTTP_SERVICE_UNAVAILABLE, HASH_HEADER_VALID);
   EXPECT_EQ(0, token_service()->num_invalidate_token());
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_TRANSIENT_ERROR);
   histogram_tester.ExpectUniqueSample("Sync.Attachments.DownloadResponseCode",
                                       net::HTTP_SERVICE_UNAVAILABLE, 1);
 }
 
 // Verify that if no hash is present on the response the downloader accepts the
 // received attachment.
 TEST_F(AttachmentDownloaderImplTest, NoHash) {
-  AttachmentId id1 = AttachmentId::Create();
+  AttachmentId id1 = attachment_id();
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   CompleteDownload(net::HTTP_OK, HASH_HEADER_NONE);
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_SUCCESS);
 }
 
 // Verify that if an invalid hash is present on the response the downloader
 // treats it as a transient error.
 TEST_F(AttachmentDownloaderImplTest, InvalidHash) {
-  AttachmentId id1 = AttachmentId::Create();
+  AttachmentId id1 = attachment_id();
   downloader()->DownloadAttachment(id1, download_callback(id1));
   RunMessageLoop();
   token_service()->RespondToAccessTokenRequest(
       GoogleServiceAuthError::AuthErrorNone());
   RunMessageLoop();
   CompleteDownload(net::HTTP_OK, HASH_HEADER_INVALID);
   VerifyDownloadResult(id1, AttachmentDownloader::DOWNLOAD_TRANSIENT_ERROR);
 }
 
 // Verify that extract fails when there is no headers object.
@@ skipping 65 matching lines @@
   raw += "\n";
   std::replace(raw.begin(), raw.end(), '\n', '\0');
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(raw));
   uint32_t extracted;
   ASSERT_FALSE(
       AttachmentDownloaderImpl::ExtractCrc32c(headers.get(), &extracted));
 }
 
 }  // namespace syncer