Do not update AttachmentIds after uploading attachments to sync server.

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"
@@ skipping 169 matching lines @@
   virtual void SetUp();
   virtual void TearDown();
 
   // Run the message loop until UploadDone has been invoked |num_uploads| times.
   void RunAndWaitFor(int num_uploads);
 
   scoped_ptr<AttachmentUploader>& uploader();
   const AttachmentUploader::UploadCallback& upload_callback() const;
   std::vector<HttpRequest>& http_requests_received();
   std::vector<AttachmentUploader::UploadResult>& upload_results();
-  std::vector<AttachmentId>& updated_attachment_ids();
+  std::vector<AttachmentId>& attachment_ids();
   MockOAuth2TokenService& token_service();
   base::MessageLoopForIO& message_loop();
   RequestHandler& request_handler();
 
  private:
   // An UploadCallback invoked by AttachmentUploaderImpl.
   void UploadDone(const AttachmentUploader::UploadResult& result,
-                  const AttachmentId& updated_attachment_id);
+                  const AttachmentId& attachment_id);
 
   base::MessageLoopForIO message_loop_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   scoped_ptr<RequestHandler> request_handler_;
   scoped_ptr<AttachmentUploader> uploader_;
   AttachmentUploader::UploadCallback upload_callback_;
   net::test_server::EmbeddedTestServer server_;
   // A closure that signals an upload has finished.
   base::Closure signal_upload_done_;
   std::vector<HttpRequest> http_requests_received_;
   std::vector<AttachmentUploader::UploadResult> upload_results_;
-  std::vector<AttachmentId> updated_attachment_ids_;
+  std::vector<AttachmentId> attachment_ids_;
   scoped_ptr<MockOAuth2TokenService> token_service_;
 
   // Must be last data member.
   base::WeakPtrFactory<AttachmentUploaderImplTest> weak_ptr_factory_;
 };
 
 // Handles HTTP requests received by the EmbeddedTestServer.
 //
 // Responds with HTTP_OK by default.  See |SetStatusCode|.
 class RequestHandler : public base::NonThreadSafe {
@@ skipping 87 matching lines @@
 std::vector<HttpRequest>& AttachmentUploaderImplTest::http_requests_received() {
   return http_requests_received_;
 }
 
 std::vector<AttachmentUploader::UploadResult>&
 AttachmentUploaderImplTest::upload_results() {
   return upload_results_;
 }
 
 std::vector<AttachmentId>&
-AttachmentUploaderImplTest::updated_attachment_ids() {
-  return updated_attachment_ids_;
+AttachmentUploaderImplTest::attachment_ids() {
+  return attachment_ids_;
 }
 
 MockOAuth2TokenService& AttachmentUploaderImplTest::token_service() {
   return *token_service_;
 }
 
 base::MessageLoopForIO& AttachmentUploaderImplTest::message_loop() {
   return message_loop_;
 }
 
 RequestHandler& AttachmentUploaderImplTest::request_handler() {
   return *request_handler_;
 }
 
 void AttachmentUploaderImplTest::UploadDone(
     const AttachmentUploader::UploadResult& result,
-    const AttachmentId& updated_attachment_id) {
+    const AttachmentId& attachment_id) {
   DCHECK(CalledOnValidThread());
   upload_results_.push_back(result);
-  updated_attachment_ids_.push_back(updated_attachment_id);
+  attachment_ids_.push_back(attachment_id);
   DCHECK(!signal_upload_done_.is_null());
   signal_upload_done_.Run();
 }
 
 RequestHandler::RequestHandler(
     const scoped_refptr<base::SingleThreadTaskRunner>& test_task_runner,
     const base::WeakPtr<AttachmentUploaderImplTest>& test)
     : status_code_(net::HTTP_OK),
       test_task_runner_(test_task_runner),
       test_(test) {
@@ skipping 75 matching lines @@
   some_data->data() = kAttachmentData;
   Attachment attachment = Attachment::Create(some_data);
   uploader()->UploadAttachment(attachment, upload_callback());
 
   // Run until the done callback is invoked.
   RunAndWaitFor(1);
 
   // See that the done callback was invoked with the right arguments.
   ASSERT_EQ(1U, upload_results().size());
   EXPECT_EQ(AttachmentUploader::UPLOAD_SUCCESS, upload_results()[0]);
-  ASSERT_EQ(1U, updated_attachment_ids().size());
-  EXPECT_EQ(attachment.GetId(), updated_attachment_ids()[0]);
+  ASSERT_EQ(1U, attachment_ids().size());
+  EXPECT_EQ(attachment.GetId(), attachment_ids()[0]);
 
   // See that the HTTP server received one request.
   ASSERT_EQ(1U, http_requests_received().size());
   const HttpRequest& http_request = http_requests_received().front();
   EXPECT_EQ(net::test_server::METHOD_POST, http_request.method);
   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);
   const std::string header_name(kAuthorization);
   const std::string header_value(std::string("Bearer ") + kAccessToken);
   EXPECT_THAT(http_request.headers,
               testing::Contains(testing::Pair(header_name, header_value)));
-
-  // TODO(maniscalco): Once AttachmentUploaderImpl is capable of updating the
-  // AttachmentId with server address information about the attachment, add some
-  // checks here to verify it works properly (bug 371522).
 }
 
 // Verify two overlapping calls to upload the same attachment result in only one
 // HTTP request.
 TEST_F(AttachmentUploaderImplTest, UploadAttachment_Collapse) {
   token_service().AddAccount(kAccountId);
   request_handler().SetStatusCode(net::HTTP_OK);
 
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
@@ skipping 41 matching lines @@
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
   Attachment attachment = Attachment::Create(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_UNSPECIFIED_ERROR, upload_results()[0]);
-  ASSERT_EQ(1U, updated_attachment_ids().size());
-  EXPECT_EQ(attachment.GetId(), updated_attachment_ids()[0]);
+  ASSERT_EQ(1U, attachment_ids().size());
+  EXPECT_EQ(attachment.GetId(), attachment_ids()[0]);
 
   // See that no HTTP request was received.
   ASSERT_EQ(0U, http_requests_received().size());
 }
 
 // Verify behavior when the server returns "503 Service Unavailable".
 TEST_F(AttachmentUploaderImplTest, UploadAttachment_ServiceUnavilable) {
   token_service().AddAccount(kAccountId);
   request_handler().SetStatusCode(net::HTTP_SERVICE_UNAVAILABLE);
 
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
   Attachment attachment = Attachment::Create(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_UNSPECIFIED_ERROR, upload_results()[0]);
-  ASSERT_EQ(1U, updated_attachment_ids().size());
-  EXPECT_EQ(attachment.GetId(), updated_attachment_ids()[0]);
+  ASSERT_EQ(1U, attachment_ids().size());
+  EXPECT_EQ(attachment.GetId(), attachment_ids()[0]);
 
   // See that the HTTP server received one request.
   ASSERT_EQ(1U, http_requests_received().size());
   const HttpRequest& http_request = http_requests_received().front();
   EXPECT_EQ(net::test_server::METHOD_POST, http_request.method);
   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);
@@ skipping 16 matching lines @@
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
   Attachment attachment = Attachment::Create(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_UNSPECIFIED_ERROR, upload_results()[0]);
-  ASSERT_EQ(1U, updated_attachment_ids().size());
-  EXPECT_EQ(attachment.GetId(), updated_attachment_ids()[0]);
+  ASSERT_EQ(1U, attachment_ids().size());
+  EXPECT_EQ(attachment.GetId(), attachment_ids()[0]);
 
   // See that the HTTP server received one request.
   ASSERT_EQ(1U, http_requests_received().size());
   const HttpRequest& http_request = http_requests_received().front();
   EXPECT_EQ(net::test_server::METHOD_POST, http_request.method);
   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);
   std::string expected_header(kAuthorization);
   const std::string header_name(kAuthorization);
   const std::string header_value(std::string("Bearer ") + kAccessToken);
   EXPECT_THAT(http_request.headers,
               testing::Contains(testing::Pair(header_name, header_value)));
 
   // See that we invalidated the token.
   ASSERT_EQ(1, token_service().num_invalidate_token());
 }
 
 // TODO(maniscalco): Add test case for when we are uploading an attachment that
 // already exists.  409 Conflict? (bug 379825)
 
 }  // namespace syncer