Update Commit and GetUpdatesResponse messages to include attachment ids.

sync/internal_api/sync_manager_impl_unittest.cc

 // Copyright 2012 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "sync/engine/sync_scheduler.h"
+#include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/internal_api/public/base/cancelation_signal.h"
 #include "sync/internal_api/public/base/model_type_test_util.h"
 #include "sync/internal_api/public/change_record.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/internal_api/public/events/protocol_event.h"
 #include "sync/internal_api/public/http_post_provider_factory.h"
 #include "sync/internal_api/public/http_post_provider_interface.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
@@ skipping 822 matching lines @@
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
     (*out)[NIGORI] = GROUP_PASSIVE;
     (*out)[DEVICE_INFO] = GROUP_PASSIVE;
     (*out)[EXPERIMENTS] = GROUP_PASSIVE;
     (*out)[BOOKMARKS] = GROUP_PASSIVE;
     (*out)[THEMES] = GROUP_PASSIVE;
     (*out)[SESSIONS] = GROUP_PASSIVE;
     (*out)[PASSWORDS] = GROUP_PASSIVE;
     (*out)[PREFERENCES] = GROUP_PASSIVE;
     (*out)[PRIORITY_PREFERENCES] = GROUP_PASSIVE;
+    (*out)[ARTICLES] = GROUP_PASSIVE;
   }
 
   ModelTypeSet GetEnabledTypes() {
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
     return GetRoutingInfoTypes(routing_info);
   }
 
   virtual void OnChangesApplied(
       ModelType model_type,
@@ skipping 1986 matching lines @@
 
   // Returns the current size of the change list.
   //
   // Note that spurious changes do not necessarily indicate a problem.
   // Assertions on change list size can help detect problems, but it may be
   // necessary to reduce their strictness if the implementation changes.
   size_t GetChangeListSize() {
     return last_changes_.Get().size();
   }
 
+  void ClearChangeList() { last_changes_ = ImmutableChangeRecordList(); }
+
  protected:
   ImmutableChangeRecordList last_changes_;
   TestIdFactory id_factory_;
 };
 
 // Test creation of a folder and a bookmark.
 TEST_F(SyncManagerChangeProcessingTest, AddBookmarks) {
   int64 type_root = GetIdForDataType(BOOKMARKS);
   int64 folder_id = kInvalidId;
   int64 child_id = kInvalidId;
@@ skipping 215 matching lines @@
       FindChangeInList(folder_a_id, ChangeRecord::ACTION_UPDATE);
   size_t folder_b_pos =
       FindChangeInList(folder_b_id, ChangeRecord::ACTION_DELETE);
   size_t child_pos = FindChangeInList(child_id, ChangeRecord::ACTION_DELETE);
 
   // Deletes should appear before updates.
   EXPECT_LT(child_pos, folder_a_pos);
   EXPECT_LT(folder_b_pos, folder_a_pos);
 }
 
+// See that attachment metadata changes are not filtered out by
+// SyncManagerImpl::VisiblePropertiesDiffer.
+TEST_F(SyncManagerChangeProcessingTest, AttachmentMetadataOnlyChanges) {
+  // Create an article with no attachments.  See that a change is generated.
+  int64 article_id = kInvalidId;
+  {
+    syncable::WriteTransaction trans(
+        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    int64 type_root = GetIdForDataType(ARTICLES);
+    syncable::Entry root(&trans, syncable::GET_BY_HANDLE, type_root);
+    ASSERT_TRUE(root.good());
+    syncable::MutableEntry article(
+        &trans, syncable::CREATE, ARTICLES, root.GetId(), "article");
+    ASSERT_TRUE(article.good());
+    SetNodeProperties(&article);
+    article_id = article.GetMetahandle();
+  }
+  ASSERT_EQ(1UL, GetChangeListSize());
+  FindChangeInList(article_id, ChangeRecord::ACTION_ADD);
+  ClearChangeList();
+
+  // Modify the article by adding one attachment.  Don't touch anything else.
+  // See that a change is generated.
+  {
+    syncable::WriteTransaction trans(
+        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::MutableEntry article(&trans, syncable::GET_BY_HANDLE, article_id);
+    sync_pb::AttachmentMetadata metadata;
+    *metadata.add_record()->mutable_id() = CreateAttachmentIdProto();
+    article.PutAttachmentMetadata(metadata);
+  }
+  ASSERT_EQ(1UL, GetChangeListSize());
+  FindChangeInList(article_id, ChangeRecord::ACTION_UPDATE);
+  ClearChangeList();
+
+  // Modify the article by replacing its attachment with a different one.  See
+  // that a change is generated.
+  {
+    syncable::WriteTransaction trans(
+        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::MutableEntry article(&trans, syncable::GET_BY_HANDLE, article_id);
+    sync_pb::AttachmentMetadata metadata = article.GetAttachmentMetadata();
+    *metadata.add_record()->mutable_id() = CreateAttachmentIdProto();
+    article.PutAttachmentMetadata(metadata);
+  }
+  ASSERT_EQ(1UL, GetChangeListSize());
+  FindChangeInList(article_id, ChangeRecord::ACTION_UPDATE);
+  ClearChangeList();
+
+  // Modify the article by replacing its attachment metadata with the same
+  // attachment metadata.  No change should be generated.
+  {
+    syncable::WriteTransaction trans(
+        FROM_HERE, syncable::SYNCER, share()->directory.get());
+    syncable::MutableEntry article(&trans, syncable::GET_BY_HANDLE, article_id);
+    article.PutAttachmentMetadata(article.GetAttachmentMetadata());
+  }
+  ASSERT_EQ(0UL, GetChangeListSize());
+}
+
 // During initialization SyncManagerImpl loads sqlite database. If it fails to
 // do so it should fail initialization. This test verifies this behavior.
 // Test reuses SyncManagerImpl initialization from SyncManagerTest but overrides
 // InternalComponentsFactory to return DirectoryBackingStore that always fails
 // to load.
 class SyncManagerInitInvalidStorageTest : public SyncManagerTest {
  public:
   SyncManagerInitInvalidStorageTest() {
   }
 
   virtual InternalComponentsFactory* GetFactory() OVERRIDE {
     return new TestInternalComponentsFactory(GetSwitches(), STORAGE_INVALID);
   }
 };
 
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer